ApplicationWindow.h

Go to the documentation of this file.

/***************************************************************************
    File                 : ApplicationWindow.h
    Project              : SciDAVis
    Description          : SciDAVis's main window
    --------------------------------------------------------------------
    Copyright            : (C) 2006-2009 Knut Franke (knut.franke*gmx.de)
    Copyright            : (C) 2006-2009 Tilman Benkert (thzs*gmx.net)
    Copyright            : (C) 2004-2007 by Ion Vasilief (ion_vasilief*yahoo.fr)
                           (replace * with @ in the email address)

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

/***************************************************************************
 *                                                                         *
 *  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 APPLICATION_H
#define APPLICATION_H

#include <QMainWindow>
#include <Q3ListView>
#include <Q3Header>
#ifdef SEARCH_FOR_UPDATES
#include <QHttp>
#endif
#include <QFile>
#include <QSplitter>
#include <QDesktopServices>
#include <QBuffer>
#include <QLocale>

#include "Table.h"
#include "ScriptingEnv.h"
#include "Script.h"

class QPixmap;
class QCloseEvent;
class QDropEvent;
class QTimerEvent;
class QDragEnterEvent;
class QTranslator;
class QDockWidget;
class QAction;
class QActionGroup;
class QWorkspace;
class QLineEdit;
class QTranslator;
class QToolButton;
class QShortcut;
class QMenu;
class QToolBar;
class QAssistantClient;
class QStatusBar;
class QSignalMapper;

class Matrix;
class Table;
class Graph;
class ScalePicker;
class Graph3D;
class Note;
class MultiLayer;
class FunctionDialog;
class Folder;
class FolderListItem;
class FolderListView;
class Plot3DDialog;
class MyWidget;
class TableStatistics;
class CurveRangeDialog;
class Project;
class AbstractAspect;

#ifndef TS_PATH
#define TS_PATH (qApp->applicationDirPath() + "/translations")
#endif

class ApplicationWindow: public QMainWindow, public scripted
{
    Q_OBJECT
public:
    ApplicationWindow();
    ApplicationWindow(const QStringList& l);
    ~ApplicationWindow();

    enum ShowWindowsPolicy{HideAll, ActiveFolder, SubFolders};

    QAssistantClient *assistant;
    QTranslator *appTranslator, *qtTranslator;
    QDockWidget *logWindow, *explorerWindow;
    QTextEdit *results;
#ifdef SCRIPTING_CONSOLE
    QDockWidget *consoleWindow;
    QTextEdit *console;
#endif
    QWorkspace* d_workspace;
    QToolBar *file_tools, *graph_tools, *table_tools, *plot_tools, *graph_3D_tools, *edit_tools, *matrix_plot_tools;
    FolderListView *lv, *folders;
    QToolButton *btnResults;
    QWidgetList *hiddenWindows, *outWindows;
    QWidget *lastModified;

public:
    QString generateUniqueName(const QString& name, bool increment = true);

public slots:
    void copyStatusBarText();
    void showStatusBarContextMenu( const QPoint & pos );

    void open();
    ApplicationWindow* open(const QString& fn);

    QFile * openCompressedFile(const QString& fn);
    ApplicationWindow* openProject(const QString& fn);
#ifdef ORIGIN_IMPORT
    ApplicationWindow* importOPJ(const QString& filename);
#endif
    void showHistory();

    ApplicationWindow * plotFile(const QString& fn);

    ApplicationWindow * loadScript(const QString& fn, bool execute = false);

    QWidgetList * windowsList();
    void updateWindowLists(MyWidget *w);
    void cascade();

    void saveProjectAs();
    bool saveProject();

    void modifiedProject();
    void savedProject();
    void modifiedProject(QWidget *w);


    void readSettings();
    void saveSettings();
    void applyUserSettings();
    void setSaveSettings(bool autoSaving, int min);
    void changeAppStyle(const QString& s);
    void changeAppFont(const QFont& f);
    void updateAppFonts();
    void setAppColors(const QColor& wc,const QColor& pc,const QColor& tpc);


    MultiLayer* multilayerPlot(int c, int r, int style);
    MultiLayer* multilayerPlot(Table* w, const QStringList& colList, int style, int startRow = 0, int endRow = -1);
    MultiLayer* multilayerPlot(const QString& caption);
    MultiLayer* multilayerPlot(const QStringList& colList);
    void connectMultilayerPlot(MultiLayer *g);
    void addLayer();
    void deleteLayer();

    MultiLayer* plotSpectrogram(Matrix *m, Graph::CurveType type);
    void plotGrayScale();
    MultiLayer* plotGrayScale(Matrix *m);
    void plotContour();
    MultiLayer* plotContour(Matrix *m);
    void plotColorMap();
    MultiLayer* plotColorMap(Matrix *m);

    void autoArrangeLayers();
    void initMultilayerPlot(MultiLayer* g, const QString& name);
    void polishGraph(Graph *g, int style);
    void plot2VerticalLayers();
    void plot2HorizontalLayers();
    void plot4Layers();
    void plotStackedLayers();
    void plotStackedHistograms();


    Graph3D* openMatrixPlot3D(const QString& caption, const QString& matrix_name,
                             double xl,double xr,double yl,double yr,double zl,double zr);
    Graph3D* dataPlot3D(Table* table,const QString& colName);
    Graph3D* dataPlotXYZ(Table* table,const QString& zColName, int type);
    Graph3D* dataPlot3D(const QString& caption,const QString& formula,
                        double xl, double xr, double yl, double yr, double zl, double zr);
    Graph3D* dataPlotXYZ(const QString& caption,const QString& formula,
                        double xl, double xr, double yl, double yr, double zl, double zr);


    Graph3D* newPlot3D();
    Graph3D* newPlot3D(const QString& formula, double xl, double xr,
                       double yl, double yr, double zl, double zr);
    Graph3D* newPlot3D(const QString& caption,const QString& formula,
                       double xl, double xr,double yl, double yr, double zl, double zr);
    void connectSurfacePlot(Graph3D *plot);
    void newSurfacePlot();
    void editSurfacePlot();
    void remove3DMatrixPlots(Matrix *m);
    void updateMatrixPlots(QWidget *);
    void add3DData();
    void change3DData();
    void change3DData(const QString& colName);
    void change3DMatrix();
    void change3DMatrix(const QString& matrix_name);
    void insertNew3DData(const QString& colName);
    void add3DMatrixPlot();
    void insert3DMatrixPlot(const QString& matrix_name);
    void initPlot3D(Graph3D *plot);
    void customPlot3D(Graph3D *plot);
    void setPlot3DOptions();

    void plot3DWireframe();
    void plot3DHiddenLine();
    void plot3DPolygons();
    void plot3DWireSurface();

    void plot3DMatrix(int style);

    void plot3DRibbon();
    void plot3DScatter();
    void plot3DTrajectory();
    void plot3DBars();


    bool newFunctionPlot(int type,QStringList &formulas, const QString& var,QList<double> &ranges, int points);

    FunctionDialog* functionDialog();
    void showFunctionDialog();
    void showFunctionDialog(Graph * g, int curve);
    void addFunctionCurve();
    void clearFitFunctionsList();
    void saveFitFunctionsList(const QStringList& l);
    void clearSurfaceFunctionsList();
    void clearLogInfo();
    void clearParamFunctionsList();
    void clearPolarFunctionsList();
    void updateFunctionLists(int type, QStringList &formulas);
    void updateSurfaceFuncList(const QString& s);



    Matrix* newMatrix(int rows = 32, int columns = 32);
    Matrix* newMatrix(const QString& caption, int r, int c);
    Matrix* matrix(const QString& name);
    Matrix* convertTableToMatrix();
    void initMatrix(Matrix* m);
    void invertMatrix();
    void matrixDeterminant();



    Table* newTable();
    Table* newTable(const QString& fname, const QString &sep, int lines,
                    bool renameCols, bool stripSpaces, bool simplifySpaces,
                        bool convertToNumeric, QLocale numericLocale);
    Table* newTable(const QString& caption,int r, int c);
    Table* newTable(int r, int c, const QString& name = QString(),const QString& legend = QString());
    Table* newTable(const QString& name, const QString& legend, QList<Column *> columns);
    Table* newHiddenTable(const QString& name, const QString& label, QList<Column *> columns);
    Table* table(const QString& name);
    Table* convertMatrixToTable();
    QWidgetList* tableList();

    void connectTable(Table* w);
    void newWrksheetPlot(const QString& name,const QString& label, QList<Column *> columns);
    void initTable(Table* w);
    void customTable(Table* w);
    void customizeTables(const QColor& bgColor,const QColor& textColor,
                        const QColor& headerColor,const QFont& textFont,
                        const QFont& headerFont, bool showComments);

    void importASCII();
    void importASCII(const QStringList& files, int import_mode, const QString& local_column_separator, int local_ignored_lines,
         bool local_rename_columns, bool local_strip_spaces, bool local_simplify_spaces, bool local_convert_to_numeric, QLocale local_numeric_locale);
    void exportAllTables(const QString& sep, bool colNames, bool expSelection);
    void exportASCII(const QString& tableName, const QString& sep, bool colNames, bool expSelection);

    TableStatistics *newTableStatistics(Table *base, int type, QList<int>,
        const QString &caption=QString::null);


    void setPreferences(Graph* g);
    void setGraphDefaultSettings(bool autoscale,bool scaleFonts,bool resizeLayers,bool antialiasing);
    void setLegendDefaultSettings(int frame, const QFont& font,
                             const QColor& textCol, const QColor& backgroundCol);
    void setArrowDefaultSettings(int lineWidth,  const QColor& c, Qt::PenStyle style,
                                int headLength, int headAngle, bool fillHead);
    void plotPie();
    void plotVectXYXY();
    void plotVectXYAM();


    void intensityTable();
    void pixelLineProfile();
    void loadImage();
    void loadImage(const QString& fn);
    Matrix* importImage();
    Matrix* importImage(const QString& fn);


    void exportLayer();
    void exportGraph();
    void exportAllGraphs();
    void exportPDF();
    void print();
    void print(QWidget* w);
    void printAllPlots();

    QStringList columnsList(SciDAVis::PlotDesignation plotType);
    QStringList columnsList();

    void undo();
    void redo();


    MyWidget* clone();
    MyWidget* clone(MyWidget*);
    void renameActiveWindow();

    void renameWindow(Q3ListViewItem *item, int, const QString &s);

    bool renameWindow(MyWidget *w, const QString &text);

    void maximizeWindow(Q3ListViewItem * lbi);
    void maximizeWindow();
    void minimizeWindow();
    void setWindowGeometry(int x, int y, int w, int h);

    void updateWindowStatus(MyWidget* );

    bool hidden(QWidget* window);
    void closeActiveWindow();
    void closeWindow(MyWidget* window);

    void removeWindowFromLists(MyWidget* w);

    void hideWindow(MyWidget* window);
    void hideActiveWindow();
    void activateWindow();
    void activateWindow(MyWidget *);
    void printWindow();

    static void about();
    static QString versionString();
    void windowsMenuAboutToShow();
    void windowsMenuActivated( int id );
    void removeCurves(const QString& name);
    QStringList dependingPlots(const QString& caption);
    QStringList depending3DPlots(Matrix *m);
    QStringList multilayerDependencies(QWidget *w);

    void saveAsTemplate();
    void openTemplate();

    QString windowGeometryInfo(MyWidget *w);
    void restoreWindowGeometry(ApplicationWindow *app, MyWidget *w, const QString s);

    void resizeActiveWindow();
    void resizeWindow();


    void setListView(const QString& caption,const QString& view);
    void renameListViewItem(const QString& oldName,const QString& newName);
    void setListViewDate(const QString& caption,const QString& date);
    QString listViewDate(const QString& caption);
    void setListViewLabel(const QString& caption,const QString& label);

    void updateColNames(const QString& oldName, const QString& newName);
    void updateTableNames(const QString& oldName, const QString& newName);
    void changeMatrixName(const QString& oldName, const QString& newName);
    void updateCurves(Table *t, const QString& name);

    void showTable(const QString& curve);

    void addColToTable();
    void cutSelection();
    void copySelection();
    void copyMarker();
    void pasteSelection();
    void clearSelection();
    void copyActiveLayer();

    void newProject();

    MultiLayer* newGraph(const QString& caption = tr("Graph"));


    Matrix* openMatrix(ApplicationWindow* app, const QStringList &flist);
    Table* openTable(ApplicationWindow* app, QTextStream &stream);
    TableStatistics* openTableStatistics(const QStringList &flist);
    Graph3D* openSurfacePlot(ApplicationWindow* app, const QStringList &lst);
    Graph* openGraph(ApplicationWindow* app, MultiLayer *plot, const QStringList &list);

    void openRecentProject();


    void insertTranslatedStrings();
    void translateActionsStrings();
    void init();
    void initGlobalConstants();
    void createActions();
    void initMainMenu();
    void initPlotMenu();
    void initTableAnalysisMenu();
    void initPlotDataMenu();
    void initToolBars();
    void initPlot3DToolBar();
    void disableActions();
    void hideToolbars();
    void customToolBars(QWidget* w);
    void customMenu(QWidget* w);
    void windowActivated(QWidget *w);


    void correlate();
    void autoCorrelate();
    void convolute();
    void deconvolute();
    void clearTable();


    void newLegend();
    void addTimeStamp();
    void drawLine();
    void drawArrow();
    void addText();
    void disableAddText();
    void addImage();
    void zoomIn();
    void zoomOut();
    void setAutoScale();
    void showRangeSelectors();
    void showCursor();
    void showScreenReader();
    void pickPointerCursor();
    void pickDataTool( QAction* action );

    void updateLog(const QString& result);


    void deleteFitTables();
    void fitLinear();
    void fitSigmoidal();
    void fitGauss();
    void fitLorentz();
    void fitMultiPeak(int profile);
    void fitMultiPeakGauss();
    void fitMultiPeakLorentz();


    void differentiate();
    void analysis(const QString& whichFit);
    void analyzeCurve(Graph *g, const QString& whichFit, const QString& curveTitle);
    void showDataSetDialog(const QString& whichFit);

    void addErrorBars();
    void defineErrorBars(const QString& name,int type,const QString& percent,int direction);
    void defineErrorBars(const QString& curveName,const QString& errColumnName, int direction);
    void movePoints();
    void removePoints();


    void closeEvent( QCloseEvent*);
    void timerEvent ( QTimerEvent *e);
    void dragEnterEvent( QDragEnterEvent* e );
    void dropEvent( QDropEvent* e );
    void customEvent( QEvent* e);


    void showFindDialogue();
    void showPlotDialog(int curveKey = -1);
    QDialog* showScaleDialog();
    QDialog* showPlot3dDialog();
    AxesDialog* showScalePageFromAxisDialog(int axisPos);
    AxesDialog* showAxisPageFromAxisDialog(int axisPos);
    void showAxisDialog();
    void showGridDialog();
    void showGeneralPlotDialog();
    void showResults(bool ok);
    void showResults(const QString& s, bool ok=true);
    void showTextDialog();
    void showLineDialog();
    void showTitleDialog();
    void showExportASCIIDialog();
    void showCurvesDialog();
    void showCurveRangeDialog();
    CurveRangeDialog* showCurveRangeDialog(Graph *g, int curve);
    void showPlotAssociations(int curve);

    void showXAxisTitleDialog();
    void showYAxisTitleDialog();
    void showRightAxisTitleDialog();
    void showTopAxisTitleDialog();

    void showGraphContextMenu();
    void showLayerButtonContextMenu();
    void showWindowContextMenu();
    void showWindowTitleBarMenu();
    void showCurveContextMenu(int curveKey);
    void showCurvePlotDialog();
    void showCurveWorksheet();
    void showCurveWorksheet(Graph *g, int curveIndex);
    void showWindowPopupMenu(Q3ListViewItem *it, const QPoint &p, int);

    void showListViewSelectionMenu(const QPoint &p);

    void showListViewPopupMenu(const QPoint &p);

    void showMoreWindows();
    void showMarkerPopupMenu();
    void showHelp();
    static void showStandAloneHelp();
    void chooseHelpFolder();
    QString guessHelpFolder();
    void showPlotWizard();
    void showFitPolynomDialog();
    void showIntegrationDialog();
    void showInterpolationDialog();
    void showExpGrowthDialog();
    void showExpDecayDialog();
    void showExpDecayDialog(int type);
    void showTwoExpDecayDialog();
    void showExpDecay3Dialog();
    void showRowStatistics();
    void showColStatistics();
    void showFitDialog();
    void showImageDialog();
    void showPlotGeometryDialog();
    void showLayerDialog();
    void showPreferencesDialog();
    void showSmoothSavGolDialog();
    void showSmoothFFTDialog();
    void showSmoothAverageDialog();
    void showSmoothDialog(int m);
    void showFilterDialog(int filter);
    void lowPassFilterDialog();
    void highPassFilterDialog();
    void bandPassFilterDialog();
    void bandBlockFilterDialog();
    void showFFTDialog();

    void translateCurveHor();
    void translateCurveVert();

    void removeCurve();
    void hideCurve();
    void hideOtherCurves();
    void showAllCurves();
    void setCurveFullRange();

    void updateConfirmOptions(bool askTables, bool askMatrixes, bool askPlots2D, bool askPlots3D, bool askNotes);


    void toggle3DAnimation(bool on = true);
    void togglePerspective(bool on = true);
    void resetRotation();
    void fitFrameToLayer();
    void setFramed3DPlot();
    void setBoxed3DPlot();
    void removeAxes3DPlot();
    void removeGrid3DPlot();
    void setHiddenLineGrid3DPlot();
    void setLineGrid3DPlot();
    void setPoints3DPlot();
    void setCrosses3DPlot();
    void setCones3DPlot();
    void setBars3DPlot();
    void setFilledMesh3DPlot();
    void setEmptyFloor3DPlot();
    void setFloorData3DPlot();
    void setFloorIso3DPlot();
    void setFloorGrid3DPlot(bool on);
    void setCeilGrid3DPlot(bool on);
    void setRightGrid3DPlot(bool on);
    void setLeftGrid3DPlot(bool on);
    void setFrontGrid3DPlot(bool on);
    void setBackGrid3DPlot(bool on);
    void pickPlotStyle( QAction* action );
    void pickCoordSystem( QAction* action);
    void pickFloorStyle( QAction* action);
    void custom3DActions(QWidget *w);
    void custom3DGrids(int grids);

    void updateRecentProjectsList();

#ifdef SEARCH_FOR_UPDATES

    void receivedVersionFile(bool error);
    void searchForUpdates();
#endif

    void showHomePage();
    void showForums();
    void showBugTracker();
#ifdef DOWNLOAD_LINKS

    void downloadManual();
#endif

    void parseCommandLineArguments(const QStringList& args);
    void createLanguagesList();
    void switchToLanguage(int param);
    void switchToLanguage(const QString& locale);

    bool alreadyUsedName(const QString& label);
    bool projectHas2DPlots();
    bool projectHas3DPlots();
    bool projectHasMatrices();

    QWidget* window(const QString& name);

    QStringList matrixNames();



    Note* newNote(const QString& caption = QString());
    Note* openNote(ApplicationWindow* app, const QStringList &flist);
    void initNote(Note* m, const QString& caption);
    void saveNoteAs();



    Folder* currentFolder(){return current_folder;};
    void addFolder();
    void deleteFolder();

    bool deleteFolder(Folder *f);

    void deleteSelectedItems();

    void deactivateFolders();

    bool changeFolder(Folder *newFolder, bool force = false);

    void folderItemChanged(Q3ListViewItem *it);
    void folderItemDoubleClicked(Q3ListViewItem *it);


    void showFolderPopupMenu(Q3ListViewItem *it, const QPoint &p, bool fromFolders);

    void showFolderPopupMenu(Q3ListViewItem *it, const QPoint &p, int);

    void startRenameFolder();

    void startRenameFolder(Q3ListViewItem *item);

    void renameFolder(Q3ListViewItem *it, int col, const QString &text);

    void showAllFolderWindows();

    void hideAllFolderWindows();

    void hideFolderWindows(Folder *f);

    void folderProperties();

    void windowProperties();

    void projectProperties();

    void appendProject();
    void appendProject(const QString& file_name);
    void saveAsProject();
    void saveFolderAsProject(Folder *f);
    void saveFolder(Folder *folder, const QString& fn);
    void rawSaveFolder(Folder *folder, QIODevice *device);

    void addFolderListViewItem(Folder *f);

    void addListViewItem(MyWidget *w);

    void setShowWindowsPolicy(int p);

    Folder* projectFolder();

    void find(const QString& s, bool windowNames, bool labels, bool folderNames,
              bool caseSensitive, bool partialMatch, bool subfolders);

    void dragFolderItems(QList<Q3ListViewItem *> items){draggedItems = items;};

    void dropFolderItems(Q3ListViewItem *dest);


    void moveFolder(FolderListItem *src, FolderListItem *dest);



    void scriptError(const QString &message, const QString &scriptName, int lineNumber);
    void executeNotes();
    void showScriptingLangDialog();
    void restartScriptingEnv();
    void scriptPrint(const QString &text);
    bool setScriptingLang(const QString &lang, bool force=false);

signals:
    void modified();

// TODO: a lot of this stuff should be private
public:
    QString d_image_export_filter;
    bool d_keep_plot_aspect;
    int d_export_vector_size;
    bool d_export_transparency;
    int d_export_quality;
    int d_export_resolution;
    bool d_export_color;
     int d_export_orientation;
    QLocale d_ASCII_import_locale;
    QString d_ASCII_file_filter;
    bool d_convert_to_numeric;
    bool d_show_current_folder;
    bool d_scale_plots_on_print, d_print_cropmarks;
    bool d_show_table_comments;
    bool d_extended_plot_dialog;
    bool d_extended_import_ASCII_dialog;
    bool d_extended_export_dialog;
    bool d_extended_open_dialog;
    bool generateUniformFitPoints;
    bool generatePeakCurves;
    int peakCurvesColor;
    QSize d_add_curves_dialog_size;

    bool fit_scale_errors;

    int fitPoints;

    bool d_2_linear_fit_points;

    bool pasteFitResultsToPlot;

    bool writeFitResultsToLog;

    int fit_output_precision;

    int d_decimal_digits;

    char d_default_numeric_format;

    Folder *current_folder;
    ShowWindowsPolicy show_windows_policy;
    enum {MaxRecentProjects = 10};
    int d_file_version;

    QColor workspaceColor, panelsColor, panelsTextColor;
    QString appStyle, workingDir;

    QString templatesDir;
    bool smooth3DMesh, autoScaleFonts, autoResizeLayers;
#ifdef SEARCH_FOR_UPDATES
    bool autoSearchUpdates;
#endif
    bool confirmCloseTable, confirmCloseMatrix, confirmClosePlot2D, confirmClosePlot3D;
    bool confirmCloseFolder, confirmCloseNotes;
    bool canvasFrameOn, titleOn, autoSave, drawBackbones, allAxesOn, autoscale2DPlots, antialiasing2DPlots;
    int majTicksStyle, minTicksStyle, legendFrameStyle, autoSaveTime, axesLineWidth, canvasFrameWidth;
    QColor legendBackground, legendTextColor, defaultArrowColor;
    int defaultArrowLineWidth, defaultArrowHeadLength, defaultArrowHeadAngle;
    bool defaultArrowHeadFill;
    Qt::PenStyle defaultArrowLineStyle;
    int majTicksLength, minTicksLength, defaultPlotMargin;
    int defaultCurveStyle, defaultCurveLineWidth, defaultSymbolSize;
    int undoLimit;
    QFont appFont, plot3DTitleFont, plot3DNumbersFont, plot3DAxesFont;
    QFont tableTextFont, tableHeaderFont, plotAxesFont, plotLegendFont, plotNumbersFont, plotTitleFont;
    QColor tableBkgdColor, tableTextColor, tableHeaderColor;
    QString projectname,columnSeparator, helpFilePath, appLanguage;
    QString configFilePath, logInfo, fitPluginsPath, asciiDirPath, imagesDirPath;
    int logID,asciiID,closeID, exportID, printAllID, ignoredLines, savingTimerId, plot3DResolution;
    bool renameColumns, copiedLayer, strip_spaces, simplify_spaces;
    QStringList recentProjects;
    QStringList tableWindows();
    bool saved, showPlot3DProjection, showPlot3DLegend, orthogonal3DPlots, autoscale3DPlots;
    QStringList plot3DColors, locales;
    QStringList functions; //user-defined functions;
    QStringList xFunctions, yFunctions, rFunctions,thetaFunctions; // user functions for parametric and polar plots
    QStringList fitFunctions; //user-defined fit functions;
    QStringList surfaceFunc; //user-defined surface functions;

    QStringList renamedTables;
    Graph::MarkerType copiedMarkerType;


    QString auxMrkText;
    QFont auxMrkFont;
    QColor auxMrkColor, auxMrkBkgColor;
    QPoint auxMrkStart,auxMrkEnd;
    Qt::PenStyle auxMrkStyle;
    QString auxMrkFileName;
    int auxMrkBkg,auxMrkWidth;

    bool startArrowOn, endArrowOn, fillArrowHead;
    int arrowHeadLength, arrowHeadAngle, specialPlotMenuID, statMenuID, panelMenuID, plot3dID;
    int plotMenuID, newMenuID, recentMenuID, setAsMenuID, fillMenuID; 
    int translateMenuID, smoothMenuID, filterMenuID, fitExpMenuID, multiPeakMenuID;

#ifdef SEARCH_FOR_UPDATES

    bool autoSearchUpdatesRequest;
#endif

    QString defaultScriptingLang;

private:
    void showWindowMenu(MyWidget * widget);
    QMenu *createToolbarsMenu();

    bool validFor3DPlot(Table *table);
    bool validFor2DPlot(Table *table, int type);

    int convertOldToNewColorIndex(int cindex);

    QList<Q3ListViewItem *> draggedItems;

#ifdef SEARCH_FOR_UPDATES

    QHttp http;
    QBuffer version_buffer;
#endif

    Graph *lastCopiedLayer;
    QSplitter *explorerSplitter;

    QMenu *windowsMenu,*view,*graph,*file,*format,*calcul,*edit,*dataMenu,*recent, *exportPlot, *toolbarsMenu;
    QMenu *d_quick_fit_menu;
    QMenu *help,*type,*plot2D,*plot3D, *specialPlot, *panels,*stat,*decay, *filter;
    QMenu *matrixMenu, *plot3DMenu, *plotDataMenu, *tableMenu;
    QMenu *smooth, *translateMenu, *multiPeakMenu;
    QMenu *scriptingMenu;
    QAction *actionCopyStatusBarText;
    QAction *actionEditCurveRange, *actionCurveFullRange, *actionShowAllCurves, *actionHideCurve, *actionHideOtherCurves;
    QAction *actionEditFunction, *actionRemoveCurve, *actionShowCurveWorksheet, *actionShowCurvePlotDialog;
    QAction *actionNewProject, *actionNewNote, *actionNewTable, *actionNewFunctionPlot, *actionNewSurfacePlot, *actionNewMatrix, *actionNewGraph;
    QAction *actionOpen, *actionLoadImage, *actionSaveProject, *actionSaveProjectAs, *actionImportImage;
    QAction *actionLoad, *actionUndo, *actionRedo;
    QAction *actionCopyWindow;
    QAction *actionCutSelection, *actionCopySelection, *actionPasteSelection, *actionClearSelection;
    QAction *actionShowExplorer, *actionShowLog, *actionAddLayer, *actionShowLayerDialog, *actionAutomaticLayout;
    QAction *actionShowHistory;
#ifdef SCRIPTING_CONSOLE
    QAction *actionShowConsole;
#endif

    QAction *actionExportGraph, *actionExportAllGraphs, *actionPrint, *actionPrintAllPlots, *actionShowExportASCIIDialog;
    QAction *actionExportPDF;
    QAction *actionCloseAllWindows, *actionClearLogInfo, *actionShowPlotWizard, *actionShowConfigureDialog;
    QAction *actionShowCurvesDialog, *actionAddErrorBars, *actionAddFunctionCurve, *actionUnzoom, *actionNewLegend, *actionAddImage, *actionAddText;
    QAction *actionPlotL, *actionPlotP, *actionPlotLP, *actionPlotVerticalDropLines, *actionPlotSpline;
    QAction *actionPlotVertSteps, *actionPlotHorSteps, *actionPlotVerticalBars;
    QAction *actionPlotHorizontalBars, *actionPlotArea, *actionPlotPie, *actionPlotVectXYAM, *actionPlotVectXYXY;
    QAction *actionPlotHistogram, *actionPlotStackedHistograms, *actionPlot2VerticalLayers, *actionPlot2HorizontalLayers, *actionPlot4Layers, *actionPlotStackedLayers;
    QAction *actionPlot3DRibbon, *actionPlot3DBars, *actionPlot3DScatter, *actionPlot3DTrajectory;
    QAction *actionShowColStatistics, *actionShowRowStatistics, *actionShowIntDialog;
    QAction *actionDifferentiate, *actionFitLinear, *actionShowFitPolynomDialog;
    QAction *actionShowExpDecayDialog, *actionShowTwoExpDecayDialog, *actionShowExpDecay3Dialog;
    QAction *actionFitExpGrowth, *actionFitSigmoidal, *actionFitGauss, *actionFitLorentz, *actionShowFitDialog;
    QAction *actionShowAxisDialog, *actionShowTitleDialog;
    QAction *actionAbout, *actionShowHelp;
#ifdef DYNAMIC_MANUAL_PATH
    QAction *actionChooseHelpFolder;
#endif
    QAction *actionRename, *actionCloseWindow, *actionConvertTable;
    QAction *actionAddColToTable, *actionDeleteLayer, *actionInterpolate;
    QAction *actionResizeActiveWindow, *actionHideActiveWindow;
    QAction *actionShowMoreWindows, *actionPixelLineProfile, *actionIntensityTable;
    QAction *actionShowLineDialog, *actionShowImageDialog, *actionShowTextDialog;
    QAction *actionActivateWindow, *actionMinimizeWindow, *actionMaximizeWindow, *actionResizeWindow, *actionPrintWindow;
    QAction *actionShowPlotGeometryDialog, *actionEditSurfacePlot, *actionAdd3DData;
    QAction *actionMatrixDeterminant;
    QAction *actionConvertMatrix, *actionInvertMatrix;
    QAction *actionPlot3DWireFrame, *actionPlot3DHiddenLine, *actionPlot3DPolygons, *actionPlot3DWireSurface;
    QAction *actionColorMap, *actionContourMap, *actionGrayMap;
    QAction *actionDeleteFitTables, *actionShowGridDialog, *actionTimeStamp;
    QAction *actionSmoothSavGol, *actionSmoothFFT, *actionSmoothAverage, *actionFFT;
    QAction *actionLowPassFilter, *actionHighPassFilter, *actionBandPassFilter, *actionBandBlockFilter;
    QAction *actionConvolute, *actionDeconvolute, *actionCorrelate, *actionAutoCorrelate;
    QAction *actionTranslateHor, *actionTranslateVert;
    QAction *actionBoxPlot, *actionMultiPeakGauss, *actionMultiPeakLorentz;
#ifdef SEARCH_FOR_UPDATES
    QAction *actionCheckUpdates;
#endif
    QAction *actionHomePage;
#ifdef DOWNLOAD_LINKS
    QAction *actionDownloadManual;
#endif
    QAction *actionHelpForums, *actionHelpBugReports;
    QAction *actionShowPlotDialog, *actionShowScaleDialog, *actionOpenTemplate, *actionSaveTemplate;
    QAction *actionNextWindow, *actionPrevWindow;
    QAction *actionScriptingLang, *actionRestartScripting, *actionClearTable, *actionGoToCell;
    QAction *actionNoteExecute, *actionNoteExecuteAll, *actionNoteEvaluate, *actionSaveNote;
    QAction *actionAnimate, *actionPerspective, *actionFitFrame, *actionResetRotation;

    QActionGroup* dataTools;
    QAction *btnCursor, *btnSelect, *btnPicker, *btnRemovePoints, *btnMovePoints;
    QAction  *btnZoomIn, *btnZoomOut, *btnPointer, *btnLine, *btnArrow;

    QActionGroup* coord;
    QAction* Box;
    QAction* Frame;
    QAction* None;

    QActionGroup* grids;
    QAction* front;
    QAction* back;
    QAction* right;
    QAction* left;
    QAction* ceil;
    QAction* floor;

    QActionGroup* floorstyle;
    QAction* floordata;
    QAction* flooriso;
    QAction* floornone;

    QActionGroup* plotstyle;
    QAction* wireframe;
    QAction* hiddenline;
    QAction* polygon;
    QAction* filledmesh;
    QAction* pointstyle;
    QAction* barstyle;
    QAction *conestyle, *crossHairStyle;

    QSignalMapper *d_plot_mapper;

    QLabel *d_status_info;

    Project * d_project;

private slots:
    void removeDependentTableStatistics(const AbstractAspect *aspect);

    void setActiveWindowFromAction();

    void selectPlotType(int type);

    void handleAspectAdded(const AbstractAspect * aspect, int index);
    void handleAspectAboutToBeRemoved(const AbstractAspect * aspect, int index);
};

#endif