Styles.h

Go to the documentation of this file.

#ifndef OSMSCOUT_STYLES_H
#define OSMSCOUT_STYLES_H

/*
  This source is part of the libosmscout library
  Copyright (C) 2009  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 <set>
#include <vector>

#include <osmscout/MapImportExport.h>

#include <osmscout/Pixel.h>
#include <osmscout/util/Color.h>
#include <osmscout/util/Projection.h>

#include <osmscout/StyleDescription.h>

namespace osmscout {

  enum class OffsetRel: int {
    base,                       
    leftOutline,                
    rightOutline,               
    laneDivider,                

    laneForwardLeft,
    laneForwardThroughLeft,
    laneForwardThrough,
    laneForwardThroughRight,
    laneForwardRight,
    laneBackwardLeft,
    laneBackwardThroughLeft,
    laneBackwardThrough,
    laneBackwardThroughRight,
    laneBackwardRight,

    sidecar                     
  };

  class OSMSCOUT_MAP_API LineStyle : public Style
  {
  public:
    enum CapStyle {
      capButt,
      capRound,
      capSquare
    };

    enum Attribute {
      attrLineColor,
      attrGapColor,
      attrPreferColorFeature,
      attrDisplayWidth,
      attrWidth,
      attrDisplayOffset,
      attrOffset,
      attrJoinCap,
      attrEndCap,
      attrDashes,
      attrPriority,
      attrZIndex,
      attrOffsetRel
    };

  private:
    std::string         slot;
    Color               lineColor;
    Color               gapColor;
    bool                preferColorFeature;
    double              displayWidth;
    double              width;
    double              displayOffset;
    double              offset;
    CapStyle            joinCap;
    CapStyle            endCap;
    std::vector<double> dash;
    int                 priority;
    int                 zIndex;
    OffsetRel           offsetRel;

  public:
    LineStyle();
    LineStyle(const LineStyle& style);

    void SetColorValue(int attribute, const Color& value) override;
    void SetDoubleValue(int attribute, double value) override;
    void SetDoubleArrayValue(int attribute, const std::vector<double>& value) override;
    void SetIntValue(int attribute, int value) override;
    void SetBoolValue(int attribute, bool value) override;

    LineStyle& SetSlot(const std::string& slot);

    LineStyle& SetLineColor(const Color& color);
    LineStyle& SetGapColor(const Color& color);
    LineStyle& SetPreferColorFeature(bool value);
    LineStyle& SetDisplayWidth(double value);
    LineStyle& SetWidth(double value);
    LineStyle& SetDisplayOffset(double value);
    LineStyle& SetOffset(double value);
    LineStyle& SetJoinCap(CapStyle joinCap);
    LineStyle& SetEndCap(CapStyle endCap);
    LineStyle& SetDashes(const std::vector<double>& dashes);
    LineStyle& SetPriority(int priority);
    LineStyle& SetZIndex(int zIndex);
    LineStyle& SetOffsetRel(OffsetRel offsetRel);

    bool IsVisible() const
    {
      return (displayWidth>0.0 ||
              width>0.0) &&
              lineColor.IsVisible();
    }

    const std::string& GetSlot() const
    {
      return slot;
    }

    const Color& GetLineColor() const
    {
      return lineColor;
    }

    const Color& GetGapColor() const
    {
      return gapColor;
    }

    bool GetPreferColorFeature() const
    {
      return preferColorFeature;
    }

    double GetDisplayWidth() const
    {
      return displayWidth;
    }

    double GetWidth() const
    {
      return width;
    }

    double GetDisplayOffset() const
    {
      return displayOffset;
    }

    double GetOffset() const
    {
      return offset;
    }

    CapStyle GetJoinCap() const
    {
      return joinCap;
    }

    CapStyle GetEndCap() const
    {
      return endCap;
    }

    bool HasDashes() const
    {
      return !dash.empty();
    }

    const std::vector<double>& GetDash() const
    {
      return dash;
    }

    int GetPriority() const
    {
      return priority;
    }

    int GetZIndex() const
    {
      return zIndex;
    }

    OffsetRel GetOffsetRel() const
    {
      return offsetRel;
    }

    static StyleDescriptorRef GetDescriptor();

    void CopyAttributes(const LineStyle& other,
                        const std::set<Attribute>& attributes);

    bool operator==(const LineStyle& other) const;
    bool operator!=(const LineStyle& other) const;
    bool operator<(const LineStyle& other) const;
  };

  class OSMSCOUT_MAP_API CapStyleEnumAttributeDescriptor CLASS_FINAL : public StyleEnumAttributeDescriptor
  {
  public:
    CapStyleEnumAttributeDescriptor(const std::string& name,
                                    int attribute)
      : StyleEnumAttributeDescriptor(name,
                                     attribute)
    {
      AddEnumValue("butt",LineStyle::capButt);
      AddEnumValue("round",LineStyle::capRound);
      AddEnumValue("square",LineStyle::capSquare);
    }
  };

  class OSMSCOUT_MAP_API OffsetRelAttributeDescriptor CLASS_FINAL : public StyleEnumAttributeDescriptor
  {
  public:
    OffsetRelAttributeDescriptor(const std::string& name,
                                 int attribute)
      : StyleEnumAttributeDescriptor(name,
                                     attribute)
    {
      AddEnumValue2("base",OffsetRel::base);
      AddEnumValue2("leftOutline",OffsetRel::leftOutline);
      AddEnumValue2("rightOutline",OffsetRel::rightOutline);
      AddEnumValue2("laneDivider",OffsetRel::laneDivider);

      AddEnumValue2("laneForwardLeft",OffsetRel::laneForwardLeft);
      AddEnumValue2("laneForwardThroughLeft",OffsetRel::laneForwardThroughLeft);
      AddEnumValue2("laneForwardThrough",OffsetRel::laneForwardThrough);
      AddEnumValue2("laneForwardThroughRight",OffsetRel::laneForwardThroughRight);
      AddEnumValue2("laneForwardRight",OffsetRel::laneForwardRight);
      AddEnumValue2("laneBackwardLeft",OffsetRel::laneBackwardLeft);
      AddEnumValue2("laneBackwardThroughLeft",OffsetRel::laneBackwardThroughLeft);
      AddEnumValue2("laneBackwardThrough",OffsetRel::laneBackwardThrough);
      AddEnumValue2("laneBackwardThroughRight",OffsetRel::laneBackwardThroughRight);
      AddEnumValue2("laneBackwardRight",OffsetRel::laneBackwardRight);

      AddEnumValue2("sidecar", OffsetRel::sidecar);
    }

    void AddEnumValue2(const std::string& name,
                       OffsetRel value)
    {
      AddEnumValue(name, static_cast<int>(value));
    }
  };

  using LineStyleRef = std::shared_ptr<LineStyle>;

  class OSMSCOUT_MAP_API FillStyle : public Style
  {
  public:
    enum Attribute {
      attrFillColor,
      attrPattern,
      attrPatternMinMag
    };

  private:
    Color               fillColor;
    std::string         pattern;
    mutable size_t      patternId;
    Magnification       patternMinMag;

  public:
    FillStyle();
    FillStyle(const FillStyle& style);

    void SetStringValue(int attribute, const std::string& value) override;
    void SetColorValue(int attribute, const Color& value) override;
    void SetMagnificationValue(int attribute, const Magnification& value) override;

    FillStyle& SetFillColor(const Color& color);
    FillStyle& SetPattern(const std::string& pattern);
    void SetPatternId(size_t id) const;
    FillStyle& SetPatternMinMag(const Magnification& mag);

    bool IsVisible() const
    {
      return (fillColor.IsVisible() ||
              !pattern.empty());
    }

    const Color& GetFillColor() const
    {
      return fillColor;
    }

    bool HasPattern() const
    {
      return !pattern.empty();
    }

    std::string GetPatternName() const
    {
      return pattern;
    }

    size_t GetPatternId() const
    {
      return patternId;
    }

    const Magnification& GetPatternMinMag() const
    {
      return patternMinMag;
    }

    static StyleDescriptorRef GetDescriptor();

    void CopyAttributes(const FillStyle& other,
                        const std::set<Attribute>& attributes);

    bool operator==(const FillStyle& other) const;
    bool operator!=(const FillStyle& other) const;
    bool operator<(const FillStyle& other) const;
  };

  using FillStyleRef = std::shared_ptr<FillStyle>;

  class OSMSCOUT_MAP_API BorderStyle : public Style
  {
  public:
    enum Attribute {
      attrColor,
      attrGapColor,
      attrWidth,
      attrDashes,
      attrDisplayOffset,
      attrOffset,
      attrPriority
    };

  private:
    std::string         slot;
    Color               color;
    Color               gapColor;
    double              width;
    std::vector<double> dash;
    double              displayOffset;
    double              offset;
    int                 priority;

  public:
    BorderStyle();
    BorderStyle(const BorderStyle& style);

    void SetColorValue(int attribute, const Color& value) override;
    void SetDoubleValue(int attribute, double value) override;
    void SetDoubleArrayValue(int attribute, const std::vector<double>& value) override;
    void SetIntValue(int attribute, int value) override;

    BorderStyle& SetSlot(const std::string& slot);

    BorderStyle& SetColor(const Color& color);
    BorderStyle& SetGapColor(const Color& color);
    BorderStyle& SetWidth(double value);
    BorderStyle& SetDashes(const std::vector<double>& dashes);
    BorderStyle& SetDisplayOffset(double value);
    BorderStyle& SetOffset(double value);
    BorderStyle& SetPriority(int priority);

    bool IsVisible() const
    {
      return width>0 && color.IsVisible();
    }

    const std::string& GetSlot() const
    {
      return slot;
    }

    const Color& GetColor() const
    {
      return color;
    }

    const Color& GetGapColor() const
    {
      return gapColor;
    }

    double GetWidth() const
    {
      return width;
    }

    bool HasDashes() const
    {
      return !dash.empty();
    }

    const std::vector<double>& GetDash() const
    {
      return dash;
    }

    double GetDisplayOffset() const
    {
      return displayOffset;
    }

    double GetOffset() const
    {
      return offset;
    }

    int GetPriority() const
    {
      return priority;
    }

    static StyleDescriptorRef GetDescriptor();

    void CopyAttributes(const BorderStyle& other,
                        const std::set<Attribute>& attributes);

    bool operator==(const BorderStyle& other) const;
    bool operator!=(const BorderStyle& other) const;
    bool operator<(const BorderStyle& other) const;
  };

  using BorderStyleRef = std::shared_ptr<BorderStyle>;

  class OSMSCOUT_MAP_API LabelStyle : public Style
  {
  private:
    size_t priority;
    double size;

  public:
    LabelStyle();
    LabelStyle(const LabelStyle& style);

    ~LabelStyle() override = default;

    virtual bool IsVisible() const = 0;
    virtual double GetAlpha() const = 0;

    LabelStyle& SetPriority(size_t priority);

    virtual LabelStyle& SetSize(double size);

    size_t GetPriority() const
    {
      return priority;
    }

    double GetSize() const
    {
      return size;
    }
  };

  using LabelStyleRef = std::shared_ptr<LabelStyle>;

  class OSMSCOUT_MAP_API TextStyle : public LabelStyle
  {
  public:
    enum Style {
      normal,
      emphasize
    };

    enum Attribute {
      attrPriority,
      attrSize,
      attrLabel,
      attrPosition,
      attrTextColor,
      attrStyle,
      attrScaleAndFadeMag,
      attrAutoSize
    };

  private:
    std::string      slot;
    LabelProviderRef label;           
    size_t           position;        
    Color            textColor;       
    Style            style;           
    Magnification    scaleAndFadeMag; 
    bool             autoSize;        

  public:
    TextStyle();
    TextStyle(const TextStyle& style);

    void SetBoolValue(int attribute, bool value) override;
    void SetColorValue(int attribute, const Color& value) override;
    void SetMagnificationValue(int attribute, const Magnification& value) override;
    void SetDoubleValue(int attribute, double value) override;
    void SetIntValue(int attribute, int value) override;
    void SetUIntValue(int attribute, size_t value) override;
    void SetLabelValue(int attribute, const LabelProviderRef& value) override;

    TextStyle& SetSlot(const std::string& slot);

    TextStyle& SetSize(double size) override;
    TextStyle& SetLabel(const LabelProviderRef& label);
    TextStyle& SetPosition(size_t position);
    TextStyle& SetTextColor(const Color& color);
    TextStyle& SetStyle(Style style);
    TextStyle& SetScaleAndFadeMag(const Magnification& mag);
    TextStyle& SetAutoSize(bool autoSize);

    bool IsVisible() const override
    {
      return label &&
             GetTextColor().IsVisible();
    }

    double GetAlpha() const override
    {
      return textColor.GetA();
    }

    const std::string& GetSlot() const
    {
      return slot;
    }

    const LabelProviderRef& GetLabel() const
    {
      return label;
    }

    size_t GetPosition() const
    {
      return position;
    }

    const Color& GetTextColor() const
    {
      return textColor;
    }

    const Style& GetStyle() const
    {
      return style;
    }

    Magnification GetScaleAndFadeMag() const
    {
      return scaleAndFadeMag;
    }

    bool GetAutoSize() const
    {
      return autoSize;
    }

    static StyleDescriptorRef GetDescriptor();

    void CopyAttributes(const TextStyle& other,
                        const std::set<Attribute>& attributes);

    bool operator==(const TextStyle& other) const;
    bool operator!=(const TextStyle& other) const;
    bool operator<(const TextStyle& other) const;
  };

  class OSMSCOUT_MAP_API TextStyleEnumAttributeDescriptor CLASS_FINAL : public StyleEnumAttributeDescriptor
  {
  public:
    TextStyleEnumAttributeDescriptor(const std::string& name,
                                     int attribute)
      : StyleEnumAttributeDescriptor(name,
                                     attribute)
    {
      AddEnumValue("normal",TextStyle::normal);
      AddEnumValue("emphasize",TextStyle::emphasize);
    }
  };

  using TextStyleRef = std::shared_ptr<TextStyle>;

  class OSMSCOUT_MAP_API ShieldStyle : public LabelStyle
  {
  public:
    enum Attribute {
      attrPriority,
      attrSize,
      attrLabel,
      attrTextColor,
      attrBgColor,
      attrBorderColor
    };

  private:
    LabelProviderRef label;          
    Color            textColor;      
    Color            bgColor;        
    Color            borderColor;    

  public:
    ShieldStyle();
    ShieldStyle(const ShieldStyle& style);

    ShieldStyle& SetLabel(const LabelProviderRef& label);
    ShieldStyle& SetSize(double size) override;
    ShieldStyle& SetTextColor(const Color& color);
    ShieldStyle& SetBgColor(const Color& color);
    ShieldStyle& SetBorderColor(const Color& color);

    bool IsVisible() const override
    {
      return label &&
             GetTextColor().IsVisible();
    }

    double GetAlpha() const override
    {
      return textColor.GetA();
    }

    const LabelProviderRef& GetLabel() const
    {
      return label;
    }

    const Color& GetTextColor() const
    {
      return textColor;
    }

    const Color& GetBgColor() const
    {
      return bgColor;
    }

    const Color& GetBorderColor() const
    {
      return borderColor;
    }

    void CopyAttributes(const ShieldStyle& other,
                        const std::set<Attribute>& attributes);
  };

  using ShieldStyleRef = std::shared_ptr<ShieldStyle>;

  class OSMSCOUT_MAP_API PathShieldStyle : public Style
  {
  public:
    enum Attribute {
      attrPriority,
      attrSize,
      attrLabel,
      attrTextColor,
      attrBgColor,
      attrBorderColor,
      attrShieldSpace
    };

  private:
    ShieldStyleRef shieldStyle;
    double         shieldSpace;

  public:
    PathShieldStyle();
    PathShieldStyle(const PathShieldStyle& style);

    void SetLabelValue(int attribute, const LabelProviderRef& value) override;
    void SetColorValue(int attribute, const Color& value) override;
    void SetDoubleValue(int attribute, double value) override;
    void SetUIntValue(int attribute, size_t value) override;

    PathShieldStyle& SetLabel(const LabelProviderRef& label);
    PathShieldStyle& SetPriority(size_t priority);
    PathShieldStyle& SetSize(double size);
    PathShieldStyle& SetTextColor(const Color& color);
    PathShieldStyle& SetBgColor(const Color& color);
    PathShieldStyle& SetBorderColor(const Color& color);
    PathShieldStyle& SetShieldSpace(double shieldSpace);

    bool IsVisible() const
    {
      return shieldStyle->IsVisible();
    }

    double GetAlpha() const
    {
      return shieldStyle->GetAlpha();
    }

    size_t GetPriority() const
    {
      return shieldStyle->GetPriority();
    }

    double GetSize() const
    {
      return shieldStyle->GetSize();
    }

    const LabelProviderRef& GetLabel() const
    {
      return shieldStyle->GetLabel();
    }

    const Color& GetTextColor() const
    {
      return shieldStyle->GetTextColor();
    }

    const Color& GetBgColor() const
    {
      return shieldStyle->GetBgColor();
    }

    const Color& GetBorderColor() const
    {
      return shieldStyle->GetBorderColor();
    }

    double GetShieldSpace() const
    {
      return shieldSpace;
    }

    const ShieldStyleRef& GetShieldStyle() const
    {
      return shieldStyle;
    }

    static StyleDescriptorRef GetDescriptor();

    void CopyAttributes(const PathShieldStyle& other,
                        const std::set<Attribute>& attributes);
  };

  using PathShieldStyleRef = std::shared_ptr<PathShieldStyle>;

  class OSMSCOUT_MAP_API PathTextStyle : public Style
  {
  public:
    enum Attribute {
      attrLabel,
      attrSize,
      attrTextColor,
      attrDisplayOffset,
      attrOffset,
      attrPriority
    };

  private:
    LabelProviderRef label;
    double           size;
    Color            textColor;
    double           displayOffset;
    double           offset;
    size_t           priority;

  public:
    PathTextStyle();
    PathTextStyle(const PathTextStyle& style);

    void SetColorValue(int attribute, const Color& value) override;
    void SetDoubleValue(int attribute, double value) override;
    void SetLabelValue(int attribute, const LabelProviderRef& value) override;
    void SetUIntValue(int attribute, size_t value) override;

    PathTextStyle& SetLabel(const LabelProviderRef& label);
    PathTextStyle& SetSize(double size);
    PathTextStyle& SetTextColor(const Color& color);
    PathTextStyle& SetDisplayOffset(double value);
    PathTextStyle& SetOffset(double value);
    PathTextStyle& SetPriority(size_t value);

    bool IsVisible() const
    {
      return label &&
             textColor.IsVisible();
    }

    const LabelProviderRef& GetLabel() const
    {
      return label;
    }

    double GetSize() const
    {
      return size;
    }

    const Color& GetTextColor() const
    {
      return textColor;
    }

    double GetDisplayOffset() const
    {
      return displayOffset;
    }

    double GetOffset() const
    {
      return offset;
    }

    size_t GetPriority() const
    {
      return priority;
    }

    static StyleDescriptorRef GetDescriptor();

    void CopyAttributes(const PathTextStyle& other,
                        const std::set<Attribute>& attributes);
  };

  using PathTextStyleRef = std::shared_ptr<PathTextStyle>;

  class OSMSCOUT_MAP_API IconStyle : public Style
  {
  public:
    enum Attribute {
      attrSymbol,
      attrIconName,
      attrPosition,
      attrPriority,
      attrOverlay
    };

  private:
    SymbolRef    symbol;
    std::string  iconName; 
    size_t       iconId;   
    unsigned int width;    
    unsigned int height;   
    size_t       position; 
    size_t       priority; 
    bool         overlay;  

  public:
    IconStyle();
    IconStyle(const IconStyle& style);

    void SetBoolValue(int attribute, bool value) override;
    void SetStringValue(int attribute, const std::string& value) override;
    void SetSymbolValue(int attribute, const SymbolRef& value) override;
    void SetUIntValue(int attribute, size_t value) override;

    IconStyle& SetSymbol(const SymbolRef& symbol);
    IconStyle& SetIconName(const std::string& iconName);
    IconStyle& SetIconId(size_t id);
    IconStyle& SetWidth(unsigned int w);
    IconStyle& SetHeight(unsigned int h);
    IconStyle& SetPosition(size_t position);
    IconStyle& SetPriority(size_t priority);
    IconStyle& SetOverlay(bool overlay);

    size_t GetPriority() const
    {
      return priority;
    }

    bool IsVisible() const
    {
      return !iconName.empty() ||
              symbol;
    }

    const SymbolRef& GetSymbol() const
    {
      return symbol;
    }

    std::string GetIconName() const
    {
      return iconName;
    }

    size_t GetIconId() const
    {
      return iconId;
    }

    unsigned int GetWidth() const
    {
      return width;
    }

    unsigned int GetHeight() const
    {
      return height;
    }

    size_t GetPosition() const
    {
      return position;
    }

    bool IsOverlay() const
    {
      return overlay;
    }

    static StyleDescriptorRef GetDescriptor();

    void CopyAttributes(const IconStyle& other,
                        const std::set<Attribute>& attributes);
  };

  using IconStyleRef = std::shared_ptr<IconStyle>;

  class OSMSCOUT_MAP_API DrawPrimitive
  {
  public:
    enum class ProjectionMode {
      MAP,
      GROUND
    };

  private:
    ProjectionMode projectionMode;
    FillStyleRef   fillStyle;
    BorderStyleRef borderStyle;

  public:
    DrawPrimitive(ProjectionMode projectionMode,
                  const FillStyleRef& fillStyle,
                  const BorderStyleRef& borderStyle);
    virtual ~DrawPrimitive() = default;

    ProjectionMode GetProjectionMode() const
    {
      return projectionMode;
    }

    const FillStyleRef& GetFillStyle() const
    {
      return fillStyle;
    }

    const BorderStyleRef& GetBorderStyle() const
    {
      return borderStyle;
    }

    virtual void GetBoundingBox(double& minX,
                                double& minY,
                                double& maxX,
                                double& maxY) const = 0;
  };

  using DrawPrimitiveRef = std::shared_ptr<DrawPrimitive>;

  class OSMSCOUT_MAP_API PolygonPrimitive : public DrawPrimitive
  {
  private:
    std::list<Vertex2D> coords;

  public:
    PolygonPrimitive(ProjectionMode projectionMode,
                     const FillStyleRef& fillStyle,
                     const BorderStyleRef& borderStyle);

    void AddCoord(const Vertex2D& coord);

    const std::list<Vertex2D>& GetCoords() const
    {
      return coords;
    }

    void GetBoundingBox(double& minX,
                        double& minY,
                        double& maxX,
                        double& maxY) const override;
  };

  using PolygonPrimitiveRef = std::shared_ptr<PolygonPrimitive>;

  class OSMSCOUT_MAP_API RectanglePrimitive : public DrawPrimitive
  {
  private:
    Vertex2D topLeft;
    double   width;
    double   height;

  public:
    RectanglePrimitive(ProjectionMode projectionMode,
                       const Vertex2D& topLeft,
                       double width,
                       double height,
                       const FillStyleRef& fillStyle,
                       const BorderStyleRef& borderStyle);

    const Vertex2D& GetTopLeft() const
    {
      return topLeft;
    }

    const double& GetWidth() const
    {
      return width;
    }

    const double& GetHeight() const
    {
      return height;
    }

    void GetBoundingBox(double& minX,
                        double& minY,
                        double& maxX,
                        double& maxY) const override;
  };

  using RectanglePrimitiveRef = std::shared_ptr<RectanglePrimitive>;

  class OSMSCOUT_MAP_API CirclePrimitive : public DrawPrimitive
  {
  private:
    Vertex2D center;
    double   radius;

  public:
    CirclePrimitive(ProjectionMode projectionMode,
                    const Vertex2D& center,
                    double radius,
                    const FillStyleRef& fillStyle,
                    const BorderStyleRef& borderStyle);

    const Vertex2D& GetCenter() const
    {
      return center;
    }

    const double& GetRadius() const
    {
      return radius;
    }

    void GetBoundingBox(double& minX,
                        double& minY,
                        double& maxX,
                        double& maxY) const override;
  };

  using CirclePrimitiveRef = std::shared_ptr<CirclePrimitive>;

  class OSMSCOUT_MAP_API Symbol
  {
  private:
    std::string                 name;
    std::list<DrawPrimitiveRef> primitives;

    struct BoundingBox{
      double minX{0};
      double minY{0};
      double maxX{0};
      double maxY{0};

      double GetWidth() const
      {
        return maxX-minX;
      }

      double GetHeight() const
      {
        return maxY-minY;
      }

      void Update(double minX, double minY, double maxX, double maxY)
      {
        this->minX = std::min(this->minX, minX);
        this->minY = std::min(this->minY, minY);

        this->maxX = std::max(this->maxX, maxX);
        this->maxY = std::max(this->maxY, maxY);
      }
    };

    BoundingBox mapBoundingBox;     
    BoundingBox groundBoundingBox;  

  public:
    explicit Symbol(const std::string& name);

    void AddPrimitive(const DrawPrimitiveRef& primitive);

    std::string GetName() const
    {
      return name;
    }

    const std::list<DrawPrimitiveRef>& GetPrimitives() const
    {
      return primitives;
    }

    void GetBoundingBox(const Projection &projection,
                               double& minX,
                               double& minY,
                               double& maxX,
                               double& maxY) const
    {
      minX=std::min(projection.ConvertWidthToPixel(mapBoundingBox.minX),
                    projection.GetMeterInPixel() * groundBoundingBox.minX);
      minY=std::min(projection.ConvertWidthToPixel(mapBoundingBox.minY),
                    projection.GetMeterInPixel() * groundBoundingBox.minY);

      maxX=std::max(projection.ConvertWidthToPixel(mapBoundingBox.maxX),
                    projection.GetMeterInPixel() * groundBoundingBox.maxX);
      maxY=std::max(projection.ConvertWidthToPixel(mapBoundingBox.maxY),
                    projection.GetMeterInPixel() * groundBoundingBox.maxY);
    }

    double GetWidth(const Projection &projection) const
    {
      return std::max(projection.ConvertWidthToPixel(mapBoundingBox.GetWidth()),
                      projection.GetMeterInPixel() * groundBoundingBox.GetWidth());
    }

    double GetHeight(const Projection &projection) const
    {
      return std::max(projection.ConvertWidthToPixel(mapBoundingBox.GetHeight()),
                      projection.GetMeterInPixel() * groundBoundingBox.GetHeight());
    }

  };

  class OSMSCOUT_MAP_API PathSymbolStyle : public Style
  {
  public:

    enum Attribute {
      attrSymbol,
      attrSymbolSpace,
      attrDisplayOffset,
      attrOffset,
      attrOffsetRel
    };

  private:
    std::string slot;
    SymbolRef   symbol;
    double      symbolSpace;
    double      displayOffset;
    double      offset;
    OffsetRel   offsetRel{OffsetRel::base};

  public:
    PathSymbolStyle();
    PathSymbolStyle(const PathSymbolStyle& style);

    void SetDoubleValue(int attribute, double value) override;
    void SetSymbolValue(int attribute, const SymbolRef& value) override;
    void SetIntValue(int attribute, int value) override;

    PathSymbolStyle& SetSlot(const std::string& slot);

    PathSymbolStyle& SetSymbol(const SymbolRef& symbol);
    PathSymbolStyle& SetSymbolSpace(double space);
    PathSymbolStyle& SetDisplayOffset(double value);
    PathSymbolStyle& SetOffset(double value);
    PathSymbolStyle& SetOffsetRel(OffsetRel offsetRel);

    bool IsVisible() const
    {
      return (bool)symbol;
    }

    const std::string& GetSlot() const
    {
      return slot;
    }

    const SymbolRef& GetSymbol() const
    {
      return symbol;
    }

    double GetSymbolSpace() const
    {
      return symbolSpace;
    }

    double GetDisplayOffset() const
    {
      return displayOffset;
    }

    double GetOffset() const
    {
      return offset;
    }

    OffsetRel GetOffsetRel() const
    {
      return offsetRel;
    }

    static StyleDescriptorRef GetDescriptor();

    void CopyAttributes(const PathSymbolStyle& other,
                        const std::set<Attribute>& attributes);
  };

  using PathSymbolStyleRef = std::shared_ptr<PathSymbolStyle>;
}

#endif