PolylineShapeModel.h

#pragma once

#include "ShapeModelBase.h"

namespace Eegeo
{
    namespace Shapes
    {
        namespace Polylines
        {

            class PolylineShapeModel : public ShapeModelBase
            {
            public:
                typedef std::vector<Eegeo::Positioning::IPointOnMap*> PointOnMapVector;
                
                typedef TShapeModelChangedEvent<PolylineShapeModel> ShapeModelChangedEvent;
            
                PolylineShapeModel(
                                   IShapeModel::IdType polylineId,
                                   const Resources::Interiors::InteriorId& indoorMapId,
                                   int indoorMapFloorId,
                                   const dv3& originEcef,
                                   const ShapeModelBase::PointOnMapVector& points,
                                   const std::vector<double>& perPointElevations,
                                   double elevation,
                                   const std::vector<u16>& geometryIndices,
                                   const Space::LatLong& boundsSouthWest,
                                   const Space::LatLong& boundsNorthEast,
                                   const v4& fillColor,
                                   float thickness,
                                   float miterLimit,
                                   bool shouldScaleWithMap,
                                   ShapeModelChangedEvent& changedEvent);
                
                virtual ~PolylineShapeModel();
 
                virtual const v4& GetFillColor() const { return m_fillColor; }
                
                virtual void SetFillColor(const v4& color);
                
                virtual float GetThickness() const { return m_thickness; }
                
                virtual void SetThickness(float thickness);
                
                virtual float GetMiterLimit() const { return m_miterLimit; }
                
                virtual void SetMiterLimit(float miterLimit);
                
                virtual bool GetShouldScaleWithMap() const { return m_shouldScaleWithMap; }
                
                virtual void SetShouldScaleWithMap(bool scaleWithMap);
            
            protected:
                virtual void NotifyPointOnMapChanged();
                
            private:
                v4 m_fillColor;
                float m_thickness;
                float m_miterLimit;
                bool m_shouldScaleWithMap;
                
                ShapeModelChangedEvent& m_changedEvent;
            };
        }
    }
}