columncommands.h

Go to the documentation of this file.

/***************************************************************************
    File                 : columncommands.h
    Project              : SciDAVis
    Description          : Commands to be called by Column to modify Column::Private
    --------------------------------------------------------------------
    Copyright            : (C) 2007-2009 Tilman Benkert (thzs*gmx.net)
                           (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 COLUMNCOMMANDS_H
#define COLUMNCOMMANDS_H

#include <QUndoCommand>
#include <QStringList>
#include "core/column/Column.h"
#include "core/AbstractSimpleFilter.h"
#include "lib/IntervalAttribute.h"

// class ColumnSetModeCmd
class ColumnSetModeCmd : public QUndoCommand
{
public:
    ColumnSetModeCmd(Column::Private * col, SciDAVis::ColumnMode mode,
            AbstractFilter *conversion_filter, QUndoCommand * parent = 0 );
    ~ColumnSetModeCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    SciDAVis::ColumnMode d_old_mode;    
    SciDAVis::ColumnMode d_mode;
    SciDAVis::ColumnDataType d_old_type;
    SciDAVis::ColumnDataType d_new_type;
    void * d_old_data;
    void * d_new_data;
    AbstractSimpleFilter* d_new_in_filter;
    AbstractSimpleFilter* d_new_out_filter;
    AbstractSimpleFilter* d_old_in_filter;
    AbstractSimpleFilter* d_old_out_filter;
    IntervalAttribute<bool> d_old_validity;
    IntervalAttribute<bool> d_new_validity;
    bool d_undone;
    bool d_executed;
    AbstractFilter *d_conversion_filter;
};
// end of class ColumnSetModeCmd


// class ColumnFullCopyCmd
class ColumnFullCopyCmd : public QUndoCommand
{
public:
    ColumnFullCopyCmd(Column::Private * col, const AbstractColumn * src, QUndoCommand * parent = 0 );
    ~ColumnFullCopyCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    const AbstractColumn * d_src;
    Column::Private * d_backup;

    Column * d_backup_owner;

};
// end of class ColumnFullCopyCmd

// class ColumnPartialCopyCmd
class ColumnPartialCopyCmd : public QUndoCommand
{
public:
    ColumnPartialCopyCmd(Column::Private * col, const AbstractColumn * src, int src_start, int dest_start, int num_rows, QUndoCommand * parent = 0 );
    ~ColumnPartialCopyCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    const AbstractColumn * d_src;
    Column::Private * d_col_backup;
    Column::Private * d_src_backup;

    Column * d_col_backup_owner;

    Column * d_src_backup_owner;
    int d_src_start;
    int d_dest_start;
    int d_num_rows;
    int d_old_row_count;
    IntervalAttribute<bool> d_old_validity;
    

};
// end of class ColumnPartialCopyCmd


// class ColumnInsertEmptyRowsCmd
class ColumnInsertEmptyRowsCmd : public QUndoCommand
{
public:
    ColumnInsertEmptyRowsCmd(Column::Private * col, int before, int count, QUndoCommand * parent = 0 );
    ~ColumnInsertEmptyRowsCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    int d_before;
    int d_count;

};
// end of class ColumnInsertEmptyRowsCmd

// class ColumnRemoveRowsCmd
class ColumnRemoveRowsCmd : public QUndoCommand 
{
public:
    ColumnRemoveRowsCmd(Column::Private * col, int first, int count, QUndoCommand * parent = 0 );
    ~ColumnRemoveRowsCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    int d_first;
    int d_count;
    int d_data_row_count;
    int d_old_size;
    Column::Private * d_backup;

    Column * d_backup_owner;
    IntervalAttribute<bool> d_masking;
    IntervalAttribute<QString> d_formulas;
};
// end of class ColumnRemoveRowsCmd

// class ColumnSetPlotDesignationCmd
class ColumnSetPlotDesignationCmd : public QUndoCommand
{
public:
    ColumnSetPlotDesignationCmd(Column::Private * col, SciDAVis::PlotDesignation pd, QUndoCommand * parent = 0 );
    ~ColumnSetPlotDesignationCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    SciDAVis::PlotDesignation d_new_pd;
    SciDAVis::PlotDesignation d_old_pd;
};
// end of class ColumnSetPlotDesignationCmd


// class ColumnClearCmd
class ColumnClearCmd : public QUndoCommand
{
public:
    ColumnClearCmd(Column::Private * col, QUndoCommand * parent = 0 );
    ~ColumnClearCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    SciDAVis::ColumnDataType d_type;
    void * d_data;
    void * d_empty_data;
    IntervalAttribute<bool> d_validity;
    bool d_undone;

};
// end of class ColumnClearCmd


// class ColumnClearValidityCmd
class ColumnClearValidityCmd : public QUndoCommand
{
public:
    ColumnClearValidityCmd(Column::Private * col, QUndoCommand * parent = 0 );
    ~ColumnClearValidityCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    IntervalAttribute<bool> d_validity;
    bool d_copied;

};
// end of class ColumnClearValidityCmd

// class ColumnClearMasksCmd
class ColumnClearMasksCmd : public QUndoCommand
{
public:
    ColumnClearMasksCmd(Column::Private * col, QUndoCommand * parent = 0 );
    ~ColumnClearMasksCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    IntervalAttribute<bool> d_masking;
    bool d_copied;

};
// end of class ColumnClearMasksCmd

// class ColumnSetInvalidCmd
class ColumnSetInvalidCmd : public QUndoCommand
{
public:
    ColumnSetInvalidCmd(Column::Private * col, Interval<int> interval, bool invalid, QUndoCommand * parent = 0 );
    ~ColumnSetInvalidCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    Interval<int> d_interval;
    bool d_invalid;
    IntervalAttribute<bool> d_validity;
    bool d_copied;

};
// end of class ColumnSetInvalidCmd

// class ColumnSetMaskedCmd
class ColumnSetMaskedCmd : public QUndoCommand
{
public:
    ColumnSetMaskedCmd(Column::Private * col, Interval<int> interval, bool masked, QUndoCommand * parent = 0 );
    ~ColumnSetMaskedCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    Interval<int> d_interval;
    bool d_masked;
    IntervalAttribute<bool> d_masking;
    bool d_copied;

};
// end of class ColumnSetMaskedCmd

// class ColumnSetFormulaCmd
class ColumnSetFormulaCmd : public QUndoCommand
{
public:
    ColumnSetFormulaCmd(Column::Private * col, Interval<int> interval, const QString& formula, QUndoCommand * parent = 0 );
    ~ColumnSetFormulaCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    Interval<int> d_interval;
    QString d_formula;
    IntervalAttribute<QString> d_formulas;
    bool d_copied;

};
// end of class ColumnSetFormulaCmd

// class ColumnClearFormulasCmd
class ColumnClearFormulasCmd : public QUndoCommand
{
public:
    ColumnClearFormulasCmd(Column::Private * col, QUndoCommand * parent = 0 );
    ~ColumnClearFormulasCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    IntervalAttribute<QString> d_formulas;
    bool d_copied;

};
// end of class ColumnClearFormulasCmd

// class ColumnSetTextCmd
class ColumnSetTextCmd : public QUndoCommand
{
public:
    ColumnSetTextCmd(Column::Private * col, int row, const QString& new_value, QUndoCommand * parent = 0 );
    ~ColumnSetTextCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    int d_row;
    QString d_new_value;
    QString d_old_value;
    int d_row_count;
    IntervalAttribute<bool> d_validity;

};
// end of class ColumnSetTextCmd

// class ColumnSetValueCmd
class ColumnSetValueCmd : public QUndoCommand
{
public:
    ColumnSetValueCmd(Column::Private * col, int row, double new_value, QUndoCommand * parent = 0 );
    ~ColumnSetValueCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    int d_row;
    double d_new_value;
    double d_old_value;
    int d_row_count;
    IntervalAttribute<bool> d_validity;

};
// end of class ColumnSetValueCmd

// class ColumnSetDateTimeCmd
class ColumnSetDateTimeCmd : public QUndoCommand
{
public:
    ColumnSetDateTimeCmd(Column::Private * col, int row, const QDateTime& new_value, QUndoCommand * parent = 0 );
    ~ColumnSetDateTimeCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    int d_row;
    QDateTime d_new_value;
    QDateTime d_old_value;
    int d_row_count;
    IntervalAttribute<bool> d_validity;

};
// end of class ColumnSetDateTimeCmd

// class ColumnReplaceTextsCmd
class ColumnReplaceTextsCmd : public QUndoCommand
{
public:
    ColumnReplaceTextsCmd(Column::Private * col, int first, const QStringList& new_values, QUndoCommand * parent = 0 );
    ~ColumnReplaceTextsCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    int d_first;
    QStringList d_new_values;
    QStringList d_old_values;
    bool d_copied;
    int d_row_count;
    IntervalAttribute<bool> d_validity;

};
// end of class ColumnReplaceTextsCmd

// class ColumnReplaceValuesCmd
class ColumnReplaceValuesCmd : public QUndoCommand
{
public:
    ColumnReplaceValuesCmd(Column::Private * col, int first, const QVector<qreal>& new_values, QUndoCommand * parent = 0 );
    ~ColumnReplaceValuesCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    int d_first;
    QVector<qreal> d_new_values;
    QVector<qreal> d_old_values;
    bool d_copied;
    int d_row_count;
    IntervalAttribute<bool> d_validity;

};
// end of class ColumnReplaceValuesCmd

// class ColumnReplaceDateTimesCmd
class ColumnReplaceDateTimesCmd : public QUndoCommand
{
public:
    ColumnReplaceDateTimesCmd(Column::Private * col, int first, const QList<QDateTime>& new_values, QUndoCommand * parent = 0 );
    ~ColumnReplaceDateTimesCmd();

    virtual void redo();
    virtual void undo();

private:
    Column::Private * d_col;
    int d_first;
    QList<QDateTime> d_new_values;
    QList<QDateTime> d_old_values;
    bool d_copied;
    int d_row_count;
    IntervalAttribute<bool> d_validity;

};
// end of class ColumnReplaceDateTimesCmd




#endif