qgslayouttable.h

Go to the documentation of this file.

/***************************************************************************
                         qgslayouttable.h
                         ----------------
    begin                : November 2017
    copyright            : (C) 2017 by Nyall Dawson
    email                : nyall dot dawson at gmail dot com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QGSLAYOUTTABLE_H
#define QGSLAYOUTTABLE_H

#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgslayoutmultiframe.h"
#include "qgsconditionalstyle.h"
#include <QFont>
#include <QColor>
#include <QPair>

class QgsLayoutTableColumn;

typedef QVector< QVariant > QgsLayoutTableRow;

#ifndef SIP_RUN
typedef QVector< QgsLayoutTableRow > QgsLayoutTableContents;
#else
typedef QVector< QVector< QVariant > > QgsLayoutTableContents;
#endif


typedef QVector< QgsLayoutTableColumn * > QgsLayoutTableColumns;


class CORE_EXPORT QgsLayoutTableStyle
{
  public:

    QgsLayoutTableStyle() = default;

    bool enabled = false;

    QColor cellBackgroundColor = QColor( 255, 255, 255, 255 );

    bool writeXml( QDomElement &styleElem, QDomDocument &doc ) const;

    bool readXml( const QDomElement &styleElem );

};

class CORE_EXPORT QgsLayoutTable: public QgsLayoutMultiFrame
{
    Q_OBJECT

  public:

    enum HeaderHAlignment
    {
      FollowColumn, 
      HeaderLeft, 
      HeaderCenter, 
      HeaderRight 
    };

    enum HeaderMode
    {
      FirstFrame = 0, 
      AllFrames, 
      NoHeaders 
    };

    enum EmptyTableMode
    {
      HeadersOnly = 0, 
      HideTable, 
      ShowMessage 
    };

    enum WrapBehavior
    {
      TruncateText = 0, 
      WrapText 
    };

    enum CellStyleGroup
    {
      OddColumns, 
      EvenColumns, 
      OddRows, 
      EvenRows, 
      FirstColumn, 
      LastColumn, 
      HeaderRow, 
      FirstRow, 
      LastRow 
    };

    QgsLayoutTable( QgsLayout *layout );

    ~QgsLayoutTable() override;

    void setCellMargin( double margin );

    double cellMargin() const { return mCellMargin; }

    void setEmptyTableBehavior( EmptyTableMode mode );

    EmptyTableMode emptyTableBehavior() const { return mEmptyTableMode; }

    void setEmptyTableMessage( const QString &message );

    QString emptyTableMessage() const { return mEmptyTableMessage; }

    void setShowEmptyRows( bool showEmpty );

    bool showEmptyRows() const { return mShowEmptyRows; }

    void setHeaderFont( const QFont &font );

    QFont headerFont() const { return mHeaderFont; }

    void setHeaderFontColor( const QColor &color );

    QColor headerFontColor() const { return mHeaderFontColor; }

    void setHeaderHAlignment( HeaderHAlignment alignment );

    HeaderHAlignment headerHAlignment() const { return mHeaderHAlignment; }

    void setHeaderMode( HeaderMode mode );

    HeaderMode headerMode() const { return mHeaderMode; }

    void setContentFont( const QFont &font );

    QFont contentFont() const { return mContentFont; }

    void setContentFontColor( const QColor &color );

    QColor contentFontColor() const { return mContentFontColor; }

    void setShowGrid( bool showGrid );

    bool showGrid() const { return mShowGrid; }

    void setGridStrokeWidth( double width );

    double gridStrokeWidth() const { return mGridStrokeWidth; }

    void setGridColor( const QColor &color );

    QColor gridColor() const { return mGridColor; }

    void setHorizontalGrid( bool horizontalGrid );

    bool horizontalGrid() const { return mHorizontalGrid; }

    void setVerticalGrid( bool verticalGrid );

    bool verticalGrid() const { return mVerticalGrid; }

    void setBackgroundColor( const QColor &color );

    QColor backgroundColor() const { return mBackgroundColor; }

    void setWrapBehavior( WrapBehavior behavior );

    WrapBehavior wrapBehavior() const { return mWrapBehavior; }

    QgsLayoutTableColumns &columns() { return mColumns; }

    void setColumns( const QgsLayoutTableColumns &columns );

    void setCellStyle( CellStyleGroup group, const QgsLayoutTableStyle &style );

    const QgsLayoutTableStyle *cellStyle( CellStyleGroup group ) const;

    virtual QMap<int, QString> headerLabels() const SIP_SKIP;

    virtual bool getTableContents( QgsLayoutTableContents &contents ) = 0;

    virtual QgsConditionalStyle conditionalCellStyle( int row, int column ) const;

    QgsLayoutTableContents &contents() { return mTableContents; }

    QSizeF fixedFrameSize( int frameIndex = -1 ) const override;
    QSizeF minFrameSize( int frameIndex = -1 ) const override;

    bool writePropertiesToElement( QDomElement &elem, QDomDocument &doc, const QgsReadWriteContext &context ) const override;
    bool readPropertiesFromElement( const QDomElement &itemElem, const QDomDocument &doc, const QgsReadWriteContext &context ) override;
    QSizeF totalSize() const override;
    void render( QgsLayoutItemRenderContext &context, const QRectF &renderExtent, int frameIndex ) override;

  public slots:

    void refresh() override;

    virtual void refreshAttributes();

    void recalculateFrameSizes() override;

  protected:
    double mCellMargin = 1.0;

    EmptyTableMode mEmptyTableMode = HeadersOnly;

    QString mEmptyTableMessage;

    bool mShowEmptyRows = false;

    QFont mHeaderFont;

    QColor mHeaderFontColor = Qt::black;

    HeaderHAlignment mHeaderHAlignment = FollowColumn;

    HeaderMode mHeaderMode = FirstFrame;

    QFont mContentFont;

    QColor mContentFontColor = Qt::black;

    bool mShowGrid = true;

    double mGridStrokeWidth = 0.5;

    QColor mGridColor = Qt::black;

    bool mHorizontalGrid = true;

    bool mVerticalGrid = true;

    QColor mBackgroundColor = Qt::white;

    QgsLayoutTableColumns mColumns;

    QgsLayoutTableContents mTableContents;

    QMap<int, double> mMaxColumnWidthMap;

    QMap<int, double> mMaxRowHeightMap;

    QSizeF mTableSize;

    WrapBehavior mWrapBehavior = TruncateText;

    QMap< CellStyleGroup, QgsLayoutTableStyle * > mCellStyles;

    virtual bool calculateMaxColumnWidths();

    virtual bool calculateMaxRowHeights();

    //not const, as needs to call calculateMaxColumnWidths()
    double totalWidth();

    //not const, as needs to call calculateMaxRowHeights()
    double totalHeight();

    int rowsVisible( double frameHeight, int firstRow, bool includeHeader, bool includeEmptyRows ) const;

    int rowsVisible( int frameIndex, int firstRow, bool includeEmptyRows ) const;

    QPair<int, int> rowRange( int frameIndex ) const;

    void drawHorizontalGridLines( QPainter *painter, int firstRow, int lastRow, bool drawHeaderLines ) const;

    void drawVerticalGridLines( QPainter *painter, const QMap<int, double> &maxWidthMap, int firstRow, int lastRow, bool hasHeader, bool mergeCells = false ) const SIP_SKIP;

    void recalculateTableSize();

    bool contentsContainsRow( const QgsLayoutTableContents &contents, const QgsLayoutTableRow &row ) const;

  private:

    QMap< CellStyleGroup, QString > mCellStyleNames;

    void initStyles();

    bool textRequiresWrapping( const QString &text, double columnWidth, const QFont &font ) const;

    QString wrappedText( const QString &value, double columnWidth, const QFont &font ) const;

    QColor backgroundColor( int row, int column ) const;

    friend class TestQgsLayoutTable;
    friend class TestQgsLayoutManualTable;
    friend class QgsCompositionConverter;
};

#endif // QGSLAYOUTTABLE_H