pageitem_table.h

/*
Copyright (C) 2011 Elvis Stansvik <elvstone@gmail.com>

For general Scribus (>=1.3.2) copyright and licensing information please refer
to the COPYING file provided with the program. Following this notice may exist
a copyright and/or license notice that predates the release of Scribus 1.3.2
for which a new license (GPL+exception) is in place.
*/
#ifndef PAGEITEM_TABLE_H
#define PAGEITEM_TABLE_H

#include <QList>
#include <QPointF>
#include <QRectF>
#include <QSet>
#include <QString>

#include "cellarea.h"
#include "pageitem.h"
#include "scribusapi.h"
#include "styles/tablestyle.h"
#include "tablecell.h"
#include "tablehandle.h"

class ScPainter;
class ScribusDoc;
class TablePainter;

class SCRIBUS_API PageItem_Table : public PageItem
{
    Q_OBJECT
    Q_ENUMS(ResizeStrategy HitTarget)

    Q_PROPERTY(int rows READ rows NOTIFY changed)
    Q_PROPERTY(int columns READ columns NOTIFY changed)
    Q_PROPERTY(QString fillColor READ fillColor WRITE setFillColor RESET unsetFillColor NOTIFY changed)
    Q_PROPERTY(TableBorder leftBorder READ leftBorder WRITE setLeftBorder RESET unsetLeftBorder NOTIFY changed)
    Q_PROPERTY(TableBorder rightBorder READ rightBorder WRITE setRightBorder RESET unsetRightBorder NOTIFY changed)
    Q_PROPERTY(TableBorder topBorder READ topBorder WRITE setTopBorder RESET unsetTopBorder NOTIFY changed)
    Q_PROPERTY(TableBorder bottomBorder READ bottomBorder WRITE setBottomBorder RESET unsetBottomBorder NOTIFY changed)
    Q_PROPERTY(QString style READ style WRITE setStyle RESET unsetStyle NOTIFY changed)

public:
    enum ResizeStrategy
    {
        MoveFollowing,
        ResizeFollowing
    };

    static const double MinimumRowHeight;

    static const double MinimumColumnWidth;

public:
    PageItem_Table(ScribusDoc *pa, double x, double y, double w, double h, double w2,
        QString fill, QString outline, int numRows = 1, int numColumns = 1);

    ~PageItem_Table();

    void adjustTable();

    int rows() const { return m_rows; }

    int columns() const { return m_columns; }

    double tableWidth() const { return m_columnPositions.last() + m_columnWidths.last(); }

    double tableHeight() const { return m_rowPositions.last() + m_rowHeights.last(); }

    QPointF gridOffset() const { return QPointF(maxLeftBorderWidth()/2, maxTopBorderWidth()/2); }

    double effectiveWidth() const { return tableWidth() + (maxLeftBorderWidth() + maxRightBorderWidth()) / 2; }

    double effectiveHeight() const { return tableHeight() + (maxTopBorderWidth() + maxBottomBorderWidth()) / 2; }

    void resize(double width, double height);

    void insertRows(int index, int numRows);

    void removeRows(int index, int numRows);

    double rowHeight(int row) const;

    QList<double> rowHeights() const { return m_rowHeights; }

    void resizeRow(int row, double height, ResizeStrategy strategy = MoveFollowing);

    void distributeRows(int startRow, int endRow);

    double rowPosition(int row) const;

    QList<double> rowPositions() const { return m_rowPositions; }

    void insertColumns(int index, int numColumns);

    void removeColumns(int index, int numColumns);

    double columnWidth(int column) const;

    QList<double> columnWidths() const { return m_columnWidths; }

    void resizeColumn(int column, double width, ResizeStrategy strategy = MoveFollowing);

    void distributeColumns(int startColumn, int endColumn);

    double columnPosition(int column) const;

    QList<double> columnPositions() const { return m_columnPositions; }

    void mergeCells(int row, int column, int numRows, int numCols);

    void splitCell(int row, int column, int numRows, int numCols);

    QSet<TableCell> selectedCells() const { return m_selection; }

    QSet<int> selectedRows() const;

    QSet<int> selectedColumns() const;

    void selectCell(int row, int column);

    void selectCells(int startRow, int startColumn, int endRow, int endColumn);

    void clearSelection();

    TableCell cellAt(int row, int column) const;

    TableCell cellAt(const QPointF& point) const;

    TableCell activeCell() const { return m_activeCell; }

    void moveLeft();

    void moveRight();

    void moveUp();

    void moveDown();

    void moveTo(const TableCell& cell);

    TableHandle hitTest(const QPointF& point, double threshold) const;

    void adjustTableToFrame();

    void adjustFrameToTable();

    void setFillColor(const QString& color);

    void unsetFillColor();

    QString fillColor() const;

    void setFillShade(const double& shade);

    void unsetFillShade();

    double fillShade() const;

    void setLeftBorder(const TableBorder& border);

    void unsetLeftBorder();

    TableBorder leftBorder() const;

    void setRightBorder(const TableBorder& border);

    void unsetRightBorder();

    TableBorder rightBorder() const;

    void setTopBorder(const TableBorder& border);

    void unsetTopBorder();

    TableBorder topBorder() const;

    void setBottomBorder(const TableBorder& border);

    void unsetBottomBorder();

    TableBorder bottomBorder() const;

    void setStyle(const QString& style);

    void unsetStyle();

    void unsetDirectFormatting();

    QString style() const;

    void updateCells() { updateCells(0, 0, rows() - 1, columns() - 1); }

    void updateCells(int startRow, int startColumn, int endRow, int endColumn);

    bool isOverflowing() const { return effectiveWidth() > width() || effectiveHeight() > height(); }

    virtual PageItem_Table* asTable() { return this; }

    virtual bool isTable() const { return true; }

    virtual ItemType realItemType() const { return PageItem::Table; }

    virtual void applicableActions(QStringList& actionList);

    virtual QString infoDescription() { return QString(); }

    QList<CellArea> cellAreas() const { return m_cellAreas; }

    QList<QList<TableCell> > cellRows() const { return m_cellRows; }

signals:
    void changed();
    void selectionChanged();

private slots:
    void handleStyleChanged();

protected:
    virtual void DrawObj_Item(ScPainter *p, QRectF clipRect);

private:
    enum ChangeType
    {
        RowsInserted,    
        RowsRemoved,     
        ColumnsInserted, 
        ColumnsRemoved   
    };

    void initialize(int numRows, int numColumns);

    void activateCell(const TableCell& cell);

    bool validRow(int row) const { return row >= 0 && row < m_rows; }
    bool validColumn(int column) const { return column >= 0 && column < m_columns; }
    bool validCell(int row, int column) const { return validRow(row) && validColumn(column); }

    double maxLeftBorderWidth() const;

    double maxRightBorderWidth() const;

    double maxTopBorderWidth() const;

    double maxBottomBorderWidth() const;

    double resizeRowMoveFollowing(int row, double height);
    double resizeRowResizeFollowing(int row, double height);
    double resizeColumnMoveFollowing(int row, double width);
    double resizeColumnResizeFollowing(int row, double width);

    void updateSpans(int index, int number, ChangeType changeType);

    void debug() const;

    void assertValid() const;

private:
    //<<Data we need to save
    QList<QList<TableCell> > m_cellRows;

    int m_rows;
    int m_columns;

    QList<double> m_rowPositions;
    QList<double> m_rowHeights;

    QList<double> m_columnPositions;
    QList<double> m_columnWidths;

    QList<CellArea> m_cellAreas;

    TableStyle m_style;
    //>>End of data we need to save
    //-----------------------------
    //<<Live working variables/data
    QSet<TableCell> m_selection;

    TablePainter* m_tablePainter;

    TableCell m_activeCell;

    /*
     * The two members below describe the active "logical position" on the table grid.
     * This position may or may not correspond with the position of the active cell.
     *
     * As an example, imagine the following scenario:
     *
     * +--------+--------+                            +--------+--------+
     * |        |        |                            |        | |      |
     * +--------+        |  --> User presses Tab -->  +--------+        |
     * | |      |        |                            |        |        |
     * +--------+--------+                            +--------+--------+
     *  Cursor in (1, 0)                               Cursor in (0, 1)
     *
     * The active cell is now the spanning cell at (0, 1). If we would use the row and
     * column of the active cell as the basis for keyboard navigation between cells,
     * then pressing Shift+Tab after the scenario above would bring the cursor into
     * cell (0, 0), not back to to (1, 0). Hence, in addition to the active cell, we
     * keep track of a "logical position". This is the logical position on the table
     * grid that is active. In the above scenario, the logical position would change
     * from (1, 0) to (1, 1).
     */

    int m_activeRow;

    int m_activeColumn;
    //>>End of live working variables/data
};

#endif // PAGEITEM_TABLE_H