StyleControllerWidget.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 terralib/qt/widgets/se/StyleControllerWidget.cpp

  \brief A widget used to controll the style se element.
*/

// TerraLib
#include "StyleControllerWidget.h"
#include "../../../core/filesystem/FileSystem.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../../geometry/GeometryProperty.h"
#include "../../../fe.h"
#include "../../../se/FeatureTypeStyle.h"
#include "../../../se/Font.h"
#include "../../../se/Rule.h"
#include "../../../se/TextSymbolizer.h"
#include "../../../se/Utils.h"
#include "../../../se/Style.h"
#include "../../../se/Symbolizer.h"
#include "../../../se/serialization/xml/Style.h"
#include "../../../xml/AbstractWriter.h"
#include "../../../xml/AbstractWriterFactory.h"
#include "../../../xml/Reader.h"
#include "../../../xml/ReaderFactory.h"
#include "../../widgets/Utils.h"
#include "StyleExplorer.h"
#include "Symbol.h"
#include "SymbolPreviewWidget.h"
#include "SymbolSelectorDialog.h"

// TerraLib - UIC
#include "ui_StyleControllerWidgetForm.h"

// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QFile>
#include <QDir>
#include <QString>

// STL
#include <cassert>
#include <fstream>

// Boost
#include <boost/filesystem/operations.hpp>

te::qt::widgets::StyleControllerWidget::StyleControllerWidget(QWidget* parent, Qt::WindowFlags f)
  : QWidget(parent, f),
    m_ui(new Ui::StyleControllerWidgetForm),
    m_currentStyle(nullptr),
    m_currentLayer(nullptr)
{
  m_ui->setupUi(this);

  // Signals & slots
  connect(m_ui->m_explorer_frame->m_iconSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(changeLegendIconSize(int)));
  connect(m_ui->m_explorer_frame->m_addRuleToolButton, SIGNAL(clicked()), this, SLOT(onAddRuleClicked()));
  connect(m_ui->m_explorer_frame->m_removeRuleToolButton, SIGNAL(clicked()), this, SLOT(onRemoveRuleClicked()));
  connect(m_ui->m_explorer_frame->m_addTextSymbToolButton, SIGNAL(clicked()), this, SLOT(onAddTextSymbolizerClicked()));
  connect(m_ui->m_explorer_frame->m_addSymbToolButton, SIGNAL(clicked()), this, SLOT(onAddSymbolizerClicked()));
  connect(m_ui->m_explorer_frame->m_removeSymbToolButton, SIGNAL(clicked()), this, SLOT(onRemoveSymbolizerClicked()));
  connect(m_ui->m_explorer_frame->m_upSymbToolButton, SIGNAL(clicked()), this, SLOT(onUpSymbolizerClicked()));
  connect(m_ui->m_explorer_frame->m_downSymbToolButton, SIGNAL(clicked()), this, SLOT(onDownSymbolizerClicked()));
  connect(m_ui->m_explorer_frame->m_libManagerToolButton, SIGNAL(clicked()), this, SLOT(onLibraryManagerClicked()));
  connect(m_ui->m_explorer_frame->m_exportStyleToolButton, SIGNAL(clicked()), this, SLOT(onExportClicked()));
  connect(m_ui->m_explorer_frame->m_importStyleToolButton, SIGNAL(clicked()), this, SLOT(onImportClicked()));
  connect(m_ui->m_explorer_frame->m_mapRefreshToolButton, SIGNAL(clicked()), this, SLOT(onMapRefreshClicked()));
  connect(m_ui->m_visualStyleRadioButton, SIGNAL(clicked(bool)), SLOT(onVisualStyleChecked(bool)));
  connect(m_ui->m_selectionStyleRadioButton, SIGNAL(clicked(bool)), SLOT(onSelectionStyleChecked(bool)));

  m_ui->m_explorer_frame->m_addRuleToolButton->setEnabled(false);
  m_ui->m_explorer_frame->m_removeRuleToolButton->setEnabled(false);
}

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

void te::qt::widgets::StyleControllerWidget::setStyle(te::se::Style* style)
{
  m_currentStyle = style;
  m_currentLayer = nullptr;

  m_ui->m_explorer->setStyle(style);

  m_ui->m_visualStyleRadioButton->setEnabled(false);
  m_ui->m_selectionStyleRadioButton->setEnabled(false);

  m_ui->m_layerGroupBox->setVisible(false);
}

void te::qt::widgets::StyleControllerWidget::setLayer(te::map::AbstractLayer* layer, std::string selColor, te::se::Rule* currentRule)
{
  m_currentLayer = layer;

  if (!layer->getSelectionStyle())
  {
    std::unique_ptr<te::da::DataSetType> dsType = layer->getSchema();

    if (dsType->hasGeom())
    {
      te::gm::GeometryProperty* gp = te::da::GetFirstGeomProperty(dsType.get());

      te::se::Symbolizer* symbolizer = te::se::CreateSymbolizer(gp->getGeometryType(), selColor);

      te::se::Rule* rule = new te::se::Rule;

      if (symbolizer != nullptr)
        rule->push_back(symbolizer);

      te::se::FeatureTypeStyle* style = new te::se::FeatureTypeStyle;
      style->push_back(rule);

      layer->setSelectionStyle(style);

      m_ui->m_selectionStyleRadioButton->setEnabled(true);
    }
    else
    {
      m_ui->m_visualStyleRadioButton->setChecked(true);
      m_ui->m_selectionStyleRadioButton->setEnabled(false);
    }
  }
  else
  {
    m_ui->m_selectionStyleRadioButton->setEnabled(true);
  }

  if (m_ui->m_visualStyleRadioButton->isChecked())
  {
    m_ui->m_explorer->setStyle(layer->getStyle(), currentRule);

    m_currentStyle = layer->getStyle();
  }
  else
  {
    m_ui->m_explorer->setStyle(layer->getSelectionStyle(), currentRule);

    m_currentStyle = layer->getSelectionStyle();
  }

}

te::qt::widgets::StyleExplorer* te::qt::widgets::StyleControllerWidget::getStyleExplorer() const
{
  return m_ui->m_explorer;
}

void te::qt::widgets::StyleControllerWidget::onAddRuleClicked()
{
  if (!m_currentLayer)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a layer first."));
    return;
  }

  if (!m_currentStyle)
  {
    QMessageBox::information(this, tr("Style"), tr("Style not defined"));
    return;
  }

  //std::unique_ptr<te::da::DataSetType> schema(m_currentLayer->getSchema());

  //te::gm::GeometryProperty* geometryProperty = te::da::GetFirstGeomProperty(schema.get());

  //te::se::Rule* rule = new te::se::Rule;

  //std::string* ruleName = new std::string("SUDESTE");

  //rule->setName(ruleName);

  //te::fe::PropertyName* propName = new te::fe::PropertyName("NM_REGIAO");
  //te::fe::Literal* propValue = new te::fe::Literal("SUDESTE");
  //te::fe::PropertyIsEqualTo* equal = new te::fe::PropertyIsEqualTo(propName, propValue);
  //te::fe::Filter* filter = new te::fe::Filter();
  //filter->setOp(equal);

  //rule->setFilter(filter);

  //te::se::Symbolizer* symbolizer = te::se::CreateSymbolizer(geometryProperty->getGeometryType());


  //if (symbolizer)
  //  rule->push_back(symbolizer);

  te::se::Rule* rule = nullptr; // the new rule must be created by another component

  m_currentStyle->push_back(rule);

  m_ui->m_explorer->updateStyleTree();

  emit updateLayer();
}

void te::qt::widgets::StyleControllerWidget::onRemoveRuleClicked()
{
  if (!m_currentStyle)
  {
    QMessageBox::information(this, tr("Style"), tr("Style not defined"));
    return;
  }

  if (m_currentStyle->getRules().size() == 1)
  {
    QMessageBox::information(this, tr("Style"), tr("It is not possible to leave a style without rules."));
    return;
  }

  te::se::Rule* rule = m_ui->m_explorer->getCurrentRule();

  if (rule == nullptr)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a rule first."));
    return;
  }

  for (std::size_t t = 0; t < m_currentStyle->getRules().size(); ++t)
  {
    if (m_currentStyle->getRule(t) == rule)
    {
      m_currentStyle->removeRule(t);
      break;
    }
  }

  m_ui->m_explorer->updateStyleTree();

  emit updateLayer();
}

void te::qt::widgets::StyleControllerWidget::onAddTextSymbolizerClicked()
{
  te::se::Rule* rule = m_ui->m_explorer->getCurrentRule();

  if (rule == nullptr)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a rule first."));
    return;
  }

  //creates new text symbolizer representation
  te::se::Fill* fill = te::se::CreateFill("#000000", "1.0");
  te::se::Font* font = te::se::CreateFont("Arial", "8", te::se::Font::StyleNormal, te::se::Font::WeightNormal);
  te::se::Symbolizer* symb = te::se::CreateTextSymbolizer("", fill, font);

  rule->push_back(symb);

  m_ui->m_explorer->updateStyleTree();
}

void te::qt::widgets::StyleControllerWidget::onAddSymbolizerClicked()
{
  te::se::Rule* rule = m_ui->m_explorer->getCurrentRule();

  if(rule == nullptr)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a rule first."));
    return;
  }

  te::se::Symbolizer* symb = m_ui->m_explorer->getCurrentSymbolizer();
 
  if(symb)
    rule->push_back(symb->clone());
  else
  {
    assert(!rule->getSymbolizers().empty());

    const te::se::Symbolizer* symb = rule->getSymbolizer(0);
    assert(symb);

    rule->push_back(symb->clone());
  }

  m_ui->m_explorer->updateStyleTree();
}

void te::qt::widgets::StyleControllerWidget::onRemoveSymbolizerClicked()
{
   te::se::Symbolizer* symb = m_ui->m_explorer->getCurrentSymbolizer();

  if(symb == nullptr)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a symbol first."));
    return;
  }

  te::se::Rule* rule = m_ui->m_explorer->getCurrentRule();
  assert(rule);

  if(rule->getSymbolizers().size() == 1)
  {
    QMessageBox::information(this, tr("Style"), tr("The rule must have at least one symbol."));
    return;
  }

  for(std::size_t i = 0; i < rule->getSymbolizers().size(); ++i)
  {
    if(rule->getSymbolizer(i) == symb)
    {
      rule->removeSymbolizer(i);
      break;
    }
  }

  m_ui->m_explorer->updateStyleTree();
}

void te::qt::widgets::StyleControllerWidget::onUpSymbolizerClicked()
{
  te::se::Symbolizer* symb = m_ui->m_explorer->getCurrentSymbolizer();

  if(symb == nullptr)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a symbol first."));
    return;
  }

  m_ui->m_explorer->goUpSymbolizer();
}

void te::qt::widgets::StyleControllerWidget::onDownSymbolizerClicked()
{
  te::se::Symbolizer* symb = m_ui->m_explorer->getCurrentSymbolizer();

  if(symb == nullptr)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a symbol first."));
    return;
  }

  m_ui->m_explorer->goDownSymbolizer();
}

void te::qt::widgets::StyleControllerWidget::onLibraryManagerClicked()
{
  te::se::Rule* rule = m_ui->m_explorer->getCurrentRule();

  if(!rule)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a rule first."));
    return;
  }

  Symbol* symbol = te::qt::widgets::SymbolSelectorDialog::getSymbol(this, tr("Symbol Selector"));
  if(symbol == nullptr)
    return;

  std::vector<te::se::Symbolizer*> symbolizers;
  for(std::size_t i = 0; i < symbol->getSymbolizersCount(); ++i)
    symbolizers.push_back(symbol->getSymbolizer(i)->clone());

  rule->setSymbolizers(symbolizers);

  m_ui->m_explorer->updateStyleTree();
}

void te::qt::widgets::StyleControllerWidget::onExportClicked()
{  
  if (!m_currentStyle)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a layer first."));
    return;
  }

  QString styleFile = QFileDialog::getSaveFileName(this, tr("Save File"), te::qt::widgets::GetFilePathFromSettings("style"), "Style file (*.sld)");

  if (styleFile.isEmpty())
    return;

  QFileInfo info(styleFile);

  te::qt::widgets::AddFilePathToSettings(info.absolutePath(), "style");

  if (info.suffix().isEmpty())
    styleFile.append(".sld");

  writeStyle(m_currentStyle, styleFile.toUtf8().data());
}

void te::qt::widgets::StyleControllerWidget::onImportClicked()
{
  if (!m_currentLayer)
  {
    QMessageBox::information(this, tr("Style"), tr("Select a layer first."));
    return;
  }

  QString styleFile = QFileDialog::getOpenFileName(this, tr("Select a style file"), te::qt::widgets::GetFilePathFromSettings("style"), "Style file (*.sld)");

  QFileInfo info(styleFile);

  te::qt::widgets::AddFilePathToSettings(info.absolutePath(), "style");

  if (!styleFile.isEmpty())
    readStyle(styleFile.toUtf8().data());
  else
    return;
}

void te::qt::widgets::StyleControllerWidget::onMapRefreshClicked()
{
  emit mapRefresh();
}

void te::qt::widgets::StyleControllerWidget::changeLegendIconSize(int size)
{
  m_ui->m_explorer->setLegendIconSize(size);
}

void te::qt::widgets::StyleControllerWidget::onVisualStyleChecked(bool state)
{
  if (state && m_currentLayer && m_currentLayer->getStyle())
  {
    m_ui->m_explorer->setStyle(m_currentLayer->getStyle());
    m_currentStyle = m_currentLayer->getStyle();
  }
}

void te::qt::widgets::StyleControllerWidget::onSelectionStyleChecked(bool state)
{
  if (state && m_currentLayer && m_currentLayer->getSelectionStyle())
  {
    m_ui->m_explorer->setStyle(m_currentLayer->getSelectionStyle());
    m_currentStyle = m_currentLayer->getSelectionStyle();
  }
}

void te::qt::widgets::StyleControllerWidget::writeStyle(const te::se::Style* style, std::string path)
{
  boost::filesystem::wpath file = te::core::FileSystem::absolutePath(path);

  {
    std::unique_ptr<te::xml::AbstractWriter> writer(te::xml::AbstractWriterFactory::make());

    writer->setURI(file.string());
    writer->writeStartDocument("UTF-8", "no");

    writer->writeStartElement("StyledLayerDescriptor");

    writer->writeAttribute("xmlns", "http://www.opengis.net/sld");
    writer->writeAttribute("xmlns:ogc", "http://www.opengis.net/ogc");
    writer->writeAttribute("xmlns:se", "http://www.opengis.net/se");
    writer->writeAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
    writer->writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
    writer->writeAttribute("xsi:schemaLocation", "http://www.opengis.net/sld StyledLayerDescriptor.xsd");

    writer->writeAttribute("version", style->getVersion());

    writer->writeStartElement("NamedLayer");
    writer->writeStartElement("UserStyle");

    te::se::serialize::Style::getInstance().write(style, *writer.get());

    writer->writeEndElement("UserStyle");
    writer->writeEndElement("NamedLayer");

    writer->writeEndElement("StyledLayerDescriptor");
    writer->writeToFile();
  }
}

void te::qt::widgets::StyleControllerWidget::readStyle(std::string path)
{
  std::unique_ptr<te::se::Style> style;

  boost::filesystem::wpath file = te::core::FileSystem::absolutePath(path);
  {
    std::unique_ptr<te::xml::Reader> reader(te::xml::ReaderFactory::make());
    reader->setValidationScheme(false);

    reader->read(file.string());
    reader->next();

    if (!checkSymbolizer(file.string()))
    {
      QMessageBox::warning(this, tr("Style Explorer"), tr("The selected theme is not compatible with the current data."));
      return;
    }

    if ((reader->getNodeType() == te::xml::START_ELEMENT) &&
      (reader->getElementLocalName() == "StyledLayerDescriptor"))
      reader->next();

    if ((reader->getNodeType() == te::xml::START_ELEMENT) &&
      (reader->getElementLocalName() == "NamedLayer"))
      reader->next();

    if ((reader->getNodeType() == te::xml::START_ELEMENT) &&
      (reader->getElementLocalName() == "Name"))
    {
      reader->next();

      if(reader->getNodeType() == te::xml::VALUE)
        reader->next();

      if(reader->getNodeType() == te::xml::END_ELEMENT)
        reader->next();
    }

    if ((reader->getNodeType() == te::xml::START_ELEMENT) &&
      (reader->getElementLocalName() == "UserStyle"))
      reader->next();

    if ((reader->getNodeType() == te::xml::START_ELEMENT) &&
      (reader->getElementLocalName() == "Name"))
    {
      reader->next();

      if(reader->getNodeType() == te::xml::VALUE)
        reader->next();

      if(reader->getNodeType() == te::xml::END_ELEMENT)
        reader->next();
    }

    if ((reader->getNodeType() == te::xml::START_ELEMENT) &&
      (reader->getElementLocalName() == "FeatureTypeStyle"))
    {
      if (reader->getNodeType() == te::xml::START_ELEMENT)
        style.reset(te::se::serialize::Style::getInstance().read(*reader.get()));

      m_ui->m_explorer->importStyle(style.release(), m_ui->m_visualStyleRadioButton->isChecked());
    }
    else
    {
      QMessageBox::warning(this, tr("Style Explorer"), tr("The style contained unrecognized elements and could not be read."));
      return;
    }
  }
}

void te::qt::widgets::StyleControllerWidget::clear()
{
  m_currentStyle = nullptr;
  m_currentLayer = nullptr;

  m_ui->m_explorer->setStyle(nullptr);

  m_ui->m_visualStyleRadioButton->setEnabled(false);
  m_ui->m_selectionStyleRadioButton->setEnabled(false);

  m_ui->m_layerGroupBox->setVisible(false);
}

bool te::qt::widgets::StyleControllerWidget::checkSymbolizer(std::string file)
{
  std::string sldFile;
  std::ifstream t(file);
  std::stringstream buffer;
  buffer << t.rdbuf();

  sldFile = buffer.str();

  std::size_t found = sldFile.find(m_ui->m_explorer->getCurrentSymbolizer()->getType());

  if (found != std::string::npos)
    return true;
  else
    return false;
}