LayerItem.cpp

Go to the documentation of this file.

#include "LayerItem.h"

#include "ChartItem.h"
#include "StyleItem.h"

#include "../../se/SymbologyPreview.h"

#include "../../../../core/uri/URI.h"
#include "../../../../core/uri/Utils.h"
#include "../../../../dataaccess/datasource/DataSourceInfoManager.h"
#include "../../../../maptools/DataSetLayer.h"
#include "../../../../maptools/DataSetAdapterLayer.h"
#include "../../../../maptools/Utils.h"

#include "../../../../se/Style.h"
#include "../../../../se/Utils.h"

#include "../../../../srs/SpatialReferenceSystemManager.h"

QString GetDataSetName(te::map::AbstractLayerPtr l)
{
  // Gets the data set name
  QString toolTip = QObject::tr("DataSet") + ": " + ((l->getType() == "DATASETADAPTERLAYER") ?
                                              ((te::map::DataSetAdapterLayer*)l.get())->getDataSetName().c_str() :
                                              (l->getType() == "DATASETLAYER") ?
                                              ((te::map::DataSetLayer*)l.get())->getDataSetName().c_str() :
                                              "" + QString("\n"));
  return toolTip;
}

QString GetTooltip(te::map::AbstractLayerPtr l)
{
  // Gets the connection info
  const std::string& id = l->getDataSourceId();

  te::da::DataSourceInfoPtr info = te::da::DataSourceInfoManager::getInstance().get(id);
  const te::core::URI& connInfo = info->getConnInfo();

  QString toolTip = QObject::tr("Connection Info") + ":\n";

  toolTip += QObject::tr("\tScheme: ") + (connInfo.scheme() + "\n").c_str();

  if(!connInfo.user().empty())
    toolTip += QObject::tr("\tUser: ") + (connInfo.user() + "\n").c_str();

  if(!connInfo.host().empty())
  toolTip += QObject::tr("\tHost: ") + (connInfo.host() + "\n").c_str();

  if(!connInfo.port().empty())
    toolTip += QObject::tr("\tPort: ") + (connInfo.port() + "\n").c_str();

  if(!connInfo.path().empty())
    toolTip += QObject::tr("\tPath: ") + (connInfo.path() + "\n").c_str();

  std::map<std::string, std::string> kvp = te::core::Expand(connInfo.query());
  std::map<std::string, std::string>::iterator itBegin = kvp.begin();
  std::map<std::string, std::string>::iterator itEnd = kvp.end();

  while (itBegin != itEnd)
  {
    toolTip += itBegin->first.c_str();
    toolTip += ": ";
    toolTip += itBegin->second.c_str();
    toolTip += "\n";
    ++itBegin;
  }

  toolTip += QObject::tr("SRID: ");
  toolTip += QString::number(l->getSRID());
  toolTip += QObject::tr(" -  ");
  toolTip += QString(te::srs::SpatialReferenceSystemManager::getInstance().getName(l->getSRID()).c_str());

  return toolTip;
}


QString BuildToolIip(te::qt::widgets::LayerItem const* item)
{
  te::map::AbstractLayerPtr l = item->getLayer();

  if(!l->isValid())
    return QObject::tr("Invalid Layer");

  QString toolTip = GetDataSetName(l) +"\n"+ GetTooltip(l);

  return toolTip;
}

te::qt::widgets::LayerItem::LayerItem(te::map::AbstractLayerPtr layer) :
  TreeItem("LAYER"),
  m_layer(layer)
{
  if(!m_layer->isValid())
    return;

  if (m_layer->getStyle() != nullptr)
    addChild(new StyleItem(m_layer->getStyle()));

  updateChart();
}

te::qt::widgets::LayerItem::~LayerItem()
{
  std::vector<TreeItem*> items;
  getChildren(items, "CHART");

  if(!items.empty())
    ((*items.begin())->setParent(nullptr));

  items.clear();
  getChildren(items, "STYLE");

  if(!items.empty())
    ((*items.begin())->setParent(nullptr));
}

std::string te::qt::widgets::LayerItem::getAsString() const
{
  return m_layer->getTitle();
}

te::qt::widgets::VISIBLE te::qt::widgets::LayerItem::isVisible() const
{
  return (m_layer->getVisibility() == te::map::VISIBLE) ? TOTALLY : NONE;
}

void te::qt::widgets::LayerItem::setVisible(const VISIBLE& visible, const bool& updateAncestors, const bool&)
{
  m_layer->setVisibility((visible == TOTALLY) ? te::map::VISIBLE : te::map::NOT_VISIBLE);

  if(updateAncestors)
    m_parent->setVisible(visible, true);
}

Qt::ItemFlags te::qt::widgets::LayerItem::flags()
{
  return TreeItem::flags() | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsUserCheckable;
}

te::map::AbstractLayerPtr te::qt::widgets::LayerItem::getLayer() const
{
  return m_layer.get();
}

void te::qt::widgets::LayerItem::updateChart()
{
  std::vector<TreeItem*> items;

  getChildren(items, "LEGEND");

  if(m_layer->getChart() != nullptr)
    insertChild(new ChartItem(m_layer->getChart()), items.size());
}

int te::qt::widgets::LayerItem::updateLegend()
{
  StyleItem* si = new StyleItem(m_layer->getStyle());

  addChild(si);

  return si->getPosition();
}

std::string te::qt::widgets::LayerItem::getToolTip() const
{
  return BuildToolIip(this).toUtf8().data();
}