src/terralib/qt/widgets/Utils.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 QtUtils.cpp
   
  \brief This file contains utility functions for dealing with Qt controls.
 */

// TerraLib
#include "../../common/STLUtils.h"
#include "../../common/StringUtils.h"
#include "../../maptools/MarkRendererManager.h"
#include "../../maptools/Canvas.h"
#include "../../se/Fill.h"
#include "../../se/Mark.h"
#include "../../se/Stroke.h"
#include "../../se/Utils.h"
#include "../../dataaccess/datasource/DataSourceCapabilities.h"
#include "../../dataaccess/datasource/DataSourceFactory.h"
#include "../../dataaccess/datasource/DataSource.h"
#include "../../common/StringUtils.h"
#include "layer/explorer/LayerItem.h"
#include "layer/explorer/LayerItemView.h"
#include "Utils.h"

// Qt
#include <QApplication>
#include <QActionGroup>
#include <QImage>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QPainter>
#include <QPen>
#include <QSettings>
#include <QTreeWidgetItem>
#include <QTreeWidgetItemIterator>
#include <QString>

//Boost
#include <boost/lexical_cast.hpp>

void te::qt::widgets::SetChildrenCheckState(QTreeWidgetItem* item, int column, Qt::CheckState state)
{
  if(item && item->child(0))
  {
    QTreeWidgetItemIterator it(item->child(0));
  
    while(*it)
    {
      (*it)->setCheckState(column, state);

      ++it;
    }
  }
}

QImage* te::qt::widgets::GetImage(te::color::RGBAColor** img, int width, int height)
{
  QImage* qimg = new QImage(width, height, QImage::Format_ARGB32);

  for(int i = 0; i < height; ++i)
  {
    unsigned char* u = qimg->scanLine(i);

    for(int j = 0; j < width; ++j)
    {
      te::color::RGBAColor c = img[i][j];
      QRgb val = qRgba(c.getRed(), c.getGreen(), c.getBlue(), c.getAlpha());
      QRgb* v = (QRgb*)(u+j*4);
      *v = val;
    }
  }

  return qimg;
}

te::color::RGBAColor** te::qt::widgets::GetImage(QImage* img)
{
  te::color::RGBAColor** rgba = new te::color::RGBAColor*[img->height()];
  for(int i = 0; i < img->height(); ++i)
  {
    te::color::RGBAColor* s = new te::color::RGBAColor[img->width()];

    for(int j = 0; j < img->width(); ++j)
      s[j] = img->pixel(j, i);

    rgba[i] = s;
  }

  return rgba;
}

QStyle::StandardPixmap toQStyle(const QMessageBox::Icon& icon)
{
  switch(icon)
  {
    case QMessageBox::Question:
      return QStyle::SP_MessageBoxQuestion;
    break;

    case QMessageBox::Warning:
      return QStyle::SP_MessageBoxWarning;
    break;

    case QMessageBox::Critical:
      return QStyle::SP_MessageBoxCritical;
    break;

    default:
      return QStyle::SP_MediaVolumeMuted;
    break;
  }
}

QMenu* te::qt::widgets::FindMenu(const QString& mnuText, QMenu* mnu)
{
  return mnu->findChild<QMenu*>(mnuText);
}

QMenu* te::qt::widgets::FindMenu(const QString& mnuText, QMenuBar* bar)
{
  return bar->findChild<QMenu*>(mnuText);
}

QAction* te::qt::widgets::FindAction(const QString& actText, QMenu* mnu)
{
  return mnu->findChild<QAction*>(actText);
}

QAction* te::qt::widgets::FindAction(const QString& actText, QMenuBar* mnuBar)
{
  return mnuBar->findChild<QAction*>(actText);
}

QActionGroup* te::qt::widgets::FindActionGroup(const QString& actGroupText, QMenu* mnu)
{
  return mnu->findChild<QActionGroup*>(actGroupText);
}

QActionGroup* te::qt::widgets::FindActionGroup(const QString& actGroupText, QMenuBar* mnuBar)
{
  return mnuBar->findChild<QActionGroup*>(actGroupText);
}

QMenu* CreateMenu(const QString& mnuName, QMenu* p)
{
  QMenu* mnu = p->findChild<QMenu*>(mnuName);

  if(mnu == nullptr)
  {
    QStringList ls = mnuName.split("."); 
    mnu = p->addMenu(ls[ls.size()-1]);

    mnu->setObjectName(mnuName);
  }

  return mnu;
}

QMenu* CreateMenu(const QString& mnuName, QMenuBar* p)
{
  QMenu* mnu = te::qt::widgets::FindMenu(mnuName, p);

  if(mnu == nullptr)
  {
    QStringList ls = mnuName.split("."); 
    mnu = new QMenu(ls[ls.size()-1], p);
    mnu->setObjectName(mnuName);

    QMenu* helpMnu = te::qt::widgets::FindMenu("Help", p);

    QAction* act = (helpMnu == nullptr) ? nullptr : helpMnu->menuAction();
     
    p->insertMenu(act, mnu);
  }

  return mnu;
}

QMenu* te::qt::widgets::GetMenu(const QString& mnuText, QMenu* mnu)
{
  QMenu* res = FindMenu(mnuText, mnu);

  QStringList mnus = mnuText.split('.');

  for(int i=1; i<mnus.size(); i++)
    mnus[i] = mnus[i-1] + "." + mnus[i];

  for(int i=0; i<mnus.size(); i++)
    res = (i == 0) ? 
      CreateMenu(mnus[i], mnu) : 
      CreateMenu(mnus[i], res);

  return res;
}

QMenu* te::qt::widgets::GetMenu(const QString& mnuText, QMenuBar* bar)
{
  QMenu* res = FindMenu(mnuText, bar);

  QStringList mnus = mnuText.split('.');

  for(int i=1; i<mnus.size(); i++)
    mnus[i] = mnus[i-1] + "." + mnus[i];

  for(int i=0; i<mnus.size(); i++)
  {
    res = (i == 0) ?
      CreateMenu(mnus[i], bar) :
      CreateMenu(mnus[i], res);
  }
  return res;
}

te::color::RGBAColor te::qt::widgets::Convert2TerraLib(const QColor& color)
{
  return te::color::RGBAColor(color.red(), color.green(), color.blue(), color.alpha());
}

QColor te::qt::widgets::Convert2Qt(const te::color::RGBAColor& color)
{
  QColor qcolor(color.getRgba());
  qcolor.setAlpha(qAlpha(color.getRgba()));
  return qcolor;
}

void te::qt::widgets::Config2DrawPolygons(te::map::Canvas* canvas, const QColor& fillColor, const QColor& contourColor, const std::size_t& contourWidth)
{
  canvas->setPolygonContourWidth((int)contourWidth);
  canvas->setPolygonContourColor(Convert2TerraLib(contourColor));
  canvas->setPolygonFillColor(Convert2TerraLib(fillColor));
}

void te::qt::widgets::Config2DrawLines(te::map::Canvas* canvas, const QColor& color, const std::size_t& width)
{
  canvas->setLineWidth((int)width);
  canvas->setLineColor(Convert2TerraLib(color));
}

void te::qt::widgets::Config2DrawPoints(te::map::Canvas* canvas, const QColor& color, const std::size_t& width)
{
  canvas->setPointWidth((int)width);
  canvas->setPointColor(Convert2TerraLib(color));
}

void te::qt::widgets::Config2DrawPoints(te::map::Canvas* canvas, const QString& markName, const std::size_t& size,
                                        const QColor& fillColor, const QColor& contourColor, const std::size_t& contourWidth)
{
  te::se::Stroke* stroke = te::se::CreateStroke(contourColor.name().toUtf8().data(),
                                                QString::number(contourWidth).toUtf8().data(),
                                                QString::number(contourColor.alphaF()).toUtf8().data());

  te::se::Fill* fill = te::se::CreateFill(fillColor.name().toUtf8().data(),
                                          QString::number(fillColor.alphaF()).toUtf8().data());

  te::se::Mark* mark = te::se::CreateMark(markName.toUtf8().data(), stroke, fill);

  te::color::RGBAColor** rgba = te::map::MarkRendererManager::getInstance().render(mark, size);

  canvas->setPointColor(te::color::RGBAColor(0, 0, 0, TE_TRANSPARENT));
  canvas->setPointPattern(rgba, (int)size, (int)size);

  te::common::Free(rgba, size);

  delete mark;
}

void te::qt::widgets::Config2DrawLayerSelection(te::map::Canvas* canvas, const QColor& selectionColor, const te::gm::GeomType& type)
{
  switch(type)
  {
    case te::gm::PolygonType:
    case te::gm::PolygonZType:
    case te::gm::PolygonMType:
    case te::gm::PolygonZMType:
    case te::gm::MultiPolygonType:
    case te::gm::MultiPolygonZType:
    case te::gm::MultiPolygonMType:
    case te::gm::MultiPolygonZMType:
    {
      QColor fillColor = selectionColor;

      Config2DrawPolygons(canvas, fillColor, Qt::black, 2);
    }
    break;

    case te::gm::LineStringType:
    case te::gm::LineStringZType:
    case te::gm::LineStringMType:
    case te::gm::LineStringZMType:
    case te::gm::MultiLineStringType:
    case te::gm::MultiLineStringZType:
    case te::gm::MultiLineStringMType:
    case te::gm::MultiLineStringZMType:
    {
      QColor fillColor = selectionColor;

      Config2DrawLines(canvas, fillColor, 6);
    }
    break;

    case te::gm::PointType:
    case te::gm::PointZType:
    case te::gm::PointMType:
    case te::gm::PointZMType:
    case te::gm::MultiPointType:
    case te::gm::MultiPointZType:
    case te::gm::MultiPointMType:
    case te::gm::MultiPointZMType:
    {
      QColor fillColor = selectionColor;

      QColor contourColor = selectionColor;
      contourColor.setAlpha(150);

      Config2DrawPoints(canvas, "square", 24, fillColor, contourColor,2);
    }
    break;

    default:
      return;
  }
}

QPixmap te::qt::widgets::CreatePixmapIcon(const int& size, const QColor& penColor, const QColor& brushColor, const int& contourSize)
{
  QPixmap pix(size, size);
  pix.fill(Qt::transparent);

  int offset = 2;

  QPainterPath path;
  path.addRect(offset, offset, pix.width() -  2 * offset, pix.height() - 2 * offset);

  QPen pen;
  pen.setColor(penColor);
  pen.setWidth(contourSize);

  QBrush brush;
  brush.setColor(brushColor);

  QPainter p(&pix);
  p.setPen(pen);
  p.setBrush(brushColor);

  p.fillPath(path, brush);
  p.drawPath(path);
    
  return pix;
}

void te::qt::widgets::AddFilePathToSettings(const QString& path, const QString& typeFile)
{
  QSettings sett(QSettings::IniFormat, QSettings::UserScope, qApp->organizationName(), qApp->applicationName());

  QString key = "Last used file path/" + typeFile;

  sett.setValue(key, path);
}

QString te::qt::widgets::GetFilePathFromSettings(const QString& typeFile)
{
  QSettings sett(QSettings::IniFormat, QSettings::UserScope, qApp->organizationName(), qApp->applicationName());

  QString key = "Last used file path/" + typeFile;

  return sett.value(key).toString();
}

QString te::qt::widgets::Convert2Qt(const std::string& text, te::core::EncodingType encoding)
{
  std::string conv_text = text;

  if (encoding != te::core::EncodingType::UTF8)
    conv_text = te::core::CharEncoding::toUTF8(text, encoding);

  return QString::fromUtf8(conv_text.c_str());
}

QString te::qt::widgets::GetDiskRasterFileSelFilter( const bool creationSupport )
{
  QString filter;
  
  if( te::da::DataSourceFactory::find( "GDAL" ) )
  {
    std::unique_ptr< te::da::DataSource > dsPtr = te::da::DataSourceFactory::make( "GDAL", "file://" );
    
    if( dsPtr.get() )
    {
      std::map< std::string, std::string > specCap = dsPtr->getCapabilities().getSpecificCapabilities();

      const std::string extensionName = creationSupport ?
        std::string( "SUPPORTED_RASTER_CREATION_EXTENSIONS" ) :
        std::string( "SUPPORTED_RASTER_EXTENSIONS" );
      
      if( specCap.find( extensionName ) != specCap.end() )
      {
        std::string fileExtensions = specCap[ extensionName ];
        std::string extFilter;
        std::string uCaseToken;
        std::string lCaseToken;
        std::vector< std::string > tokens;
        te::common::Tokenize( fileExtensions, tokens, ";" );
        
        for( unsigned int tokensIdx = 0 ; tokensIdx < tokens.size() ; ++tokensIdx )
        {
          uCaseToken = te::common::Convert2UCase( tokens[ tokensIdx ] );
          lCaseToken = te::common::Convert2LCase( tokens[ tokensIdx ] );
          extFilter = uCaseToken + " Raster File (" + "*." + lCaseToken + " *." +
            uCaseToken + ")";
          
          if( uCaseToken == "TIF" )
          {
            filter = QString( extFilter.c_str() ) + ( filter.isEmpty() ? "" : ";;" ) + filter;
          }
          else
          {
            filter += ( filter.isEmpty() ? "" : ";;" ) + QString( extFilter.c_str() );
          }
        }
      }
    }
  }
  
  filter += QString( ( filter.isEmpty() ? "" : ";;" ) ) + 
    "Web Map Service - WMS (*.xml *.wms);;Web Coverage Service - WCS (*.xml *.wcs);;All Files (*.*)";
  
  return filter;
}

QString te::qt::widgets::GetDiskVectorFileSelFilter()
{
  QString filter;

  if( te::da::DataSourceFactory::find( "GDAL" ) )
  {
    std::unique_ptr< te::da::DataSource > dsPtr = te::da::DataSourceFactory::make( "GDAL", "file://" );

    if( dsPtr.get() )
    {
      std::map< std::string, std::string > specCap = dsPtr->getCapabilities().getSpecificCapabilities();

      const std::string extensionName = "SUPPORTED_VECTOR_EXTENSIONS";

      if( specCap.find( extensionName ) != specCap.end() )
      {
        std::string fileExtensions = specCap[ extensionName ];
        std::string extFilter;
        std::string uCaseToken;
        std::string lCaseToken;
        std::vector< std::string > tokens;
        te::common::Tokenize( fileExtensions, tokens, ";" );

        for( unsigned int tokensIdx = 0 ; tokensIdx < tokens.size() ; ++tokensIdx )
        {
          uCaseToken = te::common::Convert2UCase( tokens[ tokensIdx ] );
          lCaseToken = te::common::Convert2LCase( tokens[ tokensIdx ] );
          extFilter = uCaseToken + " Vector File (" + "*." + lCaseToken + " *." +
            uCaseToken + ")";

          if( uCaseToken == "SHP" )
          {
            filter = QString( extFilter.c_str() ) + ( filter.isEmpty() ? "" : ";;" ) + filter;
          }
          else
          {
            filter += ( filter.isEmpty() ? "" : ";;" ) + QString( extFilter.c_str() );
          }
        }
      }
    }
  }

  filter += QString( ( filter.isEmpty() ? "" : ";;" ) ) + "All Files (*.*)";

  return filter;
}

std::list<te::map::AbstractLayerPtr> te::qt::widgets::GetSelectedLayersOnly(te::qt::widgets::LayerItemView* view, const bool getFolder)
{
  std::list<te::map::AbstractLayerPtr> res;
  std::list<te::qt::widgets::TreeItem*> items = view->getSelectedItems();

  for(std::list<te::qt::widgets::TreeItem*>::iterator it = items.begin(); it != items.end(); ++it)
  if((*it)->getType() == "LAYER")
    res.push_back(((te::qt::widgets::LayerItem*)(*it))->getLayer());
  else if(getFolder && (*it)->getType() == "FOLDER")
    res.push_back(((te::qt::widgets::LayerItem*)(*it))->getLayer());

  return res;
}

void te::qt::widgets::GetValidLayers(QAbstractItemModel* model, const QModelIndex& parent, std::vector<te::map::AbstractLayerPtr>& layers)
{
  int cs = model->rowCount(parent);

  for(int i = 0; i < cs; i++)
  {
    QModelIndex idx = model->index(i, 0, parent);

    if(idx.isValid())
    {
      te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>(idx.internalPointer());

      if(item->getType() == "LAYER")
      {
        te::map::AbstractLayerPtr l = ((te::qt::widgets::LayerItem*)item)->getLayer();

        if(l->isValid())
          layers.push_back(l);
      }
      else if(item->getType() == "FOLDER")
        GetValidLayers(model, idx, layers);
    }
  }
}

void te::qt::widgets::GetValidLayers(QAbstractItemModel* model, const QModelIndex& parent, std::list<te::map::AbstractLayerPtr>& layers)
{
  int cs = model->rowCount(parent);

  for(int i = 0; i < cs; i++)
  {
    QModelIndex idx = model->index(i, 0, parent);

    if(idx.isValid())
    {
      te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>(idx.internalPointer());

      if(item->getType() == "LAYER")
      {
        te::map::AbstractLayerPtr l = ((te::qt::widgets::LayerItem*)item)->getLayer();

        if(l->isValid())
          layers.push_back(l);
      }
      else if(item->getType() == "FOLDER")
        GetValidLayers(model, idx, layers);
    }
  }
}

void te::qt::widgets::GetChangedAndVisibleLayers(const QModelIndexList& idxs, std::list<te::map::AbstractLayerPtr>& layers)
{
  for(QModelIndexList::const_iterator it = idxs.begin(); it != idxs.end(); ++it)
  {
    te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>((*it).internalPointer());

    if(item->getType() == "CHART" || item->getType() == "GROUPING" || item->getType() == "COLORMAP")
    {
      QModelIndex parent = (*it).model()->parent(*it);

      if(!idxs.contains(parent))
      {
        te::qt::widgets::TreeItem* lI = static_cast<te::qt::widgets::TreeItem*>(parent.internalPointer());

        if(lI->isVisible() == te::qt::widgets::TOTALLY)
          layers.push_back(((te::qt::widgets::LayerItem*)lI)->getLayer());
      }
    }
  }
}

bool te::qt::widgets::isValidSRIDs(const int& firstSRID, const int& secondSRID, std::string& msg)
{
  if (firstSRID == 0 && secondSRID != 0)
  {
    msg = "The first SRID(0). It is not possible to convert the SRID to a valid Projection (";
    msg += te::common::Convert2String(secondSRID);
    msg += "). Please, inform the fisrt SRID!";

    return false;
  }

  if (firstSRID != 0 && secondSRID == 0)
  {
    msg = "The second SRID(0). It is not possible to convert the SRID to a valid Projection (";
    msg += te::common::Convert2String(firstSRID);
    msg += "). Please, inform the second SRID!";

    return false;
  }

  return true;
}

int te::qt::widgets::MillimetersToPixels(const QPaintDevice* device, const double& mm, const bool& printer)
{
  int h_dpi = (printer) ? device->physicalDpiX() : device->logicalDpiX(),
    v_dpi = (printer) ? device->physicalDpiY() : device->logicalDpiY(),
    dpi = (h_dpi > v_dpi) ? h_dpi : v_dpi;

  double dpMM = dpi / 25.4; // Dots per millimeter.

  int pixels = qRound(mm * dpMM); // Number of pixels.

  return pixels;
}

QPixmap* te::qt::widgets::GetCleanImage(const QSize& s, const QColor& c)
{
  QPixmap* pix = new QPixmap(s);

  pix->fill(c);

  return pix;
}