Branch data     Line data    Source code

       1                 :            : /***************************************************************************
       2                 :            :                          qgslayoutitemattributetable.h
       3                 :            :                          ---------------------------
       4                 :            :     begin                : November 2017
       5                 :            :     copyright            : (C) 2017 by Nyall Dawson
       6                 :            :     email                : nyall dot dawson at gmail dot com
       7                 :            :  ***************************************************************************/
       8                 :            : 
       9                 :            : /***************************************************************************
      10                 :            :  *                                                                         *
      11                 :            :  *   This program is free software; you can redistribute it and/or modify  *
      12                 :            :  *   it under the terms of the GNU General Public License as published by  *
      13                 :            :  *   the Free Software Foundation; either version 2 of the License, or     *
      14                 :            :  *   (at your option) any later version.                                   *
      15                 :            :  *                                                                         *
      16                 :            :  ***************************************************************************/
      17                 :            : 
      18                 :            : #ifndef QGSLAYOUTITEMATTRIBUTETABLE_H
      19                 :            : #define QGSLAYOUTITEMATTRIBUTETABLE_H
      20                 :            : 
      21                 :            : #include "qgis_core.h"
      22                 :            : #include "qgis_sip.h"
      23                 :            : #include "qgslayouttable.h"
      24                 :            : #include "qgsvectorlayerref.h"
      25                 :            : 
      26                 :            : class QgsLayoutItemMap;
      27                 :            : class QgsVectorLayer;
      28                 :            : 
      29                 :            : /**
      30                 :            :  * \ingroup core
      31                 :            :  * \brief A layout table subclass that displays attributes from a vector layer.
      32                 :            :  * \since QGIS 3.0
      33                 :            : */
      34                 :            : class CORE_EXPORT QgsLayoutItemAttributeTable: public QgsLayoutTable
      35                 :            : {
      36                 :          0 :     Q_OBJECT
      37                 :            : 
      38                 :            :   public:
      39                 :            : 
      40                 :            :     /**
      41                 :            :      * Specifies the content source for the attribute table
      42                 :            :      */
      43                 :            :     enum ContentSource
      44                 :            :     {
      45                 :            :       LayerAttributes = 0, //!< Table shows attributes from features in a vector layer
      46                 :            :       AtlasFeature, //!< Table shows attributes from the current atlas feature
      47                 :            :       RelationChildren //!< Table shows attributes from related child features
      48                 :            :     };
      49                 :            : 
      50                 :            :     /**
      51                 :            :      * Constructor for QgsLayoutItemAttributeTable, attached to the specified \a layout.
      52                 :            :      *
      53                 :            :      * Ownership is transferred to the layout.
      54                 :            :      */
      55                 :            :     QgsLayoutItemAttributeTable( QgsLayout *layout SIP_TRANSFERTHIS );
      56                 :            : 
      57                 :            :     int type() const override;
      58                 :            :     QIcon icon() const override;
      59                 :            :     QString displayName() const override;
      60                 :            : 
      61                 :            :     /**
      62                 :            :      * Returns a new QgsLayoutItemAttributeTable for the specified parent \a layout.
      63                 :            :      */
      64                 :            :     static QgsLayoutItemAttributeTable *create( QgsLayout *layout ) SIP_FACTORY;
      65                 :            : 
      66                 :            :     /**
      67                 :            :      * Sets the \a source for attributes to show in table body.
      68                 :            :      * \see source()
      69                 :            :      */
      70                 :            :     void setSource( ContentSource source );
      71                 :            : 
      72                 :            :     /**
      73                 :            :      * Returns the source for attributes shown in the table body.
      74                 :            :      * \see setSource()
      75                 :            :      */
      76                 :            :     ContentSource source() const { return mSource; }
      77                 :            : 
      78                 :            :     /**
      79                 :            :      * Returns the source layer for the table, considering the table source mode. For example,
      80                 :            :      * if the table is set to atlas feature mode, then the source layer will be the
      81                 :            :      * atlas coverage layer. If the table is set to layer attributes mode, then
      82                 :            :      * the source layer will be the user specified vector layer.
      83                 :            :      */
      84                 :            :     QgsVectorLayer *sourceLayer() const;
      85                 :            : 
      86                 :            :     /**
      87                 :            :      * Sets the vector \a layer from which to display feature attributes.
      88                 :            :      *
      89                 :            :      * This is only considered if the table source() is LayerAttributes.
      90                 :            :      *
      91                 :            :      * \see vectorLayer()
      92                 :            :      */
      93                 :            :     void setVectorLayer( QgsVectorLayer *layer );
      94                 :            : 
      95                 :            :     /**
      96                 :            :      * Returns the vector layer the attribute table is currently using.
      97                 :            :      *
      98                 :            :      * This is only considered if the table source() is LayerAttributes.
      99                 :            :      *
     100                 :            :      * \see setVectorLayer()
     101                 :            :      * \see sourceLayer()
     102                 :            :      */
     103                 :            :     QgsVectorLayer *vectorLayer() const { return mVectorLayer.get(); }
     104                 :            : 
     105                 :            :     /**
     106                 :            :      * Sets the relation \a id from which to display child features
     107                 :            :      * \see relationId()
     108                 :            :      * \see setSource()
     109                 :            :      * \note Only used if table source() is set to RelationChildren.
     110                 :            :      */
     111                 :            :     void setRelationId( const QString &id );
     112                 :            : 
     113                 :            :     /**
     114                 :            :      * Returns the relation id which the table displays child features from.
     115                 :            :      * \see setRelationId()
     116                 :            :      * \see source()
     117                 :            :      * \note Only used if table source() is set to RelationChildren.
     118                 :            :      */
     119                 :            :     QString relationId() const { return mRelationId; }
     120                 :            : 
     121                 :            :     /**
     122                 :            :      * Resets the attribute table's columns to match the vector layer's fields.
     123                 :            :      * \see setVectorLayer()
     124                 :            :      */
     125                 :            :     void resetColumns();
     126                 :            : 
     127                 :            :     /**
     128                 :            :      * Sets a layout \a map to use to limit the extent of features shown in the
     129                 :            :      * attribute table. This setting only has an effect if setDisplayOnlyVisibleFeatures is
     130                 :            :      * set to TRUE. Changing the map forces the table to refetch features from its
     131                 :            :      * vector layer, and may result in the table changing size to accommodate the new displayed
     132                 :            :      * feature attributes.
     133                 :            :      * \see map()
     134                 :            :      * \see setDisplayOnlyVisibleFeatures
     135                 :            :      */
     136                 :            :     void setMap( QgsLayoutItemMap *map );
     137                 :            : 
     138                 :            :     /**
     139                 :            :      * Returns the layout map whose extents are controlling the features shown in the
     140                 :            :      * table. The extents of the map are only used if displayOnlyVisibleFeatures() is TRUE.
     141                 :            :      * \see setMap()
     142                 :            :      * \see displayOnlyVisibleFeatures()
     143                 :            :      */
     144                 :            :     QgsLayoutItemMap *map() const { return mMap; }
     145                 :            : 
     146                 :            :     /**
     147                 :            :      * Sets the maximum number of \a features shown by the table. Changing this setting may result
     148                 :            :      * in the attribute table changing its size to accommodate the new number of rows, and requires
     149                 :            :      * the table to refetch features from its vector layer.
     150                 :            :      * \see maximumNumberOfFeatures()
     151                 :            :      */
     152                 :            :     void setMaximumNumberOfFeatures( int features );
     153                 :            : 
     154                 :            :     /**
     155                 :            :      * Returns the maximum number of features to be shown by the table.
     156                 :            :      * \see setMaximumNumberOfFeatures()
     157                 :            :      */
     158                 :            :     int maximumNumberOfFeatures() const { return mMaximumNumberOfFeatures; }
     159                 :            : 
     160                 :            :     /**
     161                 :            :      * Sets attribute table to only show unique rows.
     162                 :            :      *
     163                 :            :      * Set \a uniqueOnly to TRUE to show only unique rows. Duplicate rows
     164                 :            :      * will be stripped from the table.
     165                 :            :      *
     166                 :            :      * \see uniqueRowsOnly()
     167                 :            :      */
     168                 :            :     void setUniqueRowsOnly( bool uniqueOnly );
     169                 :            : 
     170                 :            :     /**
     171                 :            :      * Returns TRUE if the table is set to show only unique rows.
     172                 :            :      *
     173                 :            :      * \see setUniqueRowsOnly()
     174                 :            :      */
     175                 :            :     bool uniqueRowsOnly() const { return mShowUniqueRowsOnly; }
     176                 :            : 
     177                 :            :     /**
     178                 :            :      * Sets the attribute table to only show features which are visible in a map item. Changing
     179                 :            :      * this setting forces the table to refetch features from its vector layer, and may result in
     180                 :            :      * the table changing size to accommodate the new displayed feature attributes.
     181                 :            :      *
     182                 :            :      * \see displayOnlyVisibleFeatures()
     183                 :            :      * \see setMap()
     184                 :            :      */
     185                 :            :     void setDisplayOnlyVisibleFeatures( bool visibleOnly );
     186                 :            : 
     187                 :            :     /**
     188                 :            :      * Returns TRUE if the table is set to show only features visible on a corresponding
     189                 :            :      * map item.
     190                 :            :      *
     191                 :            :      * \see map()
     192                 :            :      * \see setDisplayOnlyVisibleFeatures()
     193                 :            :      */
     194                 :            :     bool displayOnlyVisibleFeatures() const { return mShowOnlyVisibleFeatures; }
     195                 :            : 
     196                 :            :     /**
     197                 :            :      * Sets attribute table to only show features which intersect the current atlas
     198                 :            :      * feature.
     199                 :            :      *
     200                 :            :      * \see filterToAtlasFeature()
     201                 :            :      */
     202                 :            :     void setFilterToAtlasFeature( bool filterToAtlas );
     203                 :            : 
     204                 :            :     /**
     205                 :            :      * Returns TRUE if the table is set to only show features which intersect the current atlas
     206                 :            :      * feature.
     207                 :            :      *
     208                 :            :      * \see setFilterToAtlasFeature()
     209                 :            :      */
     210                 :            :     bool filterToAtlasFeature() const { return mFilterToAtlasIntersection; }
     211                 :            : 
     212                 :            :     /**
     213                 :            :      * Returns TRUE if a feature filter is active on the attribute table.
     214                 :            :      *
     215                 :            :      * \see setFilterFeatures()
     216                 :            :      * \see featureFilter()
     217                 :            :      */
     218                 :            :     bool filterFeatures() const { return mFilterFeatures; }
     219                 :            : 
     220                 :            :     /**
     221                 :            :      * Sets whether the feature filter is active for the attribute table. Changing
     222                 :            :      * this setting forces the table to refetch features from its vector layer, and may result in
     223                 :            :      * the table changing size to accommodate the new displayed feature attributes.
     224                 :            :      * \see filterFeatures()
     225                 :            :      * \see setFeatureFilter()
     226                 :            :      */
     227                 :            :     void setFilterFeatures( bool filter );
     228                 :            : 
     229                 :            :     /**
     230                 :            :      * Returns the current expression used to filter features for the table. The filter is only
     231                 :            :      * active if filterFeatures() is TRUE.
     232                 :            :      *
     233                 :            :      * \see setFeatureFilter()
     234                 :            :      * \see filterFeatures()
     235                 :            :      */
     236                 :            :     QString featureFilter() const { return mFeatureFilter; }
     237                 :            : 
     238                 :            :     /**
     239                 :            :      * Sets the \a expression used for filtering features in the table. The filter is only
     240                 :            :      * active if filterFeatures() is set to TRUE. Changing this setting forces the table
     241                 :            :      * to refetch features from its vector layer, and may result in
     242                 :            :      * the table changing size to accommodate the new displayed feature attributes.
     243                 :            :      *
     244                 :            :      * \see featureFilter()
     245                 :            :      * \see setFilterFeatures()
     246                 :            :      */
     247                 :            :     void setFeatureFilter( const QString &expression );
     248                 :            : 
     249                 :            :     /**
     250                 :            :      * Sets the attributes to display in the table.
     251                 :            :      * \param fields list of fields names from the vector layer to show.
     252                 :            :      * Set to an empty list to show all feature attributes.
     253                 :            :      * \param refresh set to TRUE to force the table to refetch features from its vector layer
     254                 :            :      * and immediately update the display of the table. This may result in the table changing size
     255                 :            :      * to accommodate the new displayed feature attributes.
     256                 :            :      */
     257                 :            :     void setDisplayedFields( const QStringList &fields, bool refresh = true );
     258                 :            : 
     259                 :            :     /**
     260                 :            :      * Sets a string to wrap the contents of the table cells by. Occurrences of this string will
     261                 :            :      * be replaced by a line break.
     262                 :            :      * \param wrapString string to replace with line break
     263                 :            :      * \see wrapString()
     264                 :            :      */
     265                 :            :     void setWrapString( const QString &wrapString );
     266                 :            : 
     267                 :            :     /**
     268                 :            :      * Returns the string used to wrap the contents of the table cells by. Occurrences of this string will
     269                 :            :      * be replaced by a line break.
     270                 :            :      * \see setWrapString()
     271                 :            :      */
     272                 :            :     QString wrapString() const { return mWrapString; }
     273                 :            : 
     274                 :            :     /**
     275                 :            :      * Queries the attribute table's vector layer for attributes to show in the table.
     276                 :            :      * \param contents table content
     277                 :            :      * \returns TRUE if attributes were successfully fetched
     278                 :            :      */
     279                 :            :     bool getTableContents( QgsLayoutTableContents &contents ) override;
     280                 :            : 
     281                 :            :     QgsConditionalStyle conditionalCellStyle( int row, int column ) const override;
     282                 :            :     QgsExpressionContextScope *scopeForCell( int row, int column ) const override SIP_FACTORY;
     283                 :            : 
     284                 :            :     QgsExpressionContext createExpressionContext() const override;
     285                 :            :     void finalizeRestoreFromXml() override;
     286                 :            : 
     287                 :            :     void refreshDataDefinedProperty( QgsLayoutObject::DataDefinedProperty property = QgsLayoutObject::AllProperties ) override;
     288                 :            : 
     289                 :            :     /**
     290                 :            :      * Returns TRUE if the attribute table will be rendered using the conditional styling
     291                 :            :      * properties of the linked vector layer.
     292                 :            :      *
     293                 :            :      * \see setUseConditionalStyling()
     294                 :            :      * \since QGIS 3.12
     295                 :            :      */
     296                 :            :     bool useConditionalStyling() const;
     297                 :            : 
     298                 :            :     /**
     299                 :            :      * Sets whether the attribute table will be rendered using the conditional styling
     300                 :            :      * properties of the linked vector layer.
     301                 :            :      *
     302                 :            :      * \see useConditionalStyling()
     303                 :            :      * \since QGIS 3.12
     304                 :            :      */
     305                 :            :     void setUseConditionalStyling( bool enabled );
     306                 :            : 
     307                 :            :   protected:
     308                 :            : 
     309                 :            :     bool writePropertiesToElement( QDomElement &elem, QDomDocument &doc, const QgsReadWriteContext &context ) const override;
     310                 :            :     bool readPropertiesFromElement( const QDomElement &itemElem, const QDomDocument &doc, const QgsReadWriteContext &context ) override;
     311                 :            : 
     312                 :            :   private slots:
     313                 :            : 
     314                 :            :     void disconnectCurrentMap();
     315                 :            : 
     316                 :            :   private:
     317                 :            : 
     318                 :            :     //! Attribute source
     319                 :            :     ContentSource mSource = LayerAttributes;
     320                 :            :     //! Associated vector layer
     321                 :            :     QgsVectorLayerRef mVectorLayer = nullptr;
     322                 :            : 
     323                 :            :     //! Data defined vector layer - only
     324                 :            :     QPointer< QgsVectorLayer > mDataDefinedVectorLayer;
     325                 :            : 
     326                 :            :     //! Relation id, if in relation children mode
     327                 :            :     QString mRelationId;
     328                 :            : 
     329                 :            :     //! Current vector layer, if in atlas feature mode
     330                 :            :     QgsVectorLayer *mCurrentAtlasLayer = nullptr;
     331                 :            : 
     332                 :            :     //! Associated map (used to display the visible features)
     333                 :            :     QgsLayoutItemMap *mMap = nullptr;
     334                 :            :     QString mMapUuid;
     335                 :            : 
     336                 :            :     //! Maximum number of features that is displayed
     337                 :            :     int mMaximumNumberOfFeatures = 30;
     338                 :            : 
     339                 :            :     //! True if only unique rows should be shown
     340                 :            :     bool mShowUniqueRowsOnly = false;
     341                 :            : 
     342                 :            :     //! Shows only the features that are visible in the associated layout map (TRUE by default)
     343                 :            :     bool mShowOnlyVisibleFeatures = false;
     344                 :            : 
     345                 :            :     //! Shows only the features that intersect the current atlas feature
     346                 :            :     bool mFilterToAtlasIntersection = false;
     347                 :            : 
     348                 :            :     //! True if feature filtering enabled
     349                 :            :     bool mFilterFeatures = false;
     350                 :            : 
     351                 :            :     //! Feature filter expression
     352                 :            :     QString mFeatureFilter;
     353                 :            : 
     354                 :            :     QString mWrapString;
     355                 :            : 
     356                 :            :     bool mUseConditionalStyling = false;
     357                 :            : 
     358                 :            :     QList< QList< QgsConditionalStyle > > mConditionalStyles;
     359                 :            :     QList< QgsFeature > mFeatures;
     360                 :            : 
     361                 :          0 :     struct Cell
     362                 :            :     {
     363                 :            :       Cell() = default;
     364                 :            : 
     365                 :          0 :       Cell( const QVariant &content, const QgsConditionalStyle &style, const QgsFeature &feature )
     366                 :          0 :         : content( content )
     367                 :          0 :         , style( style )
     368                 :          0 :         , feature( feature ) {}
     369                 :            :       QVariant content;
     370                 :            :       QgsConditionalStyle style;
     371                 :            :       QgsFeature feature;
     372                 :            :     };
     373                 :            : 
     374                 :            :     /**
     375                 :            :      * Returns a list of attribute indices corresponding to displayed fields in the table.
     376                 :            :      * \note kept for compatibility with 2.0 api only
     377                 :            :      */
     378                 :            :     QList<int> fieldsToDisplay() const;
     379                 :            : 
     380                 :            :     /**
     381                 :            :      * Restores a field alias map from a pre 2.4 format project file format
     382                 :            :      * \param map QMap of integers to strings, where the string is the alias to use for the
     383                 :            :      * corresponding field, and the integer is the field index from the vector layer
     384                 :            :      */
     385                 :            :     void restoreFieldAliasMap( const QMap<int, QString> &map );
     386                 :            : 
     387                 :            :     /**
     388                 :            :      * Replaces occurrences of the wrap character with line breaks.
     389                 :            :      * \param variant input cell contents
     390                 :            :      */
     391                 :            :     QVariant replaceWrapChar( const QVariant &variant ) const;
     392                 :            : 
     393                 :            : #ifdef HAVE_SERVER_PYTHON_PLUGINS
     394                 :            : 
     395                 :            :     /**
     396                 :            :      * Returns the list of visible columns filtered by feature filter provider.
     397                 :            :      */
     398                 :            :     QgsLayoutTableColumns filteredColumns( );
     399                 :            : #endif
     400                 :            : 
     401                 :            :   private slots:
     402                 :            :     //! Checks if this vector layer will be removed (and sets mVectorLayer to 0 if yes)
     403                 :            :     void removeLayer( const QString &layerId );
     404                 :            : 
     405                 :            :     void atlasLayerChanged( QgsVectorLayer *layer );
     406                 :            : 
     407                 :            : };
     408                 :            : 
     409                 :            : #endif // QGSLAYOUTITEMATTRIBUTETABLE_H