future_Table.h

Go to the documentation of this file.

/***************************************************************************
    File                 : Table.h
    Project              : SciDAVis
    Description          : Aspect providing a spreadsheet table with column logic
    --------------------------------------------------------------------
    Copyright            : (C) 2006-2009 Tilman Benkert (thzs*gmx.net)
    Copyright            : (C) 2006-2009 Knut Franke (knut.franke*gmx.de)
    Copyright            : (C) 2006-2007 Ion Vasilief (ion_vasilief*yahoo.fr)
                           (replace * with @ in the email addresses) 

 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *  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.                                    *
 *                                                                         *
 *  This program is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *  GNU General Public License for more details.                           *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
 *   Boston, MA  02110-1301  USA                                           *
 *                                                                         *
 ***************************************************************************/
#ifndef FUTURE_TABLE_H
#define FUTURE_TABLE_H

#include "core/AbstractPart.h"
#ifndef LEGACY_CODE_0_2_x
#include "AbstractScriptingEngine.h"
#endif
#include "globals.h"
#include <QList>
#include <QStringList>

class TableView;
class QUndoStack;
class QMenu;
class Column;
class QPoint;
class QAction;
class AbstractColumn;
class ActionManager;
class TableStatistics;
class TeXTableSettings;

namespace future
{

#ifndef LEGACY_CODE_0_2_x
class Table : public AbstractPart, public scripted
#else
class Table : public AbstractPart
#endif
{
    Q_OBJECT

    public:
        class Private; // This could also be private, but then all commands need to be friend classes
        friend class Private;

#ifndef LEGACY_CODE_0_2_x
        Table(AbstractScriptingEngine *engine, int rows, int columns, const QString &name);
#else
        Table(void *engine, int rows, int columns, const QString &name);
        void setView(TableView * view);
        friend class ::TableStatistics;
#endif
        virtual ~Table();

        virtual QIcon icon() const;

        virtual QMenu *createContextMenu() const;

        virtual QWidget *view();
        

        void insertColumns(int before, QList<Column *> new_cols);
        /*
         * Convenience function, same as:
         * <code>
         * insertColumns(columnCount(), new_cols);
         * </code>
         */
        void appendColumns(QList<Column*> new_cols) { insertColumns(columnCount(), new_cols); }
        void removeColumns(int first, int count);
        void removeColumn(Column * col);
        void removeRows(int first, int count);
        void insertRows(int before, int count);
        void appendRows(int count) { insertRows(rowCount(), count); }
        void setRowCount(int new_size);
        int columnCount() const;
        int rowCount() const;
        int columnCount(SciDAVis::PlotDesignation pd) const;
        Column* column(int index) const;

        Column* column(const QString & name, bool legacy_kludge=true) const;
        int columnIndex(const Column * col) const;
        void setColumnCount(int new_size);
        QVariant headerData(int section, Qt::Orientation orientation,int role) const;


        QMenu * createSelectionMenu(QMenu * append_to = 0);

        QMenu * createColumnMenu(QMenu * append_to = 0);

        QMenu * createRowMenu(QMenu * append_to = 0);

        QMenu * createTableMenu(QMenu * append_to = 0);

        virtual bool fillProjectMenu(QMenu * menu);

        virtual bool fillProjectToolBar(QToolBar * bar);

        int colX(int col);
        int colY(int col);

        void setPlotMenu(QMenu * menu);
        void sortDialog(QList<Column*> cols);
        static void setDefaultCommentVisibility(bool visible) { d_default_comment_visibility = visible; }
        static bool defaultCommentVisibility() { return d_default_comment_visibility; }
        QString text(int row, int col);
        void setSelectionAs(SciDAVis::PlotDesignation pd);
        void copy(Table * other);



        virtual void save(QXmlStreamWriter *) const;
        virtual bool load(XmlStreamReader *);
        bool readColumnWidthElement(XmlStreamReader * reader);
        
    public:
        static ActionManager * actionManager();
        static void initActionManager();
        static int defaultColumnWidth() { return default_column_width; }
        static void setDefaultColumnWidth(int width) { default_column_width = width; }
    private:
        static ActionManager * action_manager;
        // TODO: the default sizes are to be controlled by the global Table settings
        static int default_column_width;
        Table();

    public slots:
        void clear();
#ifndef LEGACY_CODE_0_2_x

        void clearMasks();
#endif

        void addColumn();
        void addColumns();
        void addRows();
        void cutSelection();
        void copySelection();
        void pasteIntoSelection();
        void clearSelectedCells();
        void goToCell();
#ifndef LEGACY_CODE_0_2_x
        void maskSelection();
        void unmaskSelection();
#endif
        void setFormulaForSelection();
        void recalculateSelectedCells();
        void fillSelectedCellsWithRowNumbers();
        void fillSelectedCellsWithRandomNumbers();
        void sortTable();
        void insertEmptyColumns();
        void removeSelectedColumns();
        void clearSelectedColumns();
        void setSelectedColumnsAsX();
        void setSelectedColumnsAsY();
        void setSelectedColumnsAsZ();
        void setSelectedColumnsAsXError();
        void setSelectedColumnsAsYError();
        void setSelectedColumnsAsNone();
        void normalizeColumns(QList< Column* > cols);
        void normalizeSelectedColumns();
        void normalizeSelection();
        void sortSelectedColumns();
        void statisticsOnSelectedColumns();
        void statisticsOnSelectedRows();
        void insertEmptyRows();
        void removeSelectedRows();
        void selectAll();
        void dimensionsDialog();
        void editTypeAndFormatOfSelectedColumns();
        void editDescriptionOfCurrentColumn();
        void moveColumn(int from, int to);
        /*
         * If 'leading' is a null pointer, each column is sorted separately.
         */
        void sortColumns(Column * leading, QList<Column*> cols, bool ascending);

        void showTableViewContextMenu(const QPoint& pos);

        void showTableViewColumnContextMenu(const QPoint& pos);

        void showTableViewRowContextMenu(const QPoint& pos);

                void showTeXTableExportDialog();
               
                /*
                 * \param file name
                 * \param TeX tale settings
                */  
                bool export_to_TeX( QString fileName, TeXTableSettings& tex_settings );

                 

    protected:

        virtual void completeAspectInsertion(AbstractAspect * aspect, int index);

        virtual void prepareAspectRemoval(AbstractAspect * aspect);

    public:

        void setColumnWidth(int col, int width);
        int columnWidth(int col) const;

    private:
        void connectColumn(const Column* col);
        void disconnectColumn(const Column* col);

    private slots:

        void handleDescriptionChange(const AbstractAspect * aspect);
        void handleModeChange(const AbstractColumn * col);
        void handlePlotDesignationChange(const AbstractColumn * col);
        void handleDataChange(const AbstractColumn * col);
        void handleRowsAboutToBeInserted(const AbstractColumn * col, int before, int count);
        void handleRowsInserted(const AbstractColumn * col, int before, int count);
        void handleRowsAboutToBeRemoved(const AbstractColumn * col, int first, int count);
        void handleRowsRemoved(const AbstractColumn * col, int first, int count);
        void adjustActionNames();

    signals:
        void columnsAboutToBeInserted(int before, QList<Column*> new_cols);
        void columnsInserted(int first, int count);
        void columnsAboutToBeReplaced(int first, int count);
        void columnsReplaced(int first, int count);
        void columnsAboutToBeRemoved(int first, int count);
        void columnsRemoved(int first, int count);
        void rowsAboutToBeInserted(int before, int count);
        void rowsInserted(int first, int count);
        void rowsAboutToBeRemoved(int first, int count);
        void rowsRemoved(int first, int count);
        void dataChanged(int top, int left, int bottom, int right);
        void headerDataChanged(Qt::Orientation orientation, int first, int last);
#ifdef LEGACY_CODE_0_2_x
        void recalculate();
        void requestRowStatistics();
        void requestColumnStatistics();
#endif

    private:
        void createActions();
        void connectActions();
        void addActionsToView();
        QMenu * d_plot_menu;
        static bool d_default_comment_visibility;


        QAction * action_cut_selection;
        QAction * action_copy_selection;
        QAction * action_paste_into_selection;
#ifndef LEGACY_CODE_0_2_x
        QAction * action_mask_selection;
        QAction * action_unmask_selection;
#endif
        QAction * action_set_formula;
        QAction * action_clear_selection;
        QAction * action_recalculate;
        QAction * action_fill_row_numbers;
        QAction * action_fill_random;
        QAction * action_normalize_selection;


        QAction * action_toggle_comments;
        QAction * action_toggle_tabbar;
        QAction * action_select_all;
        QAction * action_add_column;
        QAction * action_clear_table;
                QAction * action_export_to_TeX;
#ifndef LEGACY_CODE_0_2_x
        QAction * action_clear_masks;
#endif
        QAction * action_sort_table;
        QAction * action_go_to_cell;
        QAction * action_dimensions_dialog;
        QAction * action_formula_mode;


        QAction * action_insert_columns;
        QAction * action_remove_columns;
        QAction * action_clear_columns;
        QAction * action_add_columns;
        QAction * action_set_as_x;
        QAction * action_set_as_y;
        QAction * action_set_as_z;
        QAction * action_set_as_xerr;
        QAction * action_set_as_yerr;
        QAction * action_set_as_none;
        QAction * action_normalize_columns;
        QAction * action_sort_columns;
        QAction * action_statistics_columns;
        QAction * action_type_format;
        QAction * action_edit_description;


        QAction * action_insert_rows;
        QAction * action_remove_rows;
        QAction * action_clear_rows;
        QAction * action_add_rows;
        QAction * action_statistics_rows;

        TableView *d_view;
        Private *d_table_private;
};

class Table::Private
{
    public:
        Private(Table *owner) : d_owner(owner), d_column_count(0), d_row_count(0) {}

        void replaceColumns(int first, QList<Column*> new_cols);

        void insertColumns(int before, QList<Column*> cols);

        void removeColumns(int first, int count);

        void appendColumns(QList<Column*> cols);
        void moveColumn(int from, int to);
        int columnCount() const { return d_column_count; }
        int rowCount() const { return d_row_count; }
        void setRowCount(int count);
        QString columnHeader(int col);
        int numColsWithPD(SciDAVis::PlotDesignation pd);
        Column* column(int index) const;

        int columnIndex(const Column * col) const 
        { 
            for(int i=0; i<d_columns.size(); i++)
                if(d_columns.at(i) == col) return i;
            return -1;
        }
        QString name() const { return d_owner->name(); }
        QVariant headerData(int section, Qt::Orientation orientation,int role) const;


        void updateVerticalHeader(int start_row);

        void updateHorizontalHeader(int start_col, int end_col);
        void setColumnWidth(int col, int width) { d_column_widths[col] = width; }
        int columnWidth(int col) const { return d_column_widths.at(col); }

    private:
        Table *d_owner;
        int d_column_count;
        int d_row_count;
        QList<int> d_vertical_header_data;
        QStringList d_horizontal_header_data;
        QList<Column *> d_columns;  

        void composeColumnHeader(int col, const QString& label);
        QList<int> d_column_widths;
};

} // namespace

#endif