Branch data     Line data    Source code

       1                 :            : /***************************************************************************
       2                 :            :  qgsellipsesymbollayer.h
       3                 :            :  ---------------------
       4                 :            :  begin                : June 2011
       5                 :            :  copyright            : (C) 2011 by Marco Hugentobler
       6                 :            :  email                : marco dot hugentobler at sourcepole dot ch
       7                 :            :  ***************************************************************************
       8                 :            :  *                                                                         *
       9                 :            :  *   This program is free software; you can redistribute it and/or modify  *
      10                 :            :  *   it under the terms of the GNU General Public License as published by  *
      11                 :            :  *   the Free Software Foundation; either version 2 of the License, or     *
      12                 :            :  *   (at your option) any later version.                                   *
      13                 :            :  *                                                                         *
      14                 :            :  ***************************************************************************/
      15                 :            : #ifndef QGSELLIPSESYMBOLLAYER_H
      16                 :            : #define QGSELLIPSESYMBOLLAYER_H
      17                 :            : 
      18                 :            : #define DEFAULT_ELLIPSE_JOINSTYLE    Qt::MiterJoin
      19                 :            : 
      20                 :            : #include "qgis_core.h"
      21                 :            : #include "qgis.h"
      22                 :            : #include "qgsmarkersymbollayer.h"
      23                 :            : #include <QPainterPath>
      24                 :            : 
      25                 :            : class QgsExpression;
      26                 :            : 
      27                 :            : /**
      28                 :            :  * \ingroup core
      29                 :            :  * \brief A symbol layer for rendering objects with major and minor axis (e.g. ellipse, rectangle, etc).
      30                 :            : */
      31                 :          0 : class CORE_EXPORT QgsEllipseSymbolLayer: public QgsMarkerSymbolLayer
      32                 :            : {
      33                 :            :   public:
      34                 :            : 
      35                 :            :     //! Marker symbol shapes
      36                 :            :     enum Shape
      37                 :            :     {
      38                 :            :       Circle, //!< Circle
      39                 :            :       Rectangle, //!< Rectangle
      40                 :            :       Diamond, //!< Diamond
      41                 :            :       Cross, //!< Stroke-only cross
      42                 :            :       Arrow, //!< Stroke-only arrow (since QGIS 3.20)
      43                 :            :       HalfArc, //!< Stroke-only half arc (since QGIS 3.20)
      44                 :            :       Triangle, //!< Triangle
      45                 :            :       RightHalfTriangle, //!< Right half of a triangle
      46                 :            :       LeftHalfTriangle, //!< Left half of a triangle
      47                 :            :       SemiCircle, //!< Semi circle
      48                 :            :     };
      49                 :            : 
      50                 :            :     //! Returns a list of all available shape types.
      51                 :            :     static QList< QgsEllipseSymbolLayer::Shape > availableShapes();
      52                 :            : 
      53                 :            :     /**
      54                 :            :      * Returns TRUE if a \a shape has a fill.
      55                 :            :      * \returns TRUE if shape uses a fill, or FALSE if shape uses lines only
      56                 :            :      * \since QGIS 3.20
      57                 :            :      */
      58                 :            :     static bool shapeIsFilled( const QgsEllipseSymbolLayer::Shape &shape );
      59                 :            : 
      60                 :            :     QgsEllipseSymbolLayer();
      61                 :            : 
      62                 :            :     //! Creates the symbol layer
      63                 :            :     static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
      64                 :            :     static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
      65                 :            : 
      66                 :            :     void renderPoint( QPointF point, QgsSymbolRenderContext &context ) override;
      67                 :            :     QString layerType() const override;
      68                 :            :     void startRender( QgsSymbolRenderContext &context ) override;
      69                 :            :     void stopRender( QgsSymbolRenderContext &context ) override;
      70                 :            :     QgsEllipseSymbolLayer *clone() const override SIP_FACTORY;
      71                 :            :     QVariantMap properties() const override;
      72                 :            : 
      73                 :            :     void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
      74                 :            :     void writeSldMarker( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
      75                 :            : 
      76                 :            :     bool writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift = QPointF( 0.0, 0.0 ) ) const override;
      77                 :            : 
      78                 :            :     /**
      79                 :            :      * Sets the rendered ellipse marker shape using a symbol \a name.
      80                 :            :      * \see setShape()
      81                 :            :      * \see shape()
      82                 :            :      * \deprecated since QGIS 3.20
      83                 :            :      */
      84                 :            :     Q_DECL_DEPRECATED void setSymbolName( const QString &name ) SIP_DEPRECATED { mShape = decodeShape( name ); }
      85                 :            : 
      86                 :            :     /**
      87                 :            :      * Returns the shape name for the rendered ellipse marker symbol.
      88                 :            :      * \see shape()
      89                 :            :      * \see setShape()
      90                 :            :      * \deprecated since QGIS 3.20
      91                 :            :      */
      92                 :            :     Q_DECL_DEPRECATED QString symbolName() const SIP_DEPRECATED { return encodeShape( mShape ); }
      93                 :            : 
      94                 :            :     /**
      95                 :            :      * Returns the shape for the rendered ellipse marker symbol.
      96                 :            :      * \see setShape()
      97                 :            :      * \since QGIS 3.20
      98                 :            :      */
      99                 :            :     QgsEllipseSymbolLayer::Shape shape() const { return mShape; }
     100                 :            : 
     101                 :            :     /**
     102                 :            :      * Sets the rendered ellipse marker shape.
     103                 :            :      * \param shape new ellipse marker shape
     104                 :            :      * \see shape()
     105                 :            :      * \since QGIS 3.20
     106                 :            :      */
     107                 :          0 :     void setShape( QgsEllipseSymbolLayer::Shape shape ) { mShape = shape; }
     108                 :            : 
     109                 :            :     /**
     110                 :            :      * Attempts to decode a string representation of a shape name to the corresponding
     111                 :            :      * shape.
     112                 :            :      * \param name encoded shape name
     113                 :            :      * \param ok if specified, will be set to TRUE if shape was successfully decoded
     114                 :            :      * \returns decoded name
     115                 :            :      * \see encodeShape()
     116                 :            :      * \since QGIS 3.20
     117                 :            :      */
     118                 :            :     static QgsEllipseSymbolLayer::Shape decodeShape( const QString &name, bool *ok = nullptr );
     119                 :            : 
     120                 :            :     /**
     121                 :            :      * Encodes a shape to its string representation.
     122                 :            :      * \param shape shape to encode
     123                 :            :      * \returns encoded string
     124                 :            :      * \see decodeShape()
     125                 :            :      * \since QGIS 3.20
     126                 :            :      */
     127                 :            :     static QString encodeShape( QgsEllipseSymbolLayer::Shape shape );
     128                 :            : 
     129                 :            :     void setSize( double size ) override;
     130                 :            : 
     131                 :            :     void setSymbolWidth( double w );
     132                 :            :     double symbolWidth() const { return mSymbolWidth; }
     133                 :            : 
     134                 :            :     void setSymbolHeight( double h );
     135                 :            :     double symbolHeight() const { return mSymbolHeight; }
     136                 :            : 
     137                 :            :     Qt::PenStyle strokeStyle() const { return mStrokeStyle; }
     138                 :          0 :     void setStrokeStyle( Qt::PenStyle strokeStyle ) { mStrokeStyle = strokeStyle; }
     139                 :            : 
     140                 :            :     /**
     141                 :            :      * Gets stroke join style.
     142                 :            :      * \since QGIS 2.16
     143                 :            :      */
     144                 :            :     Qt::PenJoinStyle penJoinStyle() const { return mPenJoinStyle; }
     145                 :            : 
     146                 :            :     /**
     147                 :            :      * Set stroke join style.
     148                 :            :      * \since QGIS 2.16
     149                 :            :     */
     150                 :          0 :     void setPenJoinStyle( Qt::PenJoinStyle style ) { mPenJoinStyle = style; }
     151                 :            : 
     152                 :            :     /**
     153                 :            :      * Returns the marker's stroke cap style (e.g., flat, round, etc).
     154                 :            :      * \see setPenCapStyle()
     155                 :            :      * \see penJoinStyle()
     156                 :            :      * \see strokeColor()
     157                 :            :      * \see strokeStyle()
     158                 :            :      * \since QGIS 3.20
     159                 :            :     */
     160                 :            :     Qt::PenCapStyle penCapStyle() const { return mPenCapStyle; }
     161                 :            : 
     162                 :            :     /**
     163                 :            :      * Sets the marker's stroke cap \a style (e.g., flat, round, etc).
     164                 :            :      * \see penCapStyle()
     165                 :            :      * \see penJoinStyle()
     166                 :            :      * \see setStrokeColor()
     167                 :            :      * \see setStrokeStyle()
     168                 :            :      * \since QGIS 3.20
     169                 :            :     */
     170                 :          0 :     void setPenCapStyle( Qt::PenCapStyle style ) { mPenCapStyle = style; }
     171                 :            : 
     172                 :          0 :     void setStrokeWidth( double w ) { mStrokeWidth = w; }
     173                 :            :     double strokeWidth() const { return mStrokeWidth; }
     174                 :            : 
     175                 :          0 :     void setFillColor( const QColor &c ) override { setColor( c ); }
     176                 :          0 :     QColor fillColor() const override { return color(); }
     177                 :            : 
     178                 :          0 :     void setStrokeColor( const QColor &c ) override { mStrokeColor = c; }
     179                 :          0 :     QColor strokeColor() const override { return mStrokeColor; }
     180                 :            : 
     181                 :            :     /**
     182                 :            :      * Sets the units for the symbol's width.
     183                 :            :      * \param unit symbol units
     184                 :            :      * \see symbolWidthUnit()
     185                 :            :      * \see setSymbolHeightUnit()
     186                 :            :     */
     187                 :          0 :     void setSymbolWidthUnit( QgsUnitTypes::RenderUnit unit ) { mSymbolWidthUnit = unit; }
     188                 :            : 
     189                 :            :     /**
     190                 :            :      * Returns the units for the symbol's width.
     191                 :            :      * \see setSymbolWidthUnit()
     192                 :            :      * \see symbolHeightUnit()
     193                 :            :     */
     194                 :            :     QgsUnitTypes::RenderUnit symbolWidthUnit() const { return mSymbolWidthUnit; }
     195                 :            : 
     196                 :          0 :     void setSymbolWidthMapUnitScale( const QgsMapUnitScale &scale ) { mSymbolWidthMapUnitScale = scale; }
     197                 :            :     const QgsMapUnitScale &symbolWidthMapUnitScale() const { return mSymbolWidthMapUnitScale; }
     198                 :            : 
     199                 :            :     /**
     200                 :            :      * Sets the units for the symbol's height.
     201                 :            :      * \param unit symbol units
     202                 :            :      * \see symbolHeightUnit()
     203                 :            :      * \see setSymbolWidthUnit()
     204                 :            :     */
     205                 :          0 :     void setSymbolHeightUnit( QgsUnitTypes::RenderUnit unit ) { mSymbolHeightUnit = unit; }
     206                 :            : 
     207                 :            :     /**
     208                 :            :      * Returns the units for the symbol's height.
     209                 :            :      * \see setSymbolHeightUnit()
     210                 :            :      * \see symbolWidthUnit()
     211                 :            :     */
     212                 :            :     QgsUnitTypes::RenderUnit symbolHeightUnit() const { return mSymbolHeightUnit; }
     213                 :            : 
     214                 :          0 :     void setSymbolHeightMapUnitScale( const QgsMapUnitScale &scale ) { mSymbolHeightMapUnitScale = scale; }
     215                 :            :     const QgsMapUnitScale &symbolHeightMapUnitScale() const { return mSymbolHeightMapUnitScale; }
     216                 :            : 
     217                 :            :     /**
     218                 :            :      * Sets the units for the symbol's stroke width.
     219                 :            :      * \param unit symbol units
     220                 :            :      * \see strokeWidthUnit()
     221                 :            :     */
     222                 :          0 :     void setStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mStrokeWidthUnit = unit; }
     223                 :            : 
     224                 :            :     /**
     225                 :            :      * Returns the units for the symbol's stroke width.
     226                 :            :      * \see setStrokeWidthUnit()
     227                 :            :     */
     228                 :            :     QgsUnitTypes::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
     229                 :            : 
     230                 :          0 :     void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
     231                 :            :     const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
     232                 :            : 
     233                 :            :     void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
     234                 :            :     QgsUnitTypes::RenderUnit outputUnit() const override;
     235                 :            :     bool usesMapUnits() const override;
     236                 :            : 
     237                 :            :     void setMapUnitScale( const QgsMapUnitScale &scale ) override;
     238                 :            :     QgsMapUnitScale mapUnitScale() const override;
     239                 :            : 
     240                 :            :     QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) override;
     241                 :            : 
     242                 :            :   private:
     243                 :            :     Shape mShape = Circle;
     244                 :            :     double mSymbolWidth = 4;
     245                 :            :     QgsUnitTypes::RenderUnit mSymbolWidthUnit = QgsUnitTypes::RenderMillimeters;
     246                 :            :     QgsMapUnitScale mSymbolWidthMapUnitScale;
     247                 :            :     double mSymbolHeight = 3;
     248                 :            :     QgsUnitTypes::RenderUnit mSymbolHeightUnit = QgsUnitTypes::RenderMillimeters;
     249                 :            :     QgsMapUnitScale mSymbolHeightMapUnitScale;
     250                 :            :     QColor mStrokeColor;
     251                 :            :     Qt::PenStyle mStrokeStyle = Qt::SolidLine;
     252                 :            :     Qt::PenJoinStyle mPenJoinStyle = DEFAULT_ELLIPSE_JOINSTYLE;
     253                 :            :     Qt::PenCapStyle mPenCapStyle = Qt::SquareCap;
     254                 :            :     double mStrokeWidth = 0;
     255                 :            :     QgsUnitTypes::RenderUnit mStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
     256                 :            :     QgsMapUnitScale mStrokeWidthMapUnitScale;
     257                 :            : 
     258                 :            :     QPainterPath mPainterPath;
     259                 :            : 
     260                 :            :     QPen mPen;
     261                 :            :     QBrush mBrush;
     262                 :            :     //! QPen to use as stroke of selected symbols
     263                 :            :     QPen mSelPen;
     264                 :            :     //! QBrush to use as fill of selected symbols
     265                 :            :     QBrush mSelBrush;
     266                 :            : 
     267                 :            :     /**
     268                 :            :      * Setup mPainterPath
     269                 :            :      * \param shape name of symbol
     270                 :            :      * \param context render context
     271                 :            :      * \param scaledWidth optional width
     272                 :            :      * \param scaledHeight optional height
     273                 :            :      * \param f optional feature to render (0 if no data defined rendering)
     274                 :            :      */
     275                 :            :     void preparePath( const QgsEllipseSymbolLayer::Shape &shape, QgsSymbolRenderContext &context, double *scaledWidth = nullptr, double *scaledHeight = nullptr, const QgsFeature *f = nullptr );
     276                 :            :     QSizeF calculateSize( QgsSymbolRenderContext &context, double *scaledWidth = nullptr, double *scaledHeight = nullptr );
     277                 :            :     void calculateOffsetAndRotation( QgsSymbolRenderContext &context, double scaledWidth, double scaledHeight, bool &hasDataDefinedRotation, QPointF &offset, double &angle ) const;
     278                 :            : };
     279                 :            : 
     280                 :            : // clazy:excludeall=qstring-allocations
     281                 :            : 
     282                 :            : #endif // QGSELLIPSESYMBOLLAYER_H
     283                 :            : 
     284                 :            :