MapParameter.h

Go to the documentation of this file.

#ifndef OSMSCOUT_MAP_MAPPARAMETER_H
#define OSMSCOUT_MAP_MAPPARAMETER_H

/*
  This source is part of the libosmscout-map library
  Copyright (C) 2009, 2015  Tim Teulings

  This library 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 2.1 of the License, or (at your option) any later version.

  This library 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 this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/

#include <list>
#include <string>

#include <osmscout/MapImportExport.h>

#include <osmscout/StyleProcessor.h>

#include <osmscout/util/Breaker.h>
#include <osmscout/util/Transformation.h>

namespace osmscout {

  class OSMSCOUT_MAP_API MapParameter CLASS_FINAL
  {
  public:
    enum class IconMode
    {
      FixedSizePixmap,  // !< raster icons should be used, iconPixelSize will be used for rendering
      ScaledPixmap,     // !< raster icons should be used, icons will be scaled to iconSize
      OriginalPixmap,   // !< raster icons should be used, icons will keep dimensions of original image
      Scalable          // !< vector icons should be used, icons will be scaled to iconSize
    };

    enum class PatternMode
    {
      OriginalPixmap,   // !< raster pattern should be used, it will keep dimensions of original image
      Scalable          // !< vector pattern should be used, it will be scaled to patternSize
    };

  private:
    std::string                         fontName;                  
    double                              fontSize;                  

    std::list<std::string>              iconPaths;                 
    std::list<std::string>              patternPaths;              

    double                              lineMinWidthPixel;         
    double                              areaMinDimensionMM;        

    double                              sidecarMaxDistanceMM;      
    double                              sidecarDistance;           
    double                              sidecarMinDistanceMM;      

    TransPolygon::OptimizeMethod        optimizeWayNodes;          
    TransPolygon::OptimizeMethod        optimizeAreaNodes;         
    double                              optimizeErrorToleranceMm;  
    bool                                drawFadings;               
    bool                                drawWaysWithFixedWidth;    

    // Node and area labels, icons
    size_t                              labelLineMinCharCount;     
    size_t                              labelLineMaxCharCount;     
    bool                                labelLineFitToArea;        
    double                              labelLineFitToWidth;       

    double                              labelPadding;              
    double                              plateLabelPadding;         
    double                              overlayLabelPadding;       

    IconMode                            iconMode;                  
    double                              iconSize;                  
    double                              iconPixelSize;             
    double                              iconPadding;               

    PatternMode                         patternMode;               
    double                              patternSize;               

    double                              labelLayouterOverlap;      

  private:
// Contour labels
    double                              contourLabelOffset;        
    double                              contourLabelSpace;         
    double                              contourLabelPadding;       

    std::string                         routeLabelSeparator;       

    bool                                renderBackground;          
    bool                                renderSeaLand;             
    bool                                renderUnknowns;            
    bool                                renderContourLines;        
    bool                                renderHillShading;         

    bool                                debugData;                 
    bool                                debugPerformance;          

    size_t                              warnObjectCountLimit;      
    size_t                              warnCoordCountLimit;       

    bool                                showAltLanguage;           

    Locale                              locale;                    

    std::vector<FillStyleProcessorRef > fillProcessors;            

    BreakerRef                          breaker;                   

  public:
    MapParameter();

    void SetFontName(const std::string& fontName);
    void SetFontSize(double fontSize);

    void SetIconPaths(const std::list<std::string>& paths);
    void SetPatternPaths(const std::list<std::string>& paths);

    void SetLineMinWidthPixel(double lineMinWidthPixel);
    void SetAreaMinDimensionMM(double areaMinDimensionMM);

    void SetSidecarMaxDistanceMM();
    void SetSidecarDistance();
    void SetSidecarMinDistanceMM();

    void SetOptimizeWayNodes(TransPolygon::OptimizeMethod optimize);
    void SetOptimizeAreaNodes(TransPolygon::OptimizeMethod optimize);
    void SetOptimizeErrorToleranceMm(double errorToleranceMm);

    void SetDrawFadings(bool drawFadings);
    void SetDrawWaysWithFixedWidth(bool drawWaysWithFixedWidth);

    void SetLabelLineMinCharCount(size_t labelLineMinCharCount);
    void SetLabelLineMaxCharCount(size_t labelLineMaxCharCount);
    void SetLabelLineFitToArea(bool labelLineFitToArea);
    void SetLabelLineFitToWidth(double labelLineFitToWidth);

    void SetLabelPadding(double labelPadding);
    void SetPlateLabelPadding(double plateLabelPadding);
    void SetOverlayLabelPadding(double padding);

    void SetIconMode(const IconMode &mode);
    void SetIconSize(double size);
    void SetIconPixelSize(double size);
    void SetIconPadding(double padding);

    void SetPatternMode(const PatternMode &mode);
    void SetPatternSize(double size);

    void SetContourLabelPadding(double padding);

    void SetRouteLabelSeparator(const std::string &separator);

    void SetLabelLayouterOverlap(double labelLayouterOverlap);

    void SetContourLabelOffset(double contourLabelOffset);
    void SetContourLabelSpace(double contourLabelSpace);

    void SetRenderBackground(bool render);
    void SetRenderSeaLand(bool render);
    void SetRenderUnknowns(bool render);
    void SetRenderContourLines(bool render);
    void SetRenderHillShading(bool render);

    void SetDebugData(bool debug);
    void SetDebugPerformance(bool debug);

    void SetWarningObjectCountLimit(size_t limit);
    void SetWarningCoordCountLimit(size_t limit);

    void SetShowAltLanguage(bool showAltLanguage);

    void SetLocale(const Locale &locale);

    void RegisterFillStyleProcessor(size_t typeIndex,
                                    const FillStyleProcessorRef& processor);

    FillStyleProcessorRef GetFillStyleProcessor(size_t typeIndex) const;

    void SetBreaker(const BreakerRef& breaker);


    inline std::string GetFontName() const
    {
      return fontName;
    }

    inline double GetFontSize() const
    {
      return fontSize;
    }

    inline const std::list<std::string>& GetIconPaths() const
    {
      return iconPaths;
    }

    inline const std::list<std::string>& GetPatternPaths() const
    {
      return patternPaths;
    }

    inline double GetLineMinWidthPixel() const
    {
      return lineMinWidthPixel;
    }

    inline double GetAreaMinDimensionMM() const
    {
      return areaMinDimensionMM;
    }

    inline double GetSidecarMaxDistanceMM() const
    {
      return sidecarMaxDistanceMM;
    }

    inline double GetSidecarDistance() const
    {
      return sidecarDistance;
    }

    inline double GetSidecarMinDistanceMM() const
    {
      return sidecarMinDistanceMM;
    }

    inline TransPolygon::OptimizeMethod GetOptimizeWayNodes() const
    {
      return optimizeWayNodes;
    }

    inline TransPolygon::OptimizeMethod GetOptimizeAreaNodes() const
    {
      return optimizeAreaNodes;
    }

    inline double GetOptimizeErrorToleranceMm() const
    {
      return optimizeErrorToleranceMm;
    }

    inline bool GetDrawFadings() const
    {
      return drawFadings;
    }

    inline bool GetDrawWaysWithFixedWidth() const
    {
      return drawWaysWithFixedWidth;
    }

    inline size_t GetLabelLineMinCharCount() const
    {
      return labelLineMinCharCount;
    }

    inline size_t GetLabelLineMaxCharCount() const
    {
      return labelLineMaxCharCount;
    }

    inline bool GetLabelLineFitToArea() const
    {
      return labelLineFitToArea;
    }

    inline double GetLabelLineFitToWidth() const
    {
      return labelLineFitToWidth;
    }

    inline double GetLabelPadding() const
    {
      return labelPadding;
    }

    inline double GetPlateLabelPadding() const
    {
      return plateLabelPadding;
    }

    inline double GetOverlayLabelPadding() const
    {
      return overlayLabelPadding;
    }

    inline IconMode GetIconMode() const
    {
      return iconMode;
    }

    inline double GetIconSize() const
    {
      return iconSize;
    }

    inline double GetIconPixelSize() const
    {
      return iconPixelSize;
    }

    inline double GetIconPadding() const
    {
      return iconPadding;
    }

    inline PatternMode GetPatternMode() const
    {
      return patternMode;
    }

    inline double GetPatternSize() const
    {
      return patternSize;
    }

    inline double GetContourLabelPadding() const
    {
      return contourLabelPadding;
    }

    inline std::string GetRouteLabelSeparator() const
    {
      return routeLabelSeparator;
    }

    inline double GetLabelLayouterOverlap() const
    {
      return labelLayouterOverlap;
    }

    inline double GetContourLabelOffset() const
    {
      return contourLabelOffset;
    }

    inline double GetContourLabelSpace() const
    {
      return contourLabelSpace;
    }

    inline bool GetRenderBackground() const
    {
      return renderBackground;
    }

    inline bool GetRenderSeaLand() const
    {
      return renderSeaLand;
    }

    inline bool GetRenderUnknowns() const
    {
      return renderUnknowns;
    }

    inline bool GetRenderContourLines() const
    {
      return renderContourLines;
    }

    inline bool GetRenderHillShading() const
    {
      return renderHillShading;
    }

    inline bool IsDebugPerformance() const
    {
      return debugPerformance;
    }

    inline bool IsDebugData() const
    {
      return debugData;
    }

    inline size_t GetWarningObjectCountLimit() const
    {
      return warnObjectCountLimit;
    }

    inline size_t GetWarningCoordCountLimit() const
    {
      return warnCoordCountLimit;
    }

    inline bool GetShowAltLanguage() const
    {
      return showAltLanguage;
    }

    inline Locale GetLocale() const
    {
      return locale;
    }

    inline Locale& GetLocaleRef()
    {
      return locale;
    }

    bool IsAborted() const
    {
      if (breaker) {
        return breaker->IsAborted();
      }

      return false;
    }
  };
}

#endif