RuleItem.cpp

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

This file is part of the TerraLib - a Framework for building GIS enabled applications.

TerraLib is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License,
or (at your option) any later version.

TerraLib is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with TerraLib. See COPYING. If not, write to
TerraLib Team at <terralib-team@terralib.org>.
*/

/*!
* \file layer/explorer/RuleItem.cpp
*/

#include "RuleItem.h"

// TerraLib
#include "../../canvas/Canvas.h"
#include "../../canvas/MapDisplay.h"
#include "../../../../geometry/LineString.h"
#include "../../../../geometry/Point.h"
#include "../../../../geometry/Polygon.h"
#include "../../../../maptools/CanvasConfigurer.h"
#include "../../../../se/Description.h"
#include "../../../../se/FeatureTypeStyle.h"
#include "../../../../se/RasterSymbolizer.h"
#include "../../../../se/Rule.h"
#include "../../../../se/Symbolizer.h"
#include "ColorMapItem.h"

// Qt
#include <QObject>


te::gm::Geometry* GetRuleGeometry(const te::se::Symbolizer* s)
{
  if(s->getType() == "PointSymbolizer")
    return new te::gm::Point(10, 10);

  if(s->getType() == "LineSymbolizer")
  {
    te::gm::LineString* gm = new te::gm::LineString(4, te::gm::LineStringType);

    gm->setPoint(0, 0, 15);
    gm->setPoint(1, 6, 6);
    gm->setPoint(2, 12, 15);
    gm->setPoint(3, 18, 6);

    return gm;
  }

  te::gm::Polygon* gm = new te::gm::Polygon(1, te::gm::PolygonType);
  te::gm::LinearRing* ring = new te::gm::LinearRing(5, te::gm::LineStringType);

  ring->setPoint(0, 2, 18);
  ring->setPoint(1, 2, 2);
  ring->setPoint(2, 18, 2);
  ring->setPoint(3, 18, 18);
  ring->setPoint(4, 2, 18);

  gm->setRingN(0, ring);

  return gm;
}

QIcon GetRuleIcon(const std::vector<te::se::Symbolizer*>& symbolizers)
{
  te::qt::widgets::Canvas canvas(20, 20);

  // create a canvas configurer
  te::map::CanvasConfigurer cc(&canvas);

  // number of rules defined on feature type style
  std::size_t nSymbolizers = symbolizers.size();

  for(std::size_t j = 0; j < nSymbolizers; ++j) // for each <Symbolizer>
  {
    // the current symbolizer
    te::se::Symbolizer* symb = symbolizers[j];

    // let's config de canvas based on the current symbolizer
    cc.config(symb);

    if(symb->getType() == "RasterSymbolizer")
      return QIcon::fromTheme("raster-symbolizer");
  
    std::unique_ptr<te::gm::Geometry> gm(GetRuleGeometry(symb));

    canvas.draw(gm.get());
  } // end for each <Symbolizer>

  return QIcon(*canvas.getPixmap());
}

QIcon GetRuleIcon(const te::se::Rule* rule)
{
  return GetRuleIcon(rule->getSymbolizers());
}

te::qt::widgets::RuleItem::RuleItem(te::se::Rule* rule) :
TreeItem("RULE"),
m_rule(rule)
{
  m_icon = GetRuleIcon(rule);

  if(rule->getName())
    m_label = *rule->getName();
  else
    m_label = QObject::tr("Default Rule").toUtf8().data();

  const std::vector<te::se::Symbolizer*>& symbolizers = m_rule->getSymbolizers();

  if (!symbolizers.empty())
  {
    // for while, consider one raster symbolizer
    te::se::RasterSymbolizer* rasterSymbolizer = dynamic_cast<te::se::RasterSymbolizer*>(symbolizers[0]);

    if (rasterSymbolizer && rasterSymbolizer->getColorMap())
      addChild(new ColorMapItem(rasterSymbolizer->getColorMap()));
  }
}

te::qt::widgets::RuleItem::~RuleItem() = default;

std::string te::qt::widgets::RuleItem::getAsString() const
{
  return m_label;
}

Qt::ItemFlags te::qt::widgets::RuleItem::flags()
{
  return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled;
}

QIcon te::qt::widgets::RuleItem::getIcon() const
{
  return m_icon;
}

te::qt::widgets::VISIBLE te::qt::widgets::RuleItem::isVisible() const
{
  VISIBLE visible = TOTALLY;

  if (m_rule && m_rule->getMaxScaleDenominator() == 0.)
    visible = NONE;

  return visible;
}

void te::qt::widgets::RuleItem::setVisible(const VISIBLE& visible, const bool&, const bool&)
{
  if (visible == TOTALLY)
  {
    m_rule->setMinScaleDenominator(0.0);
    m_rule->setMaxScaleDenominator(std::numeric_limits<double>::infinity());
  }
  else
  {
    m_rule->setMinScaleDenominator(0.0);
    m_rule->setMaxScaleDenominator(0.0);
  }
}

std::string te::qt::widgets::RuleItem::getToolTip() const
{
  std::string toolTip;

  if (m_rule && m_rule->getDescription())
    toolTip = m_rule->getDescription()->getTitle();

  return toolTip;
}

te::se::Rule* te::qt::widgets::RuleItem::getRule()
{
  return m_rule;
}

void te::qt::widgets::RuleItem::updateSymbol(const te::se::Rule* rule)
{
  m_icon = GetRuleIcon(rule);
}

void te::qt::widgets::RuleItem::updateSymbol(const std::vector<te::se::Symbolizer*>& symbolizers)
{
  m_icon = GetRuleIcon(symbolizers);
}