ScaleWidget.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/canvas/ScaleWidget.cpp
*/

#include "ScaleWidget.h"

// TerraLib
#include "../../../common/STLUtils.h"
#include "../../../maptools/Utils.h"
#include "../Utils.h"
#include "MapDisplay.h"

// Qt
#include <QFont>
#include <QIcon>
#include <QMap>
#include <QPainter>

//! Definitions
#define TD_KM "KILOMETRE"
#define TD_MT "METRE"
#define TD_DG "DEGREE"
#define TD_FT "FEET"
#define SD_KM QObject::tr("Kilometers")
#define SD_MT QObject::tr("Meters")
#define SD_DG QObject::tr("Degrees")
#define SD_FT QObject::tr("Feet")

/** @name Internally methods.
*  Methods used internally by the ScaleWidget objects.
*/
//@{

/*!
\brief Returns the height needed to show the header section.
\param font The font to be used.
\return
*/
int CalculateHeaderHeight(const QFont& font)
{
  QFontMetrics fm(font);

  return fm.height();
}

/*!
\brief Returns the height needed to show the ruler section.
\param device Device to draw.
\param heightMM The ruler height in millimeters. 
\param printer True if the device is a printer.
\return The minimum height needed to show the ruler section.
*/
int CalculateScaleHeight(const QPaintDevice* device, const int& heightMM, const bool& printer)
{
  int mm = heightMM;

  return te::qt::widgets::MillimetersToPixels(device, mm, printer);
}

/*!
\brief Returns the unit in the formatting being used.
\param displayUnit Unit being used in the display.
\return The unit with the name used in the scale object.
*/
QString GetScaleUnit(const std::string& displayUnit)
{
  if (displayUnit == TD_KM)
    return SD_KM;

  if (displayUnit == TD_MT)
    return SD_MT;

  if (displayUnit == TD_DG)
    return SD_DG;

  return SD_FT;
}

/*!
\brief Returns the height needed to show the footer section.
\param font The font to be used.
\param visible True if the footer is visible and false otherwise.
\return The minimum height needed to show the footer section.
*/
int CalculateFooterHeight(const QFont& font, const bool& visible)
{
  if (!visible)
    return 0;

  QFontMetrics fm(font);

  return fm.height();
}

/*!
\brief Returns the minimum width required to draw the header section.
\param device Device to draw.
\param font The font to be used.
\param intervals Intervals in millimeters.
\param values Intervals in the selected unit of measure.
\param printer True if the device is a printer.
\return The minimum width required to draw the header section.
*/
int GetMinimumHeaderWidth(const QPaintDevice* device, const QFont& font, const std::vector<double>& intervals, const std::vector<double>& values, const bool& printer)
{
  QFontMetrics fm(font);

  int iniValue = fm.width(QString::number(values[0])),
    finalValue = fm.width(QString::number(values[values.size() - 1])),
    rulerPixels = te::qt::widgets::MillimetersToPixels(device, intervals[intervals.size() - 1], printer);

  int minW = (iniValue / 2) + (finalValue / 2) + rulerPixels;

  return minW;
}

/*!
\brief Returns the minimum width required to draw the ruler section.
\param device Device to draw.
\param intervals Intervals in millimeters.
\param printer True if the device is a printer.
\return The minimum width required to draw the ruler section.
*/
int GetMinimumScaleWidth(const QPaintDevice* device, const std::vector<double>& intervals, const bool& printer)
{
  int rulerW = te::qt::widgets::MillimetersToPixels(device, intervals[intervals.size() - 1], printer);

  return rulerW;
}

/*!
\brief Returns the minimum width required to draw the footer section.
\param font The font to be used.
\param unit The unit of measure being used.
\param factor Scaling factor.
\return The minimum width required to draw the footer section.
*/
int GetMinimumFooterWidth(const QFont& font, const QString& unit, const int& factor)
{
  QFontMetrics fm(font);

  QString value = QString("1 : %1 ( %2 )").arg(factor).arg(unit);

  int pixelsWide = fm.width(value);

  return pixelsWide;
}

/*!
\brief Returns the minimum width in pixels required by the widget.
\param device Device to draw.
\param headerFont Font of the header section.
\param footerFont Font of the footer section.
\param intervals Values of the intervals in millimeters.
\param values Values fo the intervals in the unit of measure being used.
\param unit The unit fo mesaure being used.
\param factor Scaling factor.
\param printer True if the device is a printer.
\return The minimum width in pixels required by the widget.
*/
int GetMinimumWidth(const QPaintDevice* device, const QFont& headerFont, const QFont& footerFont, const std::vector<double>& intervals, const std::vector<double>& values, const QString& unit,
  const int& factor, const bool& printer)
{
  int footerW = GetMinimumFooterWidth(footerFont, unit, factor),
    headerW = GetMinimumHeaderWidth(device, headerFont, intervals, values, printer);

  if (headerW > footerW)
    return headerW;

  return footerW;
}

/*!
\brief Returns the minimum height in pixels required by the widget.
\param device Device to draw.
\param headerFont Font of the header section.
\param footerFont Font of the footer section.
\param rulerHeightMM The height of the ruler in millimeters.
\param numericScaleVisible Visibility of the footer section.
\param printer True if the device is a printer.
\return The minimum height in pixels required by the widget.
*/
int GetMinimumHeight(const QPaintDevice* device, const QFont& headerFont, const QFont& footerFont, const int& rulerHeightMM,
  const bool& numericScaleVisible, const bool& printer)
{
  int h_margin = te::qt::widgets::MillimetersToPixels(device, 2., printer);

  int hh = CalculateHeaderHeight(headerFont),
    sh = CalculateScaleHeight(device, rulerHeightMM, printer),
    fh = CalculateFooterHeight(footerFont, numericScaleVisible);

  int h = hh + sh + h_margin;

  if (fh > 0)
    h += fh + h_margin;

  return h;
}

/*!
\brief Returns the minimum dimensions required to draw the widget.
\param device Device to draw.
\param headerFont Font of the header section.
\param footerFont Font of the footer section.
\param heightMM The height of the ruler in millimeters.
\param intervals Values of the intervals in millimeters.
\param values Values fo the intervals in the unit of measure being used.
\param printer True if the device is a printer.
\param numericScaleVisible Visibility of the footer section.
\param unit The unit fo mesaure being used.
\param factor Scaling factor.
\return The minimum dimensions required to draw the widget.
*/
QSize GetComponentSize(const QPaintDevice* device, const QFont& headerFont, const QFont& footerFont, const int& heightMM, const std::vector<double>& intervals,
                       const std::vector<double>& values, const bool& printer, const bool& numericScaleVisible, const QString& unit, const int& factor)
{
  return QSize(GetMinimumWidth(device, headerFont, footerFont, intervals, values, unit, factor, printer) + 1,
    GetMinimumHeight(device, headerFont, footerFont, heightMM, numericScaleVisible, printer) + 1);
}

/*!
\brief Returns a pixmap with the ruler representation of the graphic scale.
\param device Device to draw.
\param heightMM The height of the ruler in millimeters.
\param intervals Values of the intervals in millimeters.
\param beginsBlack True if the first interval must be colored, false otherwise.
\param color The color to be used.
\param printer True if the device is a printer.
\return A pixmap with the ruler representation of the graphic scale.
*/
QPixmap* GetDashedScale(const QPaintDevice* device, const int& heightMM, const std::vector<double>& intervals, const bool& beginsBlack, const QColor& color, const bool& printer)
{
  int w = GetMinimumScaleWidth(device, intervals, printer),
    h = CalculateScaleHeight(device, heightMM, printer);

  QPixmap* pix = new QPixmap(w + 1, h + 1);

  pix->fill(Qt::transparent);

  QPainter p(pix);

  QRect rect(0, 0, w, h);

  p.fillRect(rect, Qt::white);

  QPen pen(color, 1);

  p.setPen(pen);

  for (size_t i = (beginsBlack) ? 0 : 1; i < intervals.size() - 1; i+=2)
  {
    int x = te::qt::widgets::MillimetersToPixels(device, intervals[i], printer),
      next_x = te::qt::widgets::MillimetersToPixels(device, intervals[i+1], printer);

    QPoint topLeft(x, 0),
      bottomRight(next_x, h);

    QRect r(topLeft, bottomRight);

    p.fillRect(r, color);
  }

  p.drawRect(rect);

  return pix;
}

/*!
\brief Returns a representation of two dashed scales one on top of the other with opposite begining intervals.
\param device Device to draw.
\param heightMM The height of the ruler in millimeters.
\param intervals Values of the intervals in millimeters.
\param beginsBlack True if the first interval must be colored, false otherwise.
\param color The color to be used.
\param printer True if the device is a printer.
\return A representation of two dashed scales one on top of the other with opposite begining intervals.
*/
QPixmap* GetDoubleDashedScale(const QPaintDevice* device, const int& heightMM, const std::vector<double> intervals, const bool& beginsBlack, const QColor& color, const bool& printer)
{
//  double widthMM = intervals[intervals.size() - 1];
  double hMM = (heightMM <= 1) ? 2 : heightMM;

//  int w = GetMinimumScaleWidth(device, intervals, printer),
//    h = CalculateScaleHeight(device, hMM, printer);

  QPixmap* p1 = GetDashedScale(device, static_cast<int>(hMM / 2), intervals, beginsBlack, color, printer);
  QPixmap* p2 = GetDashedScale(device, static_cast<int>(hMM / 2), intervals, !beginsBlack, color, printer);

  QPixmap* pix = new QPixmap(p1->width(), p1->height() + p2->height() - 1);

  QPainter p(pix);

  p.setCompositionMode(QPainter::CompositionMode_SourceOver);

  p.drawPixmap(0, 0, *p1);
  p.drawPixmap(0, p1->height() - 1, *p2);

  delete p1;
  delete p2;

  return pix;
}

/*!
\brief Returns a ruler representation graphic scale.
\param device Device to draw.
\param heightMM The height of the ruler in millimeters.
\param intervals Values of the intervals in millimeters.
\param color The color to be used.
\param printer True if the device is a printer.
\return A ruler representation graphic scale.
*/
QPixmap* GetRulerScale(const QPaintDevice* device, const double& heightMM, const std::vector<double>& intervals, const QColor& color, const bool& printer)
{
  int hMM = static_cast<int>(heightMM);

  if (hMM < 1)
    hMM = 1;

//  double widthMM = intervals[intervals.size()- 1];

  int w = GetMinimumScaleWidth(device, intervals, printer),
    h = CalculateScaleHeight(device, hMM, printer);

  QPixmap* pix = new QPixmap(w + 1, h + 1);

  pix->fill(Qt::transparent);

  int xf = w,
    y = h;

  QPainter p(pix);

  QPen pen(color, 1);

  p.setPen(pen);

  p.drawLine(0, y, xf, y);

  for (size_t i = 0; i < intervals.size(); i++)
  {
    int ini = te::qt::widgets::MillimetersToPixels(device, intervals[i], printer);

    p.drawLine(ini, 0, ini, y);
  }

  return pix;
}


/*!
\brief Returns a rounded value of interval in unit measure.
\param factor Scaling factor.
\return A rounded value of interval in unit measure.
\note The value, in the most of times, is greater then the measure represented by 1cm.
*/
double GetSweetGapValue(const double& factor)
{
  double www = factor;
  double  dx = www / 9.;  // Why???
  long  idx = static_cast<long>(dx);
  double  f = 0;
  double  fa = 1.;

  int conta = 1000;

  if (idx > 0)
  {
    while (--conta)
    {
      dx /= 10.;
      fa *= 10.;
      idx = static_cast<long>(dx);
      if (idx == 0)
      {
        idx = static_cast<long>(dx * 10.);
        f = idx * fa / 10.;
        break;
      }
    }
  }
  else
  {
    while (--conta)
    {
      dx *= 10.;
      fa /= 10.;
      idx = static_cast<long>(dx);
      if (idx > 0)
      {
        f = idx * fa;
        break;
      }
    }
  }

  if (conta == 0)
    return 0;

  return f * 10;
}

/*!
\brief Returns the calculated intervals in millimeters and in unit of measure.
\param breaks Number of values that determines the intervals on the ruler.
\param[out] values Values of the intervals in the current unit of measure.
\param[out] intervals Values of intervals in millimeters.
\param unitsPerInterval Number of units of scaling will be used in intervals.
\param factor Scaling factor.
*/
void GetIntervals(const int& breaks, std::vector<double>& values, std::vector<double>& intervals, const int& unitsPerInterval, const double& factor)
{
  double gap = GetSweetGapValue(factor) * unitsPerInterval;
  double gapMM = 10 * gap / factor; // Giving the scale in centimeters.
  double value = 0,
    interval = 0;

  values.push_back(value);

  intervals.push_back(interval);

  for (int i = 1; i < breaks; i++)
  {
    value = i * gapMM;
    interval = i * gap;

    values.push_back(value);
    intervals.push_back(interval);
  }
}

/*!
\brief Returns a pixmap with the header section of the graphic scale.
\param device Device to draw.
\param font Header font.
\param color Header color.
\param intervals Values of intervals in millimeters.
\param values Values of intervals in units of measure.
\param showAllValues True to show intermediary values ont the header section, false otherwise.
\param printer True if the device is a printer.
\param[out] pixmapOffset Half of the width of the first value. This value is returned to be used to draw the ruler section in the correct position. 
\param toLong If the values of the header are long type values. (If unit is "Degrees" turn off this argument).
\return A pixmap with the header section of the graphic scale.
*/
QPixmap* MakeHeader(const QPaintDevice* device, const QFont& font, const QColor& color, const std::vector<double>& intervals, const std::vector<double>& values, const bool& showAllValues, 
  const bool& printer, int& pixmapOffset, const bool& toLong)
{
  int w = GetMinimumHeaderWidth(device, font, intervals, values, printer), 
    h = CalculateHeaderHeight(font);

  QPixmap* pix = new QPixmap(w+1, h+1);

  pix->fill(Qt::transparent);

  QFontMetrics fm(font);

  int sub_w,
    sub_h = fm.height() + 1;

  std::vector<QPixmap*> sub_pixs;

  QPainter p;
  QPen pen(color, 2);

  // Create legend pixmaps
  for (size_t i = 0; i < values.size(); i++)
  {
    QString v = (toLong) ? QString::number(static_cast<long>(values[i])) : QString::number(values[i]);

    // Width in pixels of the value
    sub_w = fm.width(v);

    // Draw the value of legend
    QPixmap* sub_pix = new QPixmap(sub_w + 1, sub_h + 1);

    sub_pix->fill(Qt::transparent);
    p.begin(sub_pix);

    p.setPen(pen);
    p.setFont(font);

    p.drawText(QRect(0, 0, sub_w, sub_h), Qt::AlignLeft, v);

    sub_pixs.push_back(sub_pix);

    p.end();
  }

  pixmapOffset = (sub_pixs[0]->width() / 2);

  p.begin(pix);


  // 1st element
  QPixmap* sub_pix = sub_pixs[0];
  QRect rec = sub_pix->rect();

  p.drawPixmap(rec, *sub_pix);
  // ============================

  // lst element
  sub_pix = sub_pixs[values.size() - 1];
  rec = sub_pix->rect();

  int offset = te::qt::widgets::MillimetersToPixels(device, intervals[intervals.size() - 1], printer) + pixmapOffset;

  QPoint c(offset, rec.height() / 2);

  rec.moveCenter(c);

  p.drawPixmap(rec, *sub_pix);
  //============================

  if (showAllValues)
  {
    // Draw sub pixmaps centralized
    for (size_t i = 1; i < intervals.size() - 1; i++)
    {
      sub_pix = sub_pixs[i];
      rec = sub_pix->rect();

      int offset = te::qt::widgets::MillimetersToPixels(device, intervals[i], printer) + pixmapOffset;

      QPoint c(offset, rec.height() / 2);

      rec.moveCenter(c);

      p.drawPixmap(rec, *sub_pix);
    }
  }

  te::common::FreeContents(sub_pixs);

  return pix;
}

/*!
\brief Returns a pixmap with the footer section of the graphic scale.
\param factor Scaling factor.
\param unit Unit of measure being used.
\param font Footer font.
\param color Footer color.
\return A pixmap with the footer section of the graphic scale.
*/
QPixmap* MakeFooter(const int& factor, const QString& unit, const QFont& font, const QColor& color)
{
  QFontMetrics fm(font);

  QString value = QString("1 : %1 ( %2 )").arg(factor).arg(unit);

  int pixelsWide = fm.width(value),
    pixelsHigh = fm.height();

  QPixmap* pix = new QPixmap(pixelsWide + 1, pixelsHigh + 1);

  pix->fill(Qt::transparent);

  QPainter p(pix);
  QPen pen(color, 1);

  p.setPen(pen);

  p.setFont(font);

  p.drawText(QRect(0, 0, pixelsWide, pixelsHigh), Qt::AlignLeft, value);

  return pix;
}

/*!
\brief Repaints the widget.
\param device Device to draw.
\param headerFont Font of the header section.
\param headerColor Color of the header section.
\param allHeaderVisible True to show intermediary values ont the header section, false otherwise.
\param rulerColor Color of the ruler section.
\param intervals Values of intervals in millimeters.
\param values Values of intervals in units of measure.
\param heightMM Height of the ruler in millimeters.
\param showNumericScale True to show the footer section, false otherwise.
\param footerFont Font of the footer section.
\param footerColor Color of the footer section.
\param unit Unit of measure to be used.
\param factor Scaling factor.
\param printer True if the device is a printer.
\param type The type of the ruler to be drawed.
*/
void RepaintWidget(QPaintDevice* device, const QFont& headerFont, const QColor& headerColor, const bool& allHeaderVisible, const QColor& rulerColor, const std::vector<double>& intervals, 
  const std::vector<double>& values, const int& heightMM, const bool& showNumericScale, const QFont& footerFont, const QColor& footerColor, const QString& unit, const double& factor, 
  const bool& printer, const te::qt::widgets::ScaleWidget::ScaleTypes& type)
{
  int margin = te::qt::widgets::MillimetersToPixels(device, 1., printer), // vertical margin in pixels
    pixOffset;

  QPixmap* header = MakeHeader(device, headerFont, headerColor, intervals, values, allHeaderVisible, printer, pixOffset, (unit != SD_DG));

  QPixmap* gScale = nullptr;

  QPixmap* footer = nullptr;

  switch (type)
  {
    case te::qt::widgets::ScaleWidget::DASHED:
      gScale = GetDashedScale(device, heightMM, intervals, false, rulerColor, printer);
    break;

    case te::qt::widgets::ScaleWidget::DASHED_BEGIN_BLACK:
      gScale = GetDashedScale(device, heightMM, intervals, true, rulerColor, printer);
    break;

    case te::qt::widgets::ScaleWidget::RULER:
      gScale = GetRulerScale(device, heightMM, intervals, rulerColor, printer);
    break;

    case te::qt::widgets::ScaleWidget::DOUBLE_DASHED_BEGIN_BLACK:
      gScale = GetDoubleDashedScale(device, heightMM, intervals, true, rulerColor, printer);
      break;

    case te::qt::widgets::ScaleWidget::DOUBLE_DASHED:
      gScale = GetDoubleDashedScale(device, heightMM, intervals, false, rulerColor, printer);
    break;

    case te::qt::widgets::ScaleWidget::CUSTOM:
    break;
  }

  if (showNumericScale)
    footer = MakeFooter(static_cast<int>(factor), unit, footerFont, footerColor);
  
  QPainter p(device);

  int centerX = device->width() / 2,
    centerY = header->height() / 2;

  // Header
  QRect hR = header->rect();
  hR.moveCenter(QPoint(centerX, centerY));
  p.drawPixmap(hR, *header);
  // =============================

  // Ruler
  int x = hR.x() + pixOffset,
    y = hR.height() + margin;

  QRect sR = gScale->rect();

  sR.moveTo(QPoint(x, y));

  p.drawPixmap(sR, *gScale);
  // =============================

  // Footer
  if (footer != nullptr)
  {
    QRect fR = footer->rect();

    x = centerX;
    y = header->height() + margin + gScale->height() + margin + (fR.height() / 2);

    fR.moveCenter(QPoint(x, y));
    
    p.drawPixmap(fR, *footer);
  }
  // =============================

  delete header;
  delete gScale;
  delete footer;
}

/*!
\brief Returns the width of \a env in meters.
\param fromUnit Unit of measure being used by the display.
\param env The bounding rectangle to be transformed.
\param srid The identifier of the projection being used by the display.
\return The width of \a env in meters.
*/
double ToMeters(const std::string& fromUnit, const te::gm::Envelope& env, const int& srid)
{
  double w = env.getWidth();

  if (fromUnit == TD_MT)
    return w;

  if (fromUnit == TD_DG)
  {
    if (env.getLowerLeftX()  < -180. ||
      env.getLowerLeftY()  < -80. ||
      env.getUpperRightX() >  180. ||
      env.getUpperRightY() >  80.)
    {
      w = env.getWidth() * 111133.;
    }
    else
    {
      try
      {
        te::gm::Envelope planarEnvelope = te::map::GetWorldBoxInPlanar(env, srid);

        w = planarEnvelope.getWidth();
      }
      catch (...)
      {
        w = env.getWidth() * 111133.;
      }
    }

    return w;
  }

  if (fromUnit == TD_KM)
    return (w * 1000);

  return w * (12. * 25.4);
}

/*!
\brief Returns the width of the \a env, that is in meters, to the destination unit of measure.
\param toUnit The destination unit of measure.
\param env The bounding rectangle to be transformed.
\param srid The identifier of the projection being used by the display.
\return The width of the \a env, that is in meters, to the destination unit of measure.
*/
double GetWidthInUnit(const QString& toUnit, const te::gm::Envelope& env, const int& srid)
{
  te::common::UnitOfMeasurePtr unitPtr = te::srs::SpatialReferenceSystemManager::getInstance().getUnit(static_cast<unsigned int>(srid));

  if (unitPtr == nullptr)
    return env.getWidth();

  QString displayUnit = GetScaleUnit(unitPtr->getName());

  if (displayUnit == toUnit)
    return env.getWidth();

  double w = ToMeters(unitPtr->getName(), env, srid);

  if (toUnit == SD_MT)
    return w;

  if (toUnit == SD_DG)
    return (w / 111133.);

  if (toUnit == SD_KM)
    return (w / 1000);

  return w / (12. * 25.4);
}

/*!
\brief Comparies the scale unit and the display unit and returns \a true if it is and \a false otherwise. 
\param scaleUnit The scale unit selected.
\param displaySRID SRID being used in the display.
\return \a True if the units are equals and \a false otherwise.
*/
bool CompareUnit(const QString& scaleUnit, const int& displaySRID)
{
  te::common::UnitOfMeasurePtr unitPtr = te::srs::SpatialReferenceSystemManager::getInstance().getUnit(static_cast<unsigned int>(displaySRID));

  if (unitPtr == nullptr)
    return false;
  
  QString dsUnit = GetScaleUnit(unitPtr->getName());

  return (dsUnit == scaleUnit);
}

/*!
\brief Returns the scaling factor of the current visualized area in the display.
\param display The display being used.
\param unit Unit of measure to be used.
\param printer True if the device is a printer.
\return The scaling factor of the current visualized area in the display.
*/
//@}
double GetScale(const te::qt::widgets::MapDisplay& display, const QString& unit, const bool& printer)
{
  te::gm::Envelope world = display.getExtent();

  double ww = (CompareUnit(unit, display.getSRID())) ? world.getWidth() : GetWidthInUnit(unit, world, display.getSRID()),           //world width
    vw = display.width(),                                               //viewport width
    dpiX = (printer) ? display.physicalDpiX() : display.logicalDpiX(),
    dpiY = (printer) ? display.physicalDpiY() : display.logicalDpiY(),
    dotsPerMillimeter = (dpiX > dpiY) ? dpiX / 25.4 : dpiY / 25.4,
    vwMM = vw / dotsPerMillimeter;

  double scale = 10 * ww / vwMM;                              // 1cm : scale

  return scale;
}

void GetScalesIcons(QMap<int, QIcon>& icons, QStringList& typesNames, const QPaintDevice* device, const QColor& color)
{
  std::vector<double> intervals;

  intervals.push_back(0);
  intervals.push_back(2.);
  intervals.push_back(4.);

  QSize size(32, 16);

  //RULER
  QPixmap* pix = GetRulerScale(device, 2., intervals, color, false);
  icons[te::qt::widgets::ScaleWidget::RULER] = QIcon(*pix);
  typesNames.append(QObject::tr("Ruler"));

  delete pix;

  //DASHED
  pix = GetDashedScale(device, 2., intervals, false, color, false);
  icons[te::qt::widgets::ScaleWidget::DASHED] = QIcon(*pix);
  typesNames.append(QObject::tr("Dashed"));

  delete pix;

  //DASHED_BEGIN_BLACK
  pix = GetDashedScale(device, 2., intervals, true, color, false);
  icons[te::qt::widgets::ScaleWidget::DASHED_BEGIN_BLACK] = QIcon(*pix);
  typesNames.append(QObject::tr("Dashed begins black"));

  delete pix;
  //DOUBLE_DASHED
  pix = GetDoubleDashedScale(device, 2., intervals, false, color, false);
  icons[te::qt::widgets::ScaleWidget::DOUBLE_DASHED] = QIcon(*pix);
  typesNames.append(QObject::tr("Double dashed"));

  delete pix;

  //DOUBLE_DASHED_BEGIN_BLACK
  pix = GetDoubleDashedScale(device, 2., intervals, true, color, false);
  icons[te::qt::widgets::ScaleWidget::DOUBLE_DASHED_BEGIN_BLACK] = QIcon(*pix);
  typesNames.append(QObject::tr("Double dashed begins black"));

  delete pix;

  //CUSTOM
}

te::qt::widgets::ScaleWidget::ScaleWidget(MapDisplay* parent, const bool& interactive) :
QFrame(parent, Qt::SubWindow),
m_bckGround(nullptr),
m_footerFont(QFont("times", 5)),
m_showNumericScale(true),
m_factor(50),
m_unit(SD_MT),
m_numberOfIntervals(3),
m_type(RULER),
m_rulerColor(Qt::black),
m_bckGrd(Qt::white),
m_interactionEnabled(interactive),
m_display(parent),
m_headerColor(m_rulerColor),
m_headerFont(m_footerFont),
m_headerAllVisible(true),
m_unitsPerGap(3),
m_footerColor(m_rulerColor),
m_rulerHeightMM(3)
{
  m_footerFont.setPointSize(m_headerFont.pointSize() * 2);

  setAttribute(Qt::WA_TranslucentBackground);

  setInteractionHandle(m_interactionEnabled);
}

te::qt::widgets::ScaleWidget::~ScaleWidget()
{
  delete m_bckGround;
}

bool te::qt::widgets::ScaleWidget::getInteractionHandle() const
{
  return m_interactionEnabled;
}

QColor te::qt::widgets::ScaleWidget::getHeaderColor() const
{
  return m_headerColor;
}

QColor te::qt::widgets::ScaleWidget::getRulerColor() const
{
  return m_rulerColor;
}

QColor te::qt::widgets::ScaleWidget::getFooterColor() const
{
  return m_footerColor;
}

QFont te::qt::widgets::ScaleWidget::getHeaderFont() const
{
  return m_headerFont;
}

QFont te::qt::widgets::ScaleWidget::getFooterFont() const
{
  return m_footerFont;
}


QString te::qt::widgets::ScaleWidget::getUnit() const
{
  return m_unit;
}

int te::qt::widgets::ScaleWidget::getScaleType() const
{
  return m_type;
}

bool te::qt::widgets::ScaleWidget::getNumericScaleIsVisible() const
{
  return m_showNumericScale;
}

bool te::qt::widgets::ScaleWidget::getAllHeaderIsVisible() const
{
  return m_headerAllVisible;
}

int te::qt::widgets::ScaleWidget::getUnitsPerGap() const
{
  return m_unitsPerGap;
}

int te::qt::widgets::ScaleWidget::getRulerHeightMM() const
{
  return m_rulerHeightMM;
}

int te::qt::widgets::ScaleWidget::getNumberOfIntervals() const
{
  return m_numberOfIntervals;
}

void te::qt::widgets::ScaleWidget::updateScalePosition()
{
  if (m_display == nullptr)
    return;

  QRect dr = m_display->rect(),              // Display rectangle
    sr = QFrame::geometry();                 // Scale rectangle

  if (m_interactionEnabled && dr.contains(sr))
    return;

  int twoMM = te::qt::widgets::MillimetersToPixels(this, 2., false);  // 2MM vertical margin

  int newCenterX = dr.center().x(),
    newCenterY = dr.height() - (sr.height() / 2) - twoMM;

  sr.moveCenter(QPoint(newCenterX, newCenterY));

  QFrame::setGeometry(sr);
}

void te::qt::widgets::ScaleWidget::setUnit(const int& SRID)
{
  te::common::UnitOfMeasurePtr unitPtr = te::srs::SpatialReferenceSystemManager::getInstance().getUnit(static_cast<unsigned int>(SRID));

  if (unitPtr == nullptr)
    return;

  setUnit(GetScaleUnit(unitPtr->getName()));
}

void te::qt::widgets::ScaleWidget::setInteractionHandle(const bool& state)
{
  m_interactionEnabled = state;

  setAttribute(Qt::WA_TransparentForMouseEvents, !state);

  redoWidget();
}

void te::qt::widgets::ScaleWidget::updateScaleFactor()
{
  m_factor = GetScale(m_display, m_unit, false);

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setHeaderColor(const QColor& color)
{
  m_headerColor = color;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setRulerColor(const QColor& color)
{
  m_rulerColor = color;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setFooterColor(const QColor& color)
{
  m_footerColor = color;

  redoWidget();
}


void te::qt::widgets::ScaleWidget::setBackgroundColor(const QColor& color)
{
  m_bckGrd = color;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setHeaderFont(const QFont& font)
{
  m_headerFont = font;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setFooterFont(const QFont& font)
{
  m_footerFont = font;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setUnit(const QString& unit)
{
  m_unit = unit;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setScaleType(const int& type)
{
  m_type = static_cast<ScaleTypes>(type);

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setNumericScaleVisble(const bool& visible)
{
  m_showNumericScale = visible;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setAllHeaderVisible(const bool& visible)
{
  m_headerAllVisible = visible;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setUnitsPerGap(const int& units)
{
  m_unitsPerGap = units;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setRulerHeightMM(const int& hMM)
{
  m_rulerHeightMM = hMM;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::setNumberOfIntervals(const int& v)
{
  m_numberOfIntervals = v;

  redoWidget();
}

void te::qt::widgets::ScaleWidget::redoWidget()
{
  m_intervals.clear();
  m_values.clear();

  m_factor = GetScale(*m_display, m_unit, false);

  GetIntervals(m_numberOfIntervals + 1, m_intervals, m_values, m_unitsPerGap, m_factor);

  QSize s = GetComponentSize(this, m_headerFont, m_footerFont, m_rulerHeightMM, m_intervals, m_values, false, m_showNumericScale, m_unit,
                             static_cast<int>(m_factor));

  setFixedSize(s);
  setMinimumSize(s);

  m_bckGround = GetCleanImage(s, (m_interactionEnabled) ? m_bckGrd : Qt::transparent);

  RepaintWidget(m_bckGround, m_headerFont, m_headerColor, m_headerAllVisible, m_rulerColor, m_intervals, m_values, m_rulerHeightMM, m_showNumericScale, m_footerFont, m_footerColor, 
    m_unit, m_factor, false, m_type);

  update();

  updateScalePosition();
}

void te::qt::widgets::ScaleWidget::paintEvent(QPaintEvent* event)
{
  QPainter p(this);

  p.drawPixmap(0, 0, *m_bckGround);

  QFrame::paintEvent(event);
}

void te::qt::widgets::ScaleWidget::closeEvent(QCloseEvent* event)
{
  emit aboutToBeclosed();

  QFrame::closeEvent(event);
}