Merge lp:~valavanisalex/ubuntu/maverick/qtiplot/qtiplot-fix-605025 into lp:ubuntu/maverick/qtiplot

[Alex Valavanis]

[Scott Howard (showard314)]

This is an impressive amount of work! Have you discussed this with upstream yet? Ion is quite responsive and would appreciate the help with this. He's responsive on his forum, check out this post about this bug:
http://developer.berlios.de/forum/message.php?msg_id=51418

The best thing would be to get this implimented upstream and we grab upstream's patch.

[Alex Valavanis (valavanisalex)]

> This is an impressive amount of work! Have you discussed this with upstream
> yet? Ion is quite responsive and would appreciate the help with this. He's
> responsive on his forum, check out this post about this bug:
> http://developer.berlios.de/forum/message.php?msg_id=51418
>
> The best thing would be to get this implimented upstream and we grab
> upstream's patch.

Hi Scott, most of these changes are from upstream already. The diff against Ubuntu just looks large because there was a new upstream release!

[Alex Valavanis (valavanisalex)]

I have uploaded debdiffs to bug #605027 so you can see the (minimal) changes against the Debian package.

[Scott Howard (showard314)]

ok, I thought the diff was huge because you updated to the new qt assistant. That's why I though Ion should know.

[Alex Valavanis (valavanisalex)]

Ah OK,

Unfortunately, I think that moving to the new Qt Assistant needs to be an upstream task because their online documentation will also need to migrate to the new format. i.e. we could make a patch for Ubuntu but it wouldn't be able to read the old documentation!

Unmerged revisions

17. By Alex Valavanis on 2010-07-22

* debian/control: Fix Qt 4.7 compatibility (LP: #598826)
  + Build-Depends: libqtassistantclient-dev
  + Recommends: qt-assistant-compat

16. By Alex Valavanis on 2010-07-21

* Merge with Debian unstable (LP: #605027, LP: #608360)
  + debian/control: Ubuntu maintainers
* debian/patches/01_build_system.diff: Rm explicit python version
  (Closes: #560852)
* debian/control: Build-Depends: libqtassistantclient-dev (LP: #598826)
* New upstream release
* Build QTeXEngine into program
* Bump liborigin2 dependency to >=1:06042009+svn1724
* Bump muparser dependency to 1.32
* New upstream release
* Switch to dpkg-source 3.0 (quilt) format
* Minor fix to patch 01_build_system.diff
* Add qwtplot3d to build.conf
* Bump standards version to 3.8.4
* Fix spelling errors in description
* Add misc depends in qtiplot-doc
* Remove patch 02_docbook_stylesheet and
  04_add_includes.diff
* Rename 03_fix_qti_wordlist.txt_path to
  02_fix_paths.diff

15. By Alex Valavanis on 2010-07-21

Merging shared upstream rev into target branch.

=== added directory '.pc'
=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2010-07-22 00:49:43 +0000
@@ -0,0 +1,1 @@
+2

=== added directory '.pc/01_build_system.diff'
=== added directory '.pc/01_build_system.diff/qtiplot'
=== added file '.pc/01_build_system.diff/qtiplot.pro'
--- .pc/01_build_system.diff/qtiplot.pro	1970-01-01 00:00:00 +0000
+++ .pc/01_build_system.diff/qtiplot.pro	2010-07-22 00:49:43 +0000
@@ -0,0 +1,7 @@
+TEMPLATE = subdirs
+
+SUBDIRS = fitPlugins \
+	    manual \
+	    3rdparty/qwt \
+		3rdparty/qwtplot3d \
+        qtiplot

=== added file '.pc/01_build_system.diff/qtiplot/qtiplot.pro'
--- .pc/01_build_system.diff/qtiplot/qtiplot.pro	1970-01-01 00:00:00 +0000
+++ .pc/01_build_system.diff/qtiplot/qtiplot.pro	2010-07-22 00:49:43 +0000
@@ -0,0 +1,241 @@
+TARGET   = qtiplot
+QTI_ROOT = ..
+!include( $$QTI_ROOT/build.conf ) {
+  message( "You need a build.conf file with local settings!" )
+}
+
+##################### 3rd PARTY HEADER FILES SECTION ########################
+#!!! Warning: You must set this up in $$QTIROOT/build.conf
+#############################################################################
+
+# local copy included
+INCLUDEPATH       += ../3rdparty/zlib
+INCLUDEPATH 	  += ../3rdparty/QTeXEngine/src
+
+# configurable
+INCLUDEPATH       += $$MUPARSER_INCLUDEPATH
+INCLUDEPATH       += $$QWT_INCLUDEPATH
+INCLUDEPATH       += $$QWT3D_INCLUDEPATH
+INCLUDEPATH       += $$GSL_INCLUDEPATH
+
+# configurable libs
+LIBS         += $$MUPARSER_LIBS
+LIBS         += $$QWT_LIBS
+LIBS         += $$QWT3D_LIBS
+LIBS         += $$GSL_LIBS
+
+#############################################################################
+###################### BASIC PROJECT PROPERTIES #############################
+#############################################################################
+
+QMAKE_PROJECT_DEPTH = 0
+	
+!contains(CONFIG, BrowserPlugin){
+	TEMPLATE       = app
+}
+
+CONFIG        += qt warn_on exceptions opengl thread
+CONFIG        += assistant
+
+DEFINES       += QT_PLUGIN
+contains(CONFIG, CustomInstall){
+	INSTALLS        += target
+	INSTALLS        += translations
+	INSTALLS        += manual
+	INSTALLS        += documentation
+	unix:INSTALLS        += man
+
+	unix: INSTALLBASE = /usr
+	win32: INSTALLBASE = C:/QtiPlot
+
+	unix: target.path = $$INSTALLBASE/bin
+	unix: translations.path = $$INSTALLBASE/share/qtiplot/translations
+	unix: manual.path = $$INSTALLBASE/share/doc/qtiplot/manual
+	unix: documentation.path = $$INSTALLBASE/share/doc/qtiplot
+	unix: man.path = $$INSTALLBASE/share/man/man1/
+
+	win32: target.path = $$INSTALLBASE
+	win32: translations.path = $$INSTALLBASE/translations
+	win32: manual.path = $$INSTALLBASE/manual
+	win32: documentation.path = $$INSTALLBASE/doc
+
+	DEFINES       += TRANSLATIONS_PATH="\\\"$$replace(translations.path," ","\ ")\\\"
+	DEFINES       += MANUAL_PATH="\\\"$$replace(manual.path," ","\ ")\\\"
+	}
+
+win32:DEFINES += QT_DLL QT_THREAD_SUPPORT
+QT            += opengl qt3support network svg xml
+
+MOC_DIR        = ../tmp/qtiplot
+OBJECTS_DIR    = ../tmp/qtiplot
+SIP_DIR        = ../tmp/qtiplot
+DESTDIR        = ./
+
+#############################################################################
+###################### PROJECT FILES SECTION ################################
+#############################################################################
+
+###################### ICONS ################################################
+INCLUDEPATH  += icons/
+win32:RC_FILE = icons/qtiplot.rc
+mac:RC_FILE   = icons/qtiplot.icns
+RESOURCES     = ../manual/html/icons/icons.qrc
+
+###################### TRANSLATIONS #########################################
+
+TRANSLATIONS    = translations/qtiplot_cn.ts \
+				  translations/qtiplot_cz.ts \
+				  translations/qtiplot_de.ts \
+				  translations/qtiplot_es.ts \
+				  translations/qtiplot_fr.ts \
+				  #translations/qtiplot_pt.ts \
+				  translations/qtiplot_ro.ts \
+				  translations/qtiplot_ru.ts \
+				  translations/qtiplot_ja.ts \
+				  translations/qtiplot_sv.ts
+
+translations.files += translations/qtiplot_cn.qm \
+					translations/qtiplot_cz.qm \
+					translations/qtiplot_de.qm \
+					translations/qtiplot_es.qm \
+					translations/qtiplot_fr.qm \
+					#translations/qtiplot_pt.qm \
+					translations/qtiplot_ro.qm \
+					translations/qtiplot_ru.qm \
+					translations/qtiplot_ja.qm \
+					translations/qtiplot_sv.qm
+
+isEmpty(LUPDATE): LUPDATE = lupdate
+#system($$LUPDATE -verbose qtiplot.pro)
+isEmpty(LRELEASE): LRELEASE = lrelease
+#system($$LRELEASE -verbose qtiplot.pro)
+
+###################### DOCUMENTATION ########################################
+
+manual.files += ../manual/html \
+                ../manual/qtiplot-manual-en.pdf
+
+documentation.files += ../README.html \
+                       ../gpl_licence.txt
+
+unix: man.files += ../qtiplot.1
+
+###############################################################
+##################### Compression (zlib-1.2.3) ################
+###############################################################
+
+SOURCES += ../3rdparty/zlib/minigzip.c
+
+###############################################################
+################# Default Modules #############################
+###############################################################
+
+include(src/analysis/analysis.pri)
+include(src/core/core.pri)
+include(src/lib/libqti.pri)
+include(src/plot2D/plot2D.pri)
+include(src/plot3D/plot3D.pri)
+include(src/matrix/matrix.pri)
+include(src/table/table.pri)
+include(src/scripting/scripting.pri)
+
+###############################################################
+##################### TeX export: QTeXEngine ##################
+###############################################################
+
+INCLUDEPATH += ../3rdparty/QTeXEngine/src
+HEADERS 	+= ../3rdparty/QTeXEngine/src/QTeXEngine.h
+SOURCES     += ../3rdparty/QTeXEngine/src/QTeXPaintEngine.cpp
+SOURCES     += ../3rdparty/QTeXEngine/src/QTeXPaintDevice.cpp
+
+###############################################################
+##################### Scripting: PYTHON + SIP + PyQT ##########
+###############################################################
+
+contains(SCRIPTING_LANGS, Python) {
+  contains(CONFIG, CustomInstall){
+  	INSTALLS += pythonconfig
+  	pythonconfig.files += qtiplotrc.py \
+  				    qtiUtil.py \
+  				    qti_wordlist.txt \
+
+  	unix: pythonconfig.path = /usr/local/qtiplot
+  	win32: pythonconfig.path = $$INSTALLBASE
+  	DEFINES += PYTHON_CONFIG_PATH="\\\"$$replace(pythonconfig.path," ","\ ")\\\"
+  }
+
+  unix {
+    isEmpty(PYTHON): PYTHON = python
+    INCLUDEPATH += $$system($$PYTHON python-includepath.py)
+    LIBS        += $$system($$PYTHON -c "\"from distutils import sysconfig; print '-lpython'+sysconfig.get_config_var('VERSION')\"")
+    LIBS        += -lm
+    system(mkdir -p $${SIP_DIR})
+    system($$system($$PYTHON python-sipcmd.py) -c $${SIP_DIR} src/scripting/qti.sip)
+  }
+
+  win32 {
+    INCLUDEPATH += $$system(call python-includepath.py)
+    LIBS        += $$system(call python-libs-win.py)
+    system($$system(call python-sipcmd.py) -c $${SIP_DIR} src/scripting/qti.sip)
+  }
+}
+
+###############################################################
+
+# check if we have libpng
+!isEmpty(LIBPNG_LIBS) {
+	DEFINES += GL2PS_HAVE_LIBPNG
+	INCLUDEPATH += $$LIBPNG_INCLUDEPATH
+	LIBS        += $$LIBPNG_LIBS
+}
+
+###############################################################
+
+# check if we have EmfEnginge
+!isEmpty(EMF_ENGINE_LIBS) {
+	DEFINES += EMF_OUTPUT
+	INCLUDEPATH += $$EMF_ENGINE_INCLUDEPATH
+	LIBS        += $$EMF_ENGINE_LIBS
+  win32:LIBS += -lgdiplus
+  unix:LIBS += -lEMF
+}
+
+# check if we have libxls
+!isEmpty(XLS_LIBS) {
+	DEFINES += XLS_IMPORT
+	INCLUDEPATH += $$XLS_INCLUDEPATH
+	LIBS        += $$XLS_LIBS
+}
+
+# check if we have QuaZIP
+!isEmpty(QUAZIP_LIBS) {
+	DEFINES += ODS_IMPORT
+	INCLUDEPATH += $$QUAZIP_INCLUDEPATH
+	LIBS        += $$QUAZIP_LIBS
+}
+
+# check if we have liborigin2
+!isEmpty(BOOST_LIBS) {
+	DEFINES += OPJ_IMPORT
+	INCLUDEPATH += $$BOOST_INCLUDEPATH
+	INCLUDEPATH += ../3rdparty/liborigin
+	LIBS        += $$BOOST_LIBS
+	include(src/origin/origin.pri)
+}
+
+###############################################################
+
+# At the very end: add global include- and lib path
+unix:INCLUDEPATH += $$SYS_INCLUDEPATH
+unix:LIBS += $$SYS_LIBS
+
+###############################################################
+############### Building QtiPlot as a browser plugin ##########
+###############################################################
+
+contains(CONFIG, BrowserPlugin){
+	DEFINES += BROWSER_PLUGIN
+	win32: CONFIG  += qaxserver
+	RC_FILE	= qtiplot.rc
+	include(../3rdparty/QtSolutions/qtbrowserplugin/src/qtbrowserplugin.pri)
+}  

=== added directory '.pc/01_build_system.diff/qtiplot/src'
=== added directory '.pc/01_build_system.diff/qtiplot/src/origin'
=== added file '.pc/01_build_system.diff/qtiplot/src/origin/origin.pri'
--- .pc/01_build_system.diff/qtiplot/src/origin/origin.pri	1970-01-01 00:00:00 +0000
+++ .pc/01_build_system.diff/qtiplot/src/origin/origin.pri	2010-07-22 00:49:43 +0000
@@ -0,0 +1,27 @@
+###############################################################
+################# Origin Import (liborigin) ###################
+###############################################################
+INCLUDEPATH += src/origin/
+
+HEADERS += src/origin/importOPJ.h
+HEADERS += ../3rdparty/liborigin/OriginObj.h
+HEADERS += ../3rdparty/liborigin/OriginFile.h
+HEADERS += ../3rdparty/liborigin/OriginParser.h
+HEADERS += ../3rdparty/liborigin/OriginDefaultParser.h
+HEADERS += ../3rdparty/liborigin/Origin600Parser.h
+HEADERS += ../3rdparty/liborigin/Origin610Parser.h
+HEADERS += ../3rdparty/liborigin/Origin700Parser.h
+HEADERS += ../3rdparty/liborigin/Origin750Parser.h
+HEADERS += ../3rdparty/liborigin/Origin800Parser.h
+HEADERS += ../3rdparty/liborigin/Origin810Parser.h
+
+SOURCES += src/origin/importOPJ.cpp
+SOURCES += ../3rdparty/liborigin/OriginFile.cpp
+SOURCES += ../3rdparty/liborigin/OriginParser.cpp
+SOURCES += ../3rdparty/liborigin/OriginDefaultParser.cpp
+SOURCES += ../3rdparty/liborigin/Origin600Parser.cpp
+SOURCES += ../3rdparty/liborigin/Origin610Parser.cpp
+SOURCES += ../3rdparty/liborigin/Origin700Parser.cpp
+SOURCES += ../3rdparty/liborigin/Origin750Parser.cpp
+SOURCES += ../3rdparty/liborigin/Origin800Parser.cpp
+SOURCES += ../3rdparty/liborigin/Origin810Parser.cpp

=== added directory '.pc/02_fix_paths.diff'
=== added directory '.pc/02_fix_paths.diff/qtiplot'
=== added directory '.pc/02_fix_paths.diff/qtiplot/src'
=== added directory '.pc/02_fix_paths.diff/qtiplot/src/core'
=== added file '.pc/02_fix_paths.diff/qtiplot/src/core/ApplicationWindow.cpp'
--- .pc/02_fix_paths.diff/qtiplot/src/core/ApplicationWindow.cpp	1970-01-01 00:00:00 +0000
+++ .pc/02_fix_paths.diff/qtiplot/src/core/ApplicationWindow.cpp	2010-07-22 00:49:43 +0000
@@ -0,0 +1,18381 @@
+/***************************************************************************
+	File                 : ApplicationWindow.cpp
+	Project              : QtiPlot
+--------------------------------------------------------------------
+	Copyright            : (C) 2004 - 2010 by Ion Vasilief,
+						   (C) 2006 - June 2007 Tilman Hoener zu Siederdissen, Knut Franke
+	Email (use @ for *)  : ion_vasilief*yahoo.fr
+	Description          : QtiPlot's main window
+
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *  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                                           *
+ *                                                                         *
+ ***************************************************************************/
+#include "globals.h"
+#include "ApplicationWindow.h"
+#include <QtiPlotApplication.h>
+
+#include "PlotWizard.h"
+#include "ConfigDialog.h"
+#include "RenameWindowDialog.h"
+#include "ImportASCIIDialog.h"
+#include "Folder.h"
+#include "FindDialog.h"
+#include "OpenProjectDialog.h"
+#include "CustomActionDialog.h"
+#include "MdiSubWindow.h"
+
+#include <SymbolBox.h>
+#include <ColorBox.h>
+#include <PenStyleBox.h>
+#include <PatternBox.h>
+#include <SymbolDialog.h>
+#include <ExportDialog.h>
+#include <SetColValuesDialog.h>
+#include <ExtractDataDialog.h>
+#include <TableDialog.h>
+#include <TableStatistics.h>
+#include <Fit.h>
+#include <MultiPeakFit.h>
+#include <PolynomialFit.h>
+#include <SigmoidalFit.h>
+#include <LogisticFit.h>
+#include <NonLinearFit.h>
+#include <Integration.h>
+#include <Differentiation.h>
+#include <SmoothFilter.h>
+#include <FFTFilter.h>
+#include <Convolution.h>
+#include <Correlation.h>
+#include <ExpDecayDialog.h>
+#include <PolynomFitDialog.h>
+#include <FitDialog.h>
+#include <IntDialog.h>
+#include <InterpolationDialog.h>
+#include <SmoothCurveDialog.h>
+#include <FilterDialog.h>
+#include <FFTDialog.h>
+#include <FrequencyCountDialog.h>
+#include <SubtractDataDialog.h>
+#include <QwtErrorPlotCurve.h>
+#include <LegendWidget.h>
+#include <TexWidget.h>
+#include <ArrowMarker.h>
+#include <ImageWidget.h>
+#include <Grid.h>
+#include <ScaleDraw.h>
+#include <ScaleEngine.h>
+#include <QwtHistogram.h>
+#include <FunctionCurve.h>
+#include <QwtPieCurve.h>
+#include <EllipseWidget.h>
+#include <RectangleWidget.h>
+#include <Spectrogram.h>
+#include <EnrichmentDialog.h>
+#include <TextEditor.h>
+#include <CurvesDialog.h>
+#include <PlotDialog.h>
+#include <AxesDialog.h>
+#include <LineDialog.h>
+#include <ErrDialog.h>
+#include <FunctionDialog.h>
+#include <AssociationsDialog.h>
+#include <ImageExportDialog.h>
+#include <CurveRangeDialog.h>
+#include <LayerDialog.h>
+#include <TextDialog.h>
+// TODO: move tool-specific code to an extension manager
+#include <ScreenPickerTool.h>
+#include <DataPickerTool.h>
+#include <MultiPeakFitTool.h>
+#include <LineProfileTool.h>
+#include <RangeSelectorTool.h>
+#include <PlotToolInterface.h>
+#include <SubtractLineTool.h>
+#include <AddWidgetTool.h>
+#include <SurfaceDialog.h>
+#include <Graph3D.h>
+#include <Plot3DDialog.h>
+#include <ColorMapDialog.h>
+#include <MatrixDialog.h>
+#include <MatrixSizeDialog.h>
+#include <MatrixValuesDialog.h>
+#include <MatrixModel.h>
+#include <MatrixCommand.h>
+#include <Note.h>
+#include <ScriptingLangDialog.h>
+#include <ScriptWindow.h>
+#include <PythonSyntaxHighlighter.h>
+#include <CreateBinMatrixDialog.h>
+#include <QTextDocumentWriter>
+#include <QToolButton>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+using namespace std;
+
+#include <qwt_scale_engine.h>
+#include <qwt_scale_widget.h>
+#include <qwt_plot_magnifier.h>
+#include <qwt_symbol.h>
+
+#include <QFileDialog>
+#include <QInputDialog>
+#include <QProgressDialog>
+#include <QPrintDialog>
+#include <QPrintPreviewDialog>
+#include <QPixmapCache>
+#include <QMenuBar>
+#include <QClipboard>
+#include <QTranslator>
+#include <QSplitter>
+#include <QSettings>
+#include <QApplication>
+#include <QMessageBox>
+#include <QPrinter>
+#include <QActionGroup>
+#include <QAction>
+#include <QToolBar>
+#include <QKeySequence>
+#include <QImageReader>
+#include <QImageWriter>
+#include <QDateTime>
+#include <QShortcut>
+#include <QDockWidget>
+#include <QTextStream>
+#include <QVarLengthArray>
+#include <QList>
+#include <QUrl>
+#include <QAssistantClient>
+#include <QFontComboBox>
+#include <QSpinBox>
+#include <QMdiArea>
+#include <QMdiSubWindow>
+#include <QUndoStack>
+#include <QUndoView>
+#include <QCompleter>
+#include <QStringListModel>
+#include <QNetworkProxy>
+
+#include <zlib.h>
+#include <iostream>
+
+#include <gsl/gsl_statistics.h>
+#include <gsl/gsl_sort.h>
+
+#ifdef XLS_IMPORT
+extern "C" {
+	#include <libxls/xls.h>
+}
+#endif
+
+#ifdef ODS_IMPORT
+	#include <QTemporaryFile>
+	#include <OdsFileHandler.h>
+	#include <quazip.h>
+	#include <quazipfile.h>
+#endif
+
+#ifdef OPJ_IMPORT
+	#include "importOPJ.h"
+#endif
+
+using namespace Qwt3D;
+
+extern "C"
+{
+void file_compress(char  *file, char  *mode);
+void file_uncompress(char  *file);
+}
+
+ApplicationWindow::ApplicationWindow(bool factorySettings)
+: QMainWindow(), scripted(ScriptingLangManager::newEnv(this))
+{
+	setAttribute(Qt::WA_DeleteOnClose);
+	init(factorySettings);
+	((QtiPlotApplication *)QCoreApplication::instance ())->append(this);
+}
+
+void ApplicationWindow::init(bool factorySettings)
+{
+	setWindowTitle(tr("QtiPlot - untitled"));
+	setObjectName(tr("QtiPlot"));
+	initGlobalConstants();
+	QPixmapCache::setCacheLimit(20*QPixmapCache::cacheLimit ());
+
+	tablesDepend = new QMenu(this);
+
+	explorerWindow = new QDockWidget( this );
+	explorerWindow->setWindowTitle(tr("Project Explorer"));
+	explorerWindow->setObjectName("explorerWindow"); // this is needed for QMainWindow::restoreState()
+	explorerWindow->setMinimumHeight(150);
+	addDockWidget( Qt::BottomDockWidgetArea, explorerWindow );
+
+	actionSaveProject = NULL;
+	folders = new FolderListView(this);
+	folders->header()->setClickEnabled( false );
+	folders->addColumn( tr("Folder") );
+	folders->setRootIsDecorated( true );
+	folders->setResizeMode(Q3ListView::LastColumn);
+	folders->header()->hide();
+	folders->setSelectionMode(Q3ListView::Single);
+
+	connect(folders, SIGNAL(currentChanged(Q3ListViewItem *)),
+			this, SLOT(folderItemChanged(Q3ListViewItem *)));
+	connect(folders, SIGNAL(itemRenamed(Q3ListViewItem *, int, const QString &)),
+			this, SLOT(renameFolder(Q3ListViewItem *, int, const QString &)));
+	connect(folders, SIGNAL(contextMenuRequested(Q3ListViewItem *, const QPoint &, int)),
+			this, SLOT(showFolderPopupMenu(Q3ListViewItem *, const QPoint &, int)));
+	connect(folders, SIGNAL(dragItems(QList<Q3ListViewItem *>)),
+			this, SLOT(dragFolderItems(QList<Q3ListViewItem *>)));
+	connect(folders, SIGNAL(dropItems(Q3ListViewItem *)),
+			this, SLOT(dropFolderItems(Q3ListViewItem *)));
+	connect(folders, SIGNAL(renameItem(Q3ListViewItem *)),
+			this, SLOT(startRenameFolder(Q3ListViewItem *)));
+	connect(folders, SIGNAL(addFolderItem()), this, SLOT(addFolder()));
+	connect(folders, SIGNAL(deleteSelection()), this, SLOT(deleteSelectedItems()));
+
+	current_folder = new Folder( 0, tr("UNTITLED"));
+	FolderListItem *fli = new FolderListItem(folders, current_folder);
+	current_folder->setFolderListItem(fli);
+	fli->setOpen( true );
+
+	lv = new FolderListView();
+	lv->addColumn (tr("Name"),-1 );
+	lv->addColumn (tr("Type"),-1 );
+	lv->addColumn (tr("View"),-1 );
+	lv->addColumn (tr("Size"),-1 );
+	lv->addColumn (tr("Created"),-1);
+	lv->addColumn (tr("Label"),-1);
+	lv->setResizeMode(Q3ListView::LastColumn);
+	lv->setMinimumHeight(80);
+	lv->setSelectionMode(Q3ListView::Extended);
+	lv->setDefaultRenameAction (Q3ListView::Accept);
+
+	explorerSplitter = new QSplitter(Qt::Horizontal, explorerWindow);
+	explorerSplitter->addWidget(folders);
+	explorerSplitter->addWidget(lv);
+	explorerWindow->setWidget(explorerSplitter);
+
+	QList<int> splitterSizes;
+	explorerSplitter->setSizes( splitterSizes << 45 << 45);
+	explorerWindow->hide();
+
+	logWindow = new QDockWidget(this);
+	logWindow->setObjectName("logWindow"); // this is needed for QMainWindow::restoreState()
+	logWindow->setWindowTitle(tr("Results Log"));
+	addDockWidget( Qt::TopDockWidgetArea, logWindow );
+
+	results=new QTextEdit(logWindow);
+	results->setReadOnly (true);
+
+	logWindow->setWidget(results);
+	logWindow->hide();
+
+#ifdef SCRIPTING_CONSOLE
+	consoleWindow = new QDockWidget(this);
+	consoleWindow->setObjectName("consoleWindow"); // this is needed for QMainWindow::restoreState()
+	consoleWindow->setWindowTitle(tr("Scripting Console"));
+	addDockWidget( Qt::TopDockWidgetArea, consoleWindow );
+	console = new QTextEdit(consoleWindow);
+	console->setReadOnly(true);
+	consoleWindow->setWidget(console);
+	consoleWindow->hide();
+#endif
+
+	undoStackWindow = new QDockWidget(this);
+	undoStackWindow->setObjectName("undoStackWindow"); // this is needed for QMainWindow::restoreState()
+	undoStackWindow->setWindowTitle(tr("Undo Stack"));
+	addDockWidget(Qt::RightDockWidgetArea, undoStackWindow);
+
+	d_undo_view = new QUndoView(undoStackWindow);
+	d_undo_view->setCleanIcon(QIcon(":/filesave.png"));
+	undoStackWindow->setWidget(d_undo_view);
+	undoStackWindow->hide();
+
+	// Needs to be done after initialization of dock windows,
+	// because we now use QDockWidget::toggleViewAction()
+	createActions();
+	initToolBars();
+	initMainMenu();
+
+	d_workspace = new QMdiArea();
+	d_workspace->setOption(QMdiArea::DontMaximizeSubWindowOnActivation);
+	d_workspace->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+	d_workspace->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+	d_workspace->setActivationOrder(QMdiArea::ActivationHistoryOrder);
+	setCentralWidget(d_workspace);
+
+	setAcceptDrops(true);
+
+	hiddenWindows = new QList<QWidget*>();
+
+	scriptWindow = 0;
+    d_text_editor = NULL;
+
+	renamedTables = QStringList();
+	if (!factorySettings)
+		readSettings();
+	createLanguagesList();
+	insertTranslatedStrings();
+	disableToolbars();
+
+	assistant = new QAssistantClient( QString(), this );
+
+	actionNextWindow = new QAction(QIcon(":/next.png"), tr("&Next","next window"), this);
+	actionNextWindow->setShortcut( tr("F5","next window shortcut") );
+	connect(actionNextWindow, SIGNAL(activated()), d_workspace, SLOT(activateNextSubWindow()));
+
+	actionPrevWindow = new QAction(QIcon(":/prev.png"), tr("&Previous","previous window"), this);
+	actionPrevWindow->setShortcut( tr("F6","previous window shortcut") );
+	connect(actionPrevWindow, SIGNAL(activated()), d_workspace, SLOT(activatePreviousSubWindow()));
+
+	connect(tablesDepend, SIGNAL(activated(int)), this, SLOT(showTable(int)));
+
+	connect(this, SIGNAL(modified()),this, SLOT(modifiedProject()));
+	connect(d_workspace, SIGNAL(subWindowActivated(QMdiSubWindow *)),
+			this, SLOT(windowActivated(QMdiSubWindow*)));
+	connect(lv, SIGNAL(doubleClicked(Q3ListViewItem *)),
+			this, SLOT(maximizeWindow(Q3ListViewItem *)));
+	connect(lv, SIGNAL(doubleClicked(Q3ListViewItem *)),
+			this, SLOT(folderItemDoubleClicked(Q3ListViewItem *)));
+	connect(lv, SIGNAL(contextMenuRequested(Q3ListViewItem *, const QPoint &, int)),
+			this, SLOT(showWindowPopupMenu(Q3ListViewItem *, const QPoint &, int)));
+	connect(lv, SIGNAL(dragItems(QList<Q3ListViewItem *>)),
+			this, SLOT(dragFolderItems(QList<Q3ListViewItem *>)));
+	connect(lv, SIGNAL(dropItems(Q3ListViewItem *)),
+			this, SLOT(dropFolderItems(Q3ListViewItem *)));
+	connect(lv, SIGNAL(renameItem(Q3ListViewItem *)),
+			this, SLOT(startRenameFolder(Q3ListViewItem *)));
+	connect(lv, SIGNAL(addFolderItem()), this, SLOT(addFolder()));
+	connect(lv, SIGNAL(deleteSelection()), this, SLOT(deleteSelectedItems()));
+	connect(lv, SIGNAL(itemRenamed(Q3ListViewItem *, int, const QString &)),
+			this, SLOT(renameWindow(Q3ListViewItem *, int, const QString &)));
+
+	connect(scriptEnv, SIGNAL(error(const QString&,const QString&,int)),
+			this, SLOT(scriptError(const QString&,const QString&,int)));
+	connect(scriptEnv, SIGNAL(print(const QString&)), this, SLOT(scriptPrint(const QString&)));
+
+	connect(recent, SIGNAL(activated(int)), this, SLOT(openRecentProject(int)));
+	connect(explorerWindow, SIGNAL(dockLocationChanged (Qt::DockWidgetArea)), this, SLOT(updateExplorerWindowLayout(Qt::DockWidgetArea)));
+
+	// this has to be done after connecting scriptEnv
+	scriptEnv->initialize();
+
+    //apply user settings
+    updateAppFonts();
+	setScriptingLanguage(defaultScriptingLang);
+    setAppColors(workspaceColor, panelsColor, panelsTextColor, true);
+
+    loadCustomActions();
+    initCompleter();
+}
+
+void ApplicationWindow::updateExplorerWindowLayout(Qt::DockWidgetArea area)
+{
+	switch(area){
+		case Qt::LeftDockWidgetArea:
+		case Qt::RightDockWidgetArea:
+			explorerSplitter->setOrientation(Qt::Vertical);
+		break;
+
+		case Qt::TopDockWidgetArea:
+		case Qt::BottomDockWidgetArea:
+		case Qt::NoDockWidgetArea:
+			explorerSplitter->setOrientation(Qt::Horizontal);
+		break;
+
+		default:
+			break;
+	}
+}
+
+void ApplicationWindow::initWindow()
+{
+	switch(d_init_window_type){
+		case TableWindow:
+			newTable();
+		break;
+		case MatrixWindow:
+			newMatrix();
+		break;
+		case MultiLayerWindow:
+			newGraph();
+		break;
+		case NoteWindow:
+			newNote();
+		break;
+		default:
+			break;
+	}
+	savedProject();
+}
+
+void ApplicationWindow::initGlobalConstants()
+{
+	d_indexed_colors = ColorBox::defaultColors();
+	d_indexed_color_names = ColorBox::defaultColorNames();
+
+	d_symbols_list = SymbolBox::defaultSymbols();
+
+	d_latex_compiler = MathTran;
+	d_latex_compiler_path = QString::null;
+	d_mdi_windows_area = true;
+	d_open_project_filter = QString::null;//tr("QtiPlot project") + " (*.qti)";
+
+	d_comment_highlight_color = Qt::red;
+	d_class_highlight_color = Qt::darkMagenta;
+	d_numeric_highlight_color = Qt::darkGreen;
+	d_keyword_highlight_color = Qt::darkBlue;
+	d_function_highlight_color = Qt::blue;
+	d_quotation_highlight_color = Qt::darkYellow;
+
+    d_notes_tab_length = 20;
+    d_completer = NULL;
+    d_completion = true;
+    d_note_line_numbers = true;
+
+	d_auto_update_table_values = true;
+	d_active_window = NULL;
+    d_matrix_undo_stack_size = 10;
+
+	d_opening_file = false;
+	d_is_appending_file = false;
+    d_in_place_editing = true;
+
+	d_matrix_tool_bar = true;
+	d_file_tool_bar = true;
+	d_table_tool_bar = true;
+	d_column_tool_bar = true;
+	d_edit_tool_bar = true;
+	d_notes_tool_bar = true;
+	d_plot_tool_bar = true;
+	d_plot3D_tool_bar = true;
+	d_display_tool_bar = false;
+	d_format_tool_bar = true;
+
+	appStyle = qApp->style()->objectName();
+	d_app_rect = QRect();
+	projectname = "untitled";
+	lastCopiedLayer = 0;
+	d_enrichement_copy = NULL;
+	d_arrow_copy = NULL;
+
+	savingTimerId = 0;
+
+	autoSearchUpdatesRequest = false;
+
+	show_windows_policy = ActiveFolder;
+	d_script_win_on_top = false;
+	d_script_win_rect = QRect(0, 0, 500, 300);
+	d_init_window_type = TableWindow;
+
+	QString aux = qApp->applicationDirPath();
+	workingDir = aux;
+
+#ifdef TRANSLATIONS_PATH
+	d_translations_folder = TRANSLATIONS_PATH;
+#else
+	d_translations_folder = aux + "/translations";
+#endif
+
+#ifdef MANUAL_PATH
+	helpFilePath = MANUAL_PATH;
+	helpFilePath += "/index.html";
+#else
+	helpFilePath = aux + "/manual/index.html";
+#endif
+
+#ifdef PYTHON_CONFIG_PATH
+	d_python_config_folder = PYTHON_CONFIG_PATH;
+#else
+	d_python_config_folder = aux;
+#endif
+
+	fitPluginsPath = aux + "fitPlugins";
+	fitModelsPath = QString::null;
+	templatesDir = aux;
+	asciiDirPath = aux;
+	imagesDirPath = aux;
+	scriptsDirPath = aux;
+	customActionsDirPath = QString::null;
+
+	appFont = QFont();
+    d_notes_font = appFont;
+
+	QString family = appFont.family();
+	int pointSize = appFont.pointSize();
+	tableTextFont = appFont;
+	tableHeaderFont = appFont;
+	plotAxesFont = QFont(family, pointSize, QFont::Bold, false);
+	plotNumbersFont = QFont(family, pointSize );
+	plotLegendFont = appFont;
+	plotTitleFont = QFont(family, pointSize + 2, QFont::Bold,false);
+
+	autoSearchUpdates = false;
+	appLanguage = QLocale::system().name().section('_',0,0);
+	show_windows_policy = ApplicationWindow::ActiveFolder;
+
+	workspaceColor = QColor("darkGray");
+	panelsColor = QColor("#ffffff");
+	panelsTextColor = QColor("#000000");
+	tableBkgdColor = QColor("#ffffff");
+	tableTextColor = QColor("#000000");
+	tableHeaderColor = QColor("#000000");
+
+	d_graph_background_color = Qt::white;
+	d_graph_canvas_color = Qt::white;
+	d_graph_border_color = Qt::black;
+	d_graph_background_opacity = 255;
+	d_graph_canvas_opacity = 255;
+	d_graph_border_width = 0;
+	d_graph_tick_labels_dist = 4;
+	d_graph_axes_labels_dist = 2;
+
+	autoSave = true;
+	autoSaveTime = 15;
+	d_backup_files = true;
+
+	defaultScriptingLang = "muParser";
+/*#ifdef SCRIPTING_PYTHON
+	defaultScriptingLang = "Python";
+#endif*/
+
+	d_decimal_digits = 13;
+	d_muparser_c_locale = true;
+
+	d_extended_open_dialog = true;
+	d_extended_export_dialog = true;
+	d_extended_import_ASCII_dialog = true;
+	d_extended_plot_dialog = true;
+
+	d_add_curves_dialog_size = QSize(700, 400);
+	d_show_current_folder = false;
+
+	d_confirm_overwrite = true;
+	confirmCloseFolder = true;
+	confirmCloseTable = true;
+	confirmCloseMatrix = true;
+	confirmClosePlot2D = true;
+	confirmClosePlot3D = true;
+	confirmCloseNotes = true;
+	d_inform_rename_table = true;
+
+	d_show_table_comments = false;
+
+	titleOn = true;
+	d_show_axes = QVector<bool> (QwtPlot::axisCnt, true);
+	d_show_axes_labels = QVector<bool> (QwtPlot::axisCnt, true);
+	canvasFrameWidth = 0;
+	d_canvas_frame_color = Qt::black;
+	defaultPlotMargin = 0;
+	drawBackbones = true;
+	axesLineWidth = 1;
+	autoscale2DPlots = true;
+	autoScaleFonts = true;
+	autoResizeLayers = true;
+	antialiasing2DPlots = false;
+	d_scale_plots_on_print = false;
+	d_print_cropmarks = false;
+	d_graph_legend_display = Graph::ColumnName;
+	d_graph_axis_labeling = Graph::Default;
+	d_synchronize_graph_scales = true;
+	d_print_paper_size = QPrinter::A4;
+	d_printer_orientation = QPrinter::Landscape;
+	defaultCurveStyle = int(Graph::LineSymbols);
+	defaultCurveLineWidth = 1;
+	d_curve_line_style = 0;//Qt::SolidLine;
+	defaultCurveBrush = 0;
+	defaultCurveAlpha = 255;
+	defaultSymbolSize = 7;
+	defaultSymbolEdge = 1.0;
+	d_fill_symbols = true;
+	d_symbol_style = 0;
+	d_indexed_symbols = true;
+	d_keep_aspect_ration = true;
+
+	majTicksStyle = int(ScaleDraw::Out);
+	minTicksStyle = int(ScaleDraw::Out);
+	minTicksLength = 5;
+	majTicksLength = 9;
+
+	legendFrameStyle = int(LegendWidget::Line);
+	d_frame_widget_pen = QPen(Qt::black, 1, Qt::SolidLine);
+	legendTextColor = Qt::black;
+	legendBackground = Qt::white;
+	legendBackground.setAlpha(0); // transparent by default;
+	d_legend_default_angle = 0;
+	d_frame_geometry_unit = (int)FrameWidget::Scale;
+	d_layer_geometry_unit = (int)FrameWidget::Pixel;
+	d_layer_canvas_width = 400;
+	d_layer_canvas_height = 300;
+
+	d_rect_default_background = Qt::white;
+	d_rect_default_brush = QBrush(Qt::white);
+
+	defaultArrowLineWidth = 1;
+	defaultArrowColor = Qt::black;
+	defaultArrowHeadLength = 4;
+	defaultArrowHeadAngle = 45;
+	defaultArrowHeadFill = true;
+	defaultArrowLineStyle = Graph::getPenStyle("SolidLine");
+
+	d_3D_legend = true;
+	d_3D_projection = NOFLOOR;
+	d_3D_smooth_mesh = true;
+	d_3D_resolution = 1;
+	d_3D_orthogonal = false;
+	d_3D_autoscale = true;
+	d_3D_axes_font = QFont(family, pointSize, QFont::Normal, false);
+	d_3D_numbers_font = QFont(family, pointSize);
+	d_3D_title_font = QFont(family, pointSize + 2, QFont::Normal, false);
+    d_3D_color_map = QwtLinearColorMap(Qt::blue, Qt::red);
+	d_3D_mesh_color = Qt::black;
+	d_3D_axes_color = Qt::black;
+	d_3D_numbers_color = Qt::black;
+	d_3D_labels_color = Qt::black;
+	d_3D_background_color = Qt::white;
+	d_3D_grid_color = Qt::blue;
+	d_3D_minor_grid_color = Qt::lightGray;
+	d_3D_minor_grids = true;
+	d_3D_major_grids = true;
+	d_3D_major_style = Qwt3D::SOLID;
+	d_3D_minor_style = Qwt3D::DASH;
+	d_3D_major_width = 1.0;
+	d_3D_minor_width = 0.8;
+
+	fit_output_precision = 13;
+	pasteFitResultsToPlot = false;
+	writeFitResultsToLog = true;
+	generateUniformFitPoints = true;
+	fitPoints = 100;
+	generatePeakCurves = true;
+	peakCurvesColor = Qt::green;
+	fit_scale_errors = true;
+	d_2_linear_fit_points = true;
+	d_multi_peak_messages = true;
+
+	columnSeparator = "\t";
+	ignoredLines = 0;
+	renameColumns = true;
+	strip_spaces = false;
+	simplify_spaces = false;
+	d_ASCII_file_filter = "*";
+	d_ASCII_import_locale = QLocale::system().name();
+	d_ASCII_import_mode = int(ImportASCIIDialog::NewTables);
+	d_ASCII_import_first_row_role = 0;//column names
+	d_ASCII_comment_string = "#";
+	d_ASCII_import_comments = false;
+	d_ASCII_import_read_only = false;
+	d_ASCII_import_preview = true;
+	d_preview_lines = 100;
+	d_import_ASCII_dialog_size = QSize();
+    d_ASCII_end_line = LF;
+	d_eol = LF;
+#ifdef Q_OS_MAC
+    d_ASCII_end_line = CR;
+	d_eol = CR;
+#endif
+
+	d_export_col_separator = "\t";
+	d_export_col_names = false;
+    d_export_col_comment = false;
+	d_export_table_selection = false;
+	d_export_ASCII_file_filter = ".dat";
+
+	d_scale_fonts_factor = 0.0;
+	d_image_export_filter = ".png";
+	d_export_transparency = false;
+	d_export_quality = 100;
+	d_export_raster_size = QSizeF();
+	d_export_size_unit = FrameWidget::Pixel;
+	d_export_vector_resolution = QWidget().logicalDpiX();
+	d_export_bitmap_resolution = d_export_vector_resolution;
+	d_export_color = true;
+	d_export_escape_tex_strings = true;
+	d_export_tex_font_sizes = true;
+	d_3D_export_text_mode = 0; //VectorWriter::PIXEL
+	d_3D_export_sort = 1; //VectorWriter::SIMPLESORT
+}
+
+void ApplicationWindow::initToolBars()
+{
+	initPlot3DToolBar();
+
+	setWindowIcon(QIcon(":/logo.png"));
+	QPixmap openIcon, saveIcon;
+
+	fileTools = new QToolBar(tr( "File" ), this);
+	fileTools->setObjectName("fileTools"); // this is needed for QMainWindow::restoreState()
+	fileTools->setIconSize( QSize(18,20) );
+	addToolBar( Qt::TopToolBarArea, fileTools );
+
+	fileTools->addAction(actionNewProject);
+	fileTools->addAction(actionNewFolder);
+	fileTools->addAction(actionNewTable);
+	fileTools->addAction(actionNewMatrix);
+	fileTools->addAction(actionNewNote);
+	fileTools->addAction(actionNewGraph);
+	fileTools->addAction(actionNewFunctionPlot);
+	fileTools->addAction(actionNewSurfacePlot);
+	fileTools->addSeparator ();
+	fileTools->addAction(actionOpen);
+	fileTools->addAction(actionOpenTemplate);
+#ifdef XLS_IMPORT
+	fileTools->addAction(actionOpenExcel);
+#endif
+#ifdef ODS_IMPORT
+	fileTools->addAction(actionOpenOds);
+#endif
+	fileTools->addAction(actionAppendProject);
+	fileTools->addAction(actionSaveProject);
+	fileTools->addAction(actionSaveTemplate);
+	fileTools->addSeparator ();
+	fileTools->addAction(actionLoad);
+	fileTools->addSeparator ();
+	fileTools->addAction(actionCopyWindow);
+	fileTools->addAction(actionPrint);
+	fileTools->addAction(actionPrintPreview);
+	fileTools->addAction(actionExportPDF);
+	fileTools->addSeparator();
+	fileTools->addAction(actionShowExplorer);
+	fileTools->addAction(actionShowLog);
+#ifdef SCRIPTING_PYTHON
+	fileTools->addAction(actionShowScriptWindow);
+#endif
+
+	editTools = new QToolBar(tr("Edit"), this);
+	editTools->setObjectName("editTools"); // this is needed for QMainWindow::restoreState()
+	editTools->setIconSize( QSize(18,20) );
+	addToolBar( editTools );
+
+	editTools->addAction(actionUndo);
+	editTools->addAction(actionRedo);
+	editTools->addAction(actionCutSelection);
+	editTools->addAction(actionCopySelection);
+	editTools->addAction(actionPasteSelection);
+	editTools->addAction(actionClearSelection);
+
+	noteTools = new QToolBar(tr("Notes"), this);
+	noteTools->setObjectName("noteTools"); // this is needed for QMainWindow::restoreState()
+	noteTools->setIconSize( QSize(18,20) );
+#ifdef SCRIPTING_PYTHON
+	noteTools->addAction(actionNoteExecuteAll);
+	noteTools->addAction(actionNoteExecute);
+	noteTools->addAction(actionCommentSelection);
+	noteTools->addAction(actionUncommentSelection);
+#endif
+	noteTools->addAction(actionDecreaseIndent);
+	noteTools->addAction(actionIncreaseIndent);
+	noteTools->addAction(actionFind);
+	noteTools->addAction(actionFindPrev);
+	noteTools->addAction(actionFindNext);
+	noteTools->addAction(actionReplace);
+	addToolBar( noteTools );
+
+	plotTools = new QToolBar(tr("Plot"), this);
+	plotTools->setObjectName("plotTools"); // this is needed for QMainWindow::restoreState()
+	plotTools->setIconSize( QSize(16,20) );
+	addToolBar( plotTools );
+
+	plotTools->addAction(actionAddLayer);
+	plotTools->addAction(actionAddInsetLayer);
+	plotTools->addAction(actionAddInsetCurveLayer);
+	plotTools->addSeparator();
+	plotTools->addAction(actionShowLayerDialog);
+	plotTools->addAction(actionAutomaticLayout);
+	plotTools->addSeparator();
+	plotTools->addAction(actionExtractLayers);
+	plotTools->addAction(actionExtractGraphs);
+	plotTools->addSeparator();
+	plotTools->addAction(actionAddErrorBars);
+	plotTools->addAction(actionShowCurvesDialog);
+	plotTools->addAction(actionAddFunctionCurve);
+	plotTools->addAction(actionNewLegend);
+	plotTools->addSeparator ();
+	plotTools->addAction(actionUnzoom);
+
+	dataTools = new QActionGroup( this );
+	dataTools->setExclusive( true );
+
+	btnPointer = new QAction(tr("Disable &Tools"), this);
+	btnPointer->setActionGroup(dataTools);
+	btnPointer->setCheckable( true );
+	btnPointer->setIcon(QIcon(":/pointer.png"));
+	btnPointer->setChecked(true);
+	plotTools->addAction(btnPointer);
+
+	actionMagnify->setActionGroup(dataTools);
+	actionMagnify->setCheckable( true );
+
+	actionMagnifyHor->setActionGroup(dataTools);
+	actionMagnifyHor->setCheckable( true );
+
+	actionMagnifyVert->setActionGroup(dataTools);
+	actionMagnifyVert->setCheckable( true );
+
+	btnZoomIn = new QAction(tr("&Zoom In"), this);
+	btnZoomIn->setShortcut( tr("Ctrl++") );
+	btnZoomIn->setActionGroup(dataTools);
+	btnZoomIn->setCheckable( true );
+	btnZoomIn->setIcon(QIcon(":/zoom.png"));
+
+	btnZoomOut = new QAction(tr("&Zoom Out"), this);
+	btnZoomOut->setShortcut( tr("Ctrl+-") );
+	btnZoomOut->setActionGroup(dataTools);
+	btnZoomOut->setCheckable( true );
+	btnZoomOut->setIcon(QIcon(":/zoomOut.png"));
+
+	QMenu *menu_zoom = new QMenu(this);
+	menu_zoom->addAction(actionMagnify);
+	menu_zoom->addAction(actionMagnifyHor);
+	menu_zoom->addAction(actionMagnifyVert);
+	menu_zoom->addAction(btnZoomIn);
+	menu_zoom->addAction(btnZoomOut);
+
+	QToolButton *btn_zoom = new QToolButton(this);
+	btn_zoom->setMenu(menu_zoom);
+	btn_zoom->setPopupMode(QToolButton::MenuButtonPopup);
+	btn_zoom->setDefaultAction(actionMagnify);
+	connect(menu_zoom, SIGNAL(triggered(QAction *)), btn_zoom, SLOT(setDefaultAction(QAction *)));
+
+	plotTools->addWidget(btn_zoom);
+
+	btnCursor = new QAction(tr("&Data Reader"), this);
+	btnCursor->setShortcut( tr("CTRL+D") );
+	btnCursor->setActionGroup(dataTools);
+	btnCursor->setCheckable( true );
+	btnCursor->setIcon(QIcon(":/select.png"));
+	plotTools->addAction(btnCursor);
+
+	btnSelect = new QAction(tr("&Select Data Range"), this);
+	btnSelect->setShortcut( tr("ALT+S") );
+	btnSelect->setActionGroup(dataTools);
+	btnSelect->setCheckable( true );
+	btnSelect->setIcon(QIcon(":/cursors.png"));
+	plotTools->addAction(btnSelect);
+
+	btnPicker = new QAction(tr("S&creen Reader"), this);
+	btnPicker->setActionGroup(dataTools);
+	btnPicker->setCheckable( true );
+	btnPicker->setIcon(QIcon(":/cursor_16.png"));
+	plotTools->addAction(btnPicker);
+
+	actionDrawPoints = new QAction(tr("&Draw Data Points"), this);
+	actionDrawPoints->setActionGroup(dataTools);
+	actionDrawPoints->setCheckable( true );
+	actionDrawPoints->setIcon(QIcon(":/draw_points.png"));
+	plotTools->addAction(actionDrawPoints);
+
+	btnMovePoints = new QAction(tr("&Move Data Points..."), this);
+	btnMovePoints->setShortcut( tr("Ctrl+ALT+M") );
+	btnMovePoints->setActionGroup(dataTools);
+	btnMovePoints->setCheckable( true );
+	btnMovePoints->setIcon(QIcon(":/hand.png"));
+	plotTools->addAction(btnMovePoints);
+
+	btnRemovePoints = new QAction(tr("Remove &Bad Data Points..."), this);
+	btnRemovePoints->setShortcut( tr("Alt+B") );
+	btnRemovePoints->setActionGroup(dataTools);
+	btnRemovePoints->setCheckable( true );
+	btnRemovePoints->setIcon(QIcon(":/delete.png"));
+	plotTools->addAction(btnRemovePoints);
+
+	actionDragCurve = new QAction(tr("Dra&g Curve"), this);
+	actionDragCurve->setActionGroup(dataTools);
+	actionDragCurve->setCheckable( true );
+	actionDragCurve->setIcon(QIcon(":/drag_curve.png"));
+	plotTools->addAction(actionDragCurve);
+
+	connect( dataTools, SIGNAL( triggered( QAction* ) ), this, SLOT( pickDataTool( QAction* ) ) );
+	plotTools->addSeparator ();
+
+	actionAddFormula = new QAction(tr("Add E&quation"), this);
+	actionAddFormula->setShortcut( tr("ALT+Q") );
+	actionAddFormula->setCheckable(true);
+	actionAddFormula->setIcon(QIcon(":/equation.png"));
+	connect(actionAddFormula, SIGNAL(triggered()), this, SLOT(addTexFormula()));
+	plotTools->addAction(actionAddFormula);
+
+	actionAddText = new QAction(tr("Add &Text"), this);
+	actionAddText->setShortcut( tr("ALT+T") );
+	actionAddText->setIcon(QIcon(":/text.png"));
+	actionAddText->setCheckable(true);
+	connect(actionAddText, SIGNAL(triggered()), this, SLOT(addText()));
+	plotTools->addAction(actionAddText);
+
+	btnArrow = new QAction(tr("Draw &Arrow"), this);
+	btnArrow->setShortcut( tr("CTRL+ALT+A") );
+	btnArrow->setActionGroup(dataTools);
+	btnArrow->setCheckable( true );
+	btnArrow->setIcon(QIcon(":/arrow.png"));
+	plotTools->addAction(btnArrow);
+
+	btnLine = new QAction(tr("Draw &Line"), this);
+	btnLine->setShortcut( tr("CTRL+ALT+L") );
+	btnLine->setActionGroup(dataTools);
+	btnLine->setCheckable( true );
+	btnLine->setIcon(QIcon(":/lPlot.png"));
+	plotTools->addAction(btnLine);
+
+	QPixmap pix = QPixmap(16, 16);
+	pix.fill(Qt::transparent);
+	QPainter p;
+	p.begin(&pix);
+	p.setBrush(Qt::lightGray);
+	p.drawRect(QRect(1, 2, 12, 10));
+
+    actionAddRectangle = new QAction(tr("Add &Rectangle"), this);
+	actionAddRectangle->setShortcut( tr("CTRL+ALT+R") );
+	actionAddRectangle->setCheckable(true);
+	actionAddRectangle->setIcon(QIcon(pix));
+	connect(actionAddRectangle, SIGNAL(triggered()), this, SLOT(addRectangle()));
+	plotTools->addAction(actionAddRectangle);
+
+	pix.fill(Qt::transparent);
+	p.drawEllipse(QRect(0, 2, 15, 12));
+	p.end();
+
+	actionAddEllipse = new QAction(tr("Add &Ellipse"), this);
+	actionAddEllipse->setShortcut( tr("CTRL+ALT+E") );
+	actionAddEllipse->setCheckable(true);
+	actionAddEllipse->setIcon(QIcon(pix));
+	connect(actionAddEllipse, SIGNAL(triggered()), this, SLOT(addEllipse()));
+	plotTools->addAction(actionAddEllipse);
+
+	plotTools->addAction(actionTimeStamp);
+	plotTools->addAction(actionAddImage);
+	plotTools->hide();
+
+	tableTools = new QToolBar(tr("Table"), this);
+	tableTools->setObjectName("tableTools"); // this is needed for QMainWindow::restoreState()
+	tableTools->setIconSize( QSize(16, 20));
+	addToolBar(Qt::TopToolBarArea, tableTools);
+
+	QMenu *menuPlotLine = new QMenu(this);
+	menuPlotLine->addAction(actionPlotL);
+	menuPlotLine->addAction(actionPlotHorSteps);
+	menuPlotLine->addAction(actionPlotVertSteps);
+
+	QToolButton *btnPlotLine = new QToolButton(this);
+	btnPlotLine->setMenu(menuPlotLine);
+	btnPlotLine->setPopupMode(QToolButton::MenuButtonPopup);
+	btnPlotLine->setDefaultAction(actionPlotL);
+	connect(menuPlotLine, SIGNAL(triggered(QAction *)), btnPlotLine, SLOT(setDefaultAction(QAction *)));
+	tableTools->addWidget(btnPlotLine);
+
+	QMenu *menuPlotScatter = new QMenu(this);
+	menuPlotScatter->addAction(actionPlotP);
+	menuPlotScatter->addAction(actionPlotVerticalDropLines);
+
+	QToolButton *btnPlotScatter = new QToolButton(this);
+	btnPlotScatter->setMenu(menuPlotScatter);
+	btnPlotScatter->setPopupMode(QToolButton::MenuButtonPopup);
+	btnPlotScatter->setDefaultAction(actionPlotP);
+	connect(menuPlotScatter, SIGNAL(triggered(QAction *)), btnPlotScatter, SLOT(setDefaultAction(QAction *)));
+	tableTools->addWidget(btnPlotScatter);
+
+	QMenu *menuPlotLineSymbol = new QMenu(this);
+	menuPlotLineSymbol->addAction(actionPlotLP);
+	menuPlotLineSymbol->addAction(actionPlotSpline);
+
+	QToolButton *btnPlotLineSymbol = new QToolButton(this);
+	btnPlotLineSymbol->setMenu(menuPlotLineSymbol);
+	btnPlotLineSymbol->setPopupMode(QToolButton::MenuButtonPopup);
+	btnPlotLineSymbol->setDefaultAction(actionPlotLP);
+	connect(menuPlotLineSymbol, SIGNAL(triggered(QAction *)), btnPlotLineSymbol, SLOT(setDefaultAction(QAction *)));
+	tableTools->addWidget(btnPlotLineSymbol);
+
+	QMenu *menuPlotBars = new QMenu(this);
+	menuPlotBars->addAction(actionPlotVerticalBars);
+	menuPlotBars->addAction(actionPlotHorizontalBars);
+	menuPlotBars->addAction(actionStackColumns);
+	menuPlotBars->addAction(actionStackBars);
+
+	QToolButton *btnPlotBars = new QToolButton(this);
+	btnPlotBars->setMenu(menuPlotBars);
+	btnPlotBars->setPopupMode(QToolButton::MenuButtonPopup);
+	btnPlotBars->setDefaultAction(actionPlotVerticalBars);
+	connect(menuPlotBars, SIGNAL(triggered(QAction *)), btnPlotBars, SLOT(setDefaultAction(QAction *)));
+	tableTools->addWidget(btnPlotBars);
+
+	tableTools->addAction(actionPlotArea);
+	tableTools->addAction(actionPlotPie);
+
+	QMenu *menuStatisticPlots = new QMenu(this);
+	menuStatisticPlots->addAction(actionBoxPlot);
+	menuStatisticPlots->addAction(actionPlotHistogram);
+	menuStatisticPlots->addAction(actionPlotStackedHistograms);
+	menuStatisticPlots->addAction(actionStemPlot);
+
+	QToolButton *btnStatisticPlots = new QToolButton(this);
+	btnStatisticPlots->setMenu(menuStatisticPlots);
+	btnStatisticPlots->setPopupMode(QToolButton::MenuButtonPopup);
+	btnStatisticPlots->setDefaultAction(actionBoxPlot);
+	connect(menuStatisticPlots, SIGNAL(triggered(QAction *)), btnStatisticPlots, SLOT(setDefaultAction(QAction *)));
+	tableTools->addWidget(btnStatisticPlots);
+
+	QMenu *menuVectorPlots = new QMenu(this);
+	menuVectorPlots->addAction(actionPlotVectXYXY);
+	menuVectorPlots->addAction(actionPlotVectXYAM);
+
+	QToolButton *btnVectorPlots = new QToolButton(this);
+	btnVectorPlots->setMenu(menuVectorPlots);
+	btnVectorPlots->setPopupMode(QToolButton::MenuButtonPopup);
+	btnVectorPlots->setDefaultAction(actionPlotVectXYXY);
+	connect(menuVectorPlots, SIGNAL(triggered(QAction *)), btnVectorPlots, SLOT(setDefaultAction(QAction *)));
+	tableTools->addWidget(btnVectorPlots);
+
+	QMenu *menuPlotSpecial = new QMenu(this);
+	menuPlotSpecial->addAction(actionPlotDoubleYAxis);
+	menuPlotSpecial->addAction(actionWaterfallPlot);
+	menuPlotSpecial->addAction(actionAddZoomPlot);
+	menuPlotSpecial->addAction(actionPlot2VerticalLayers);
+	menuPlotSpecial->addAction(actionPlot2HorizontalLayers);
+	menuPlotSpecial->addAction(actionPlot4Layers);
+	menuPlotSpecial->addAction(actionPlotStackedLayers);
+	menuPlotSpecial->addAction(actionCustomSharedAxisLayers);
+
+	QToolButton *btnPlotSpecial = new QToolButton(this);
+	btnPlotSpecial->setMenu(menuPlotSpecial);
+	btnPlotSpecial->setPopupMode(QToolButton::MenuButtonPopup);
+	btnPlotSpecial->setDefaultAction(actionPlotDoubleYAxis);
+	connect(menuPlotSpecial, SIGNAL(triggered(QAction *)), btnPlotSpecial, SLOT(setDefaultAction(QAction *)));
+	tableTools->addWidget(btnPlotSpecial);
+
+	tableTools->addSeparator ();
+
+	QMenu *menu3DPlots = new QMenu(this);
+	menu3DPlots->addAction(actionPlot3DBars);
+	menu3DPlots->addAction(actionPlot3DRibbon);
+	menu3DPlots->addAction(actionPlot3DScatter);
+	menu3DPlots->addAction(actionPlot3DTrajectory);
+
+	QToolButton *btn3DPlots = new QToolButton(this);
+	btn3DPlots->setMenu(menu3DPlots);
+	btn3DPlots->setPopupMode(QToolButton::MenuButtonPopup);
+	btn3DPlots->setDefaultAction(actionPlot3DBars);
+	connect(menu3DPlots, SIGNAL(triggered(QAction *)), btn3DPlots, SLOT(setDefaultAction(QAction *)));
+	tableTools->addWidget(btn3DPlots);
+
+	tableTools->setEnabled(false);
+    tableTools->hide();
+
+	columnTools = new QToolBar(tr( "Column"), this);
+	columnTools->setObjectName("columnTools"); // this is needed for QMainWindow::restoreState()
+	columnTools->setIconSize(QSize(16, 20));
+	addToolBar(Qt::TopToolBarArea, columnTools);
+
+	columnTools->addAction(actionShowColumnValuesDialog);
+	columnTools->addAction(actionSetAscValues);
+	columnTools->addAction(actionSetRandomValues);
+	columnTools->addSeparator();
+	columnTools->addAction(actionSortTable);
+	columnTools->addAction(actionShowColStatistics);
+	columnTools->addAction(actionShowRowStatistics);
+	columnTools->addSeparator();
+	columnTools->addAction(actionSetXCol);
+	columnTools->addAction(actionSetYCol);
+	columnTools->addAction(actionSetZCol);
+	columnTools->addAction(actionSetYErrCol);
+	columnTools->addAction(actionSetLabelCol);
+	columnTools->addAction(actionDisregardCol);
+	columnTools->addSeparator();
+	columnTools->addAction(actionMoveColFirst);
+	columnTools->addAction(actionMoveColLeft);
+	columnTools->addAction(actionMoveColRight);
+	columnTools->addAction(actionMoveColLast);
+	columnTools->addAction(actionSwapColumns);
+	columnTools->addSeparator();
+	columnTools->addAction(actionAdjustColumnWidth);
+	columnTools->addAction(actionMoveRowUp);
+	columnTools->addAction(actionMoveRowDown);
+	columnTools->addSeparator();
+	columnTools->addAction(actionAddColToTable);
+    columnTools->setEnabled(false);
+	columnTools->hide();
+
+	displayBar = new QToolBar( tr( "Data Display" ), this );
+    displayBar->setAllowedAreas( Qt::TopToolBarArea | Qt::BottomToolBarArea );
+	displayBar->setObjectName("displayBar"); // this is needed for QMainWindow::restoreState()
+	info = new QLineEdit( this );
+	displayBar->addWidget( info );
+	info->setReadOnly(true);
+    QPalette palette;
+    palette.setColor(QPalette::Text, QColor(Qt::green));
+	palette.setColor(QPalette::HighlightedText, QColor(Qt::darkGreen));
+	palette.setColor(QPalette::Base, QColor(Qt::black));
+	info->setPalette(palette);
+
+	addToolBar( Qt::TopToolBarArea, displayBar );
+	displayBar->hide();
+
+    insertToolBarBreak (displayBar);
+
+	plotMatrixBar = new QToolBar( tr( "Matrix Plot" ), this);
+	plotMatrixBar->setObjectName("plotMatrixBar");
+	addToolBar(Qt::BottomToolBarArea, plotMatrixBar);
+
+	QMenu *menu3DMatrix = new QMenu(this);
+	menu3DMatrix->addAction(actionPlot3DWireFrame);
+	menu3DMatrix->addAction(actionPlot3DHiddenLine);
+	menu3DMatrix->addAction(actionPlot3DWireSurface);
+	menu3DMatrix->addAction(actionPlot3DPolygons);
+
+	QToolButton *btn3DMatrix = new QToolButton(this);
+	btn3DMatrix->setMenu(menu3DMatrix);
+	btn3DMatrix->setPopupMode(QToolButton::MenuButtonPopup);
+	btn3DMatrix->setDefaultAction(actionPlot3DWireSurface);
+	connect(menu3DMatrix, SIGNAL(triggered(QAction *)), btn3DMatrix, SLOT(setDefaultAction(QAction *)));
+	plotMatrixBar->addWidget(btn3DMatrix);
+
+	actionPlot3DBars->addTo(plotMatrixBar);
+	actionPlot3DScatter->addTo(plotMatrixBar);
+
+	plotMatrixBar->addSeparator();
+
+	QMenu *menuContourPlot = new QMenu(this);
+	menuContourPlot->addAction(actionColorMap);
+	menuContourPlot->addAction(actionContourMap);
+	menuContourPlot->addAction(actionGrayMap);
+
+	QToolButton *btnContourPlot = new QToolButton(this);
+	btnContourPlot->setMenu(menuContourPlot);
+	btnContourPlot->setPopupMode(QToolButton::MenuButtonPopup);
+	btnContourPlot->setDefaultAction(actionColorMap);
+	connect(menuContourPlot, SIGNAL(triggered(QAction *)), btnContourPlot, SLOT(setDefaultAction(QAction *)));
+	plotMatrixBar->addWidget(btnContourPlot);
+
+	actionImagePlot->addTo(plotMatrixBar);
+	actionImageProfilesPlot->addTo(plotMatrixBar);
+	actionPlotHistogram->addTo(plotMatrixBar);
+	plotMatrixBar->addSeparator();
+	actionSetMatrixValues->addTo(plotMatrixBar);
+	actionFlipMatrixHorizontally->addTo(plotMatrixBar);
+	actionFlipMatrixVertically->addTo(plotMatrixBar);
+	actionRotateMatrix->addTo(plotMatrixBar);
+	actionRotateMatrixMinus->addTo(plotMatrixBar);
+	plotMatrixBar->addSeparator();
+	plotMatrixBar->addAction(actionIncreasePrecision);
+	plotMatrixBar->addAction(actionDecreasePrecision);
+	plotMatrixBar->hide();
+
+	formatToolBar = new QToolBar(tr( "Format" ), this);
+	formatToolBar->setObjectName("formatToolBar");
+	addToolBar(Qt::TopToolBarArea, formatToolBar);
+
+	QFontComboBox *fb = new QFontComboBox();
+	connect(fb, SIGNAL(currentFontChanged(const QFont &)), this, SLOT(setFontFamily(const QFont &)));
+	actionFontBox = formatToolBar->addWidget(fb);
+
+	QSpinBox *sb = new QSpinBox();
+	connect(sb, SIGNAL(valueChanged(int)), this, SLOT(setFontSize(int)));
+	actionFontSize = formatToolBar->addWidget(sb);
+
+	actionFontBold->addTo(formatToolBar);
+	actionFontItalic->addTo(formatToolBar);
+
+	actionUnderline->addTo(formatToolBar);
+	actionSuperscript->addTo(formatToolBar);
+	actionSubscript->addTo(formatToolBar);
+	actionGreekSymbol->addTo(formatToolBar);
+	actionGreekMajSymbol->addTo(formatToolBar);
+	actionMathSymbol->addTo(formatToolBar);
+
+	formatToolBar->setEnabled(false);
+	formatToolBar->hide();
+
+	QList<QToolBar *> toolBars = toolBarsList();
+	foreach (QToolBar *t, toolBars)
+		connect(t, SIGNAL(actionTriggered(QAction *)), this, SLOT(performCustomAction(QAction *)));
+}
+
+void ApplicationWindow::insertTranslatedStrings()
+{
+	if (projectname == "untitled")
+		setWindowTitle(tr("QtiPlot - untitled"));
+
+	lv->setColumnText (0, tr("Name"));
+	lv->setColumnText (1, tr("Type"));
+	lv->setColumnText (2, tr("View"));
+	lv->setColumnText (3, tr("Size"));
+	lv->setColumnText (4, tr("Created"));
+	lv->setColumnText (5, tr("Label"));
+
+	if (scriptWindow)
+		scriptWindow->setWindowTitle(tr("QtiPlot - Script Window"));
+	explorerWindow->setWindowTitle(tr("Project Explorer"));
+	logWindow->setWindowTitle(tr("Results Log"));
+	undoStackWindow->setWindowTitle(tr("Undo Stack"));
+#ifdef SCRIPTING_CONSOLE
+	consoleWindow->setWindowTitle(tr("Scripting Console"));
+#endif
+	displayBar->setWindowTitle(tr("Data Display"));
+	tableTools->setWindowTitle(tr("Table"));
+	columnTools->setWindowTitle(tr("Column"));
+	plotTools->setWindowTitle(tr("Plot"));
+	fileTools->setWindowTitle(tr("File"));
+	editTools->setWindowTitle(tr("Edit"));
+	noteTools->setWindowTitle(tr("Notes"));
+	plotMatrixBar->setWindowTitle(tr("Matrix Plot"));
+	plot3DTools->setWindowTitle(tr("3D Surface"));
+	formatToolBar->setWindowTitle(tr("Format"));
+
+	fileMenu->changeItem(recentMenuID, tr("&Recent Projects"));
+	fileMenu->setTitle(tr("&File"));
+	newMenu->setTitle(tr("&New"));
+	exportPlotMenu->setTitle(tr("&Export Graph"));
+	importMenu->setTitle(tr("&Import"));
+	edit->setTitle(tr("&Edit"));
+	view->setTitle(tr("&View"));
+	graphMenu->setTitle(tr("&Graph"));
+	plot3DMenu->setTitle(tr("3D &Plot"));
+	matrixMenu->setTitle(tr("&Matrix"));
+    plot2DMenu->setTitle(tr("&Plot"));
+    plotDataMenu->setTitle(tr("&Data"));
+	normMenu->setTitle(tr("&Normalize"));
+	fillMenu->setTitle(tr("&Fill Columns With"));
+	tableMenu->setTitle(tr("&Table"));
+	smoothMenu->setTitle(tr("&Smooth"));
+	filterMenu->setTitle(tr("&FFT filter"));
+	decayMenu->setTitle(tr("Fit E&xponential Decay"));
+	multiPeakMenu->setTitle(tr("Fit &Multi-peak"));
+	analysisMenu->setTitle(tr("&Analysis"));
+	format->setTitle(tr("F&ormat"));
+	scriptingMenu->setTitle(tr("&Scripting"));
+	windowsMenu->setTitle(tr("&Windows"));
+	help->setTitle(tr("&Help"));
+
+	translateActionsStrings();
+	customMenu(activeWindow());
+}
+
+void ApplicationWindow::initMainMenu()
+{
+	menuBar()->setObjectName("menuBar");
+
+	fileMenu = new QMenu(this);
+	fileMenu->setObjectName("fileMenu");
+	connect(fileMenu, SIGNAL(aboutToShow()), this, SLOT(fileMenuAboutToShow()));
+	menuBar()->addMenu(fileMenu);
+
+	recent = new QMenu(this);
+	newMenu = new QMenu(this);
+	newMenu->setObjectName("newMenu");
+	exportPlotMenu = new QMenu(this);
+	exportPlotMenu->setObjectName("exportPlotMenu");
+	importMenu = new QMenu(this);
+	importMenu->setObjectName("importMenu");
+
+	edit = new QMenu(this);
+	edit->setObjectName("editMenu");
+	menuBar()->addMenu(edit);
+
+	edit->addAction(actionUndo);
+	edit->addAction(actionRedo);
+	edit->insertSeparator();
+	edit->addAction(actionCopySelection);
+	edit->addAction(actionPasteSelection);
+	edit->addAction(actionClearSelection);
+	edit->insertSeparator();
+	edit->addAction(actionDeleteFitTables);
+	edit->addAction(actionClearLogInfo);
+	edit->insertSeparator();
+	edit->addAction(actionShowConfigureDialog);
+
+	connect(edit, SIGNAL(aboutToShow()), this, SLOT(editMenuAboutToShow()));
+
+	view = new QMenu(this);
+	view->setObjectName("viewMenu");
+	menuBar()->addMenu(view);
+
+	view->setCheckable(true);
+	view->addAction(actionToolBars);
+	view->addAction(actionShowPlotWizard);
+	view->addAction(actionShowExplorer);
+	view->addAction(actionShowLog);
+	view->addAction(actionShowUndoStack);
+#ifdef SCRIPTING_CONSOLE
+	view->addAction(actionShowConsole);
+#endif
+
+	scriptingMenu = new QMenu(this);
+	scriptingMenu->setObjectName("scriptingMenu");
+	connect(scriptingMenu, SIGNAL(aboutToShow()), this, SLOT(scriptingMenuAboutToShow()));
+	menuBar()->addMenu(scriptingMenu);
+
+	graphMenu = new QMenu(this);
+	graphMenu->setObjectName("graphMenu");
+	graphMenu->setCheckable(true);
+	menuBar()->addMenu(graphMenu);
+
+	graphMenu->addAction(actionShowCurvesDialog);
+	graphMenu->addAction(actionAddFunctionCurve);
+	graphMenu->addAction(actionAddErrorBars);
+	graphMenu->addAction(actionNewLegend);
+	graphMenu->addSeparator();
+	graphMenu->addAction(actionAddFormula);
+	graphMenu->addAction(actionAddText);
+	graphMenu->addAction(btnArrow);
+	graphMenu->addAction(btnLine);
+	graphMenu->addAction(actionAddRectangle);
+	graphMenu->addAction(actionAddEllipse);
+	graphMenu->addAction(actionTimeStamp);
+	graphMenu->addAction(actionAddImage);
+	graphMenu->addSeparator();//layers section
+	graphMenu->addAction(actionAddLayer);
+	graphMenu->addAction(actionAddInsetLayer);
+	graphMenu->addAction(actionAddInsetCurveLayer);
+	graphMenu->addAction(actionShowLayerDialog);
+	graphMenu->addAction(actionAutomaticLayout);
+	graphMenu->addSeparator();
+	graphMenu->addAction(actionExtractLayers);
+	graphMenu->addAction(actionExtractGraphs);
+	graphMenu->addSeparator();
+	graphMenu->addAction(actionDeleteLayer);
+
+	plot3DMenu = new QMenu(this);
+	plot3DMenu->setObjectName("plot3DMenu");
+	plot3DMenu->addAction(actionPlot3DWireFrame);
+	plot3DMenu->addAction(actionPlot3DHiddenLine);
+	plot3DMenu->addAction(actionPlot3DPolygons);
+	plot3DMenu->addAction(actionPlot3DWireSurface);
+	plot3DMenu->insertSeparator();
+	plot3DMenu->addAction(actionPlot3DBars);
+	plot3DMenu->addAction(actionPlot3DScatter);
+	plot3DMenu->insertSeparator();
+	plot3DMenu->addAction(actionColorMap);
+	plot3DMenu->addAction(actionContourMap);
+	plot3DMenu->addAction(actionGrayMap);
+	plot3DMenu->insertSeparator();
+	plot3DMenu->addAction(actionImagePlot);
+	plot3DMenu->addAction(actionImageProfilesPlot);
+	plot3DMenu->insertSeparator();
+	plot3DMenu->addAction(actionPlotHistogram);
+	menuBar()->addMenu(plot3DMenu);
+
+	matrixMenu = new QMenu(this);
+	matrixMenu->setObjectName("matrixMenu");
+	connect(matrixMenu, SIGNAL(aboutToShow()), this, SLOT(matrixMenuAboutToShow()));
+	menuBar()->addMenu(matrixMenu);
+
+    plot2DMenu = new QMenu(this);
+	plot2DMenu->setObjectName("plot2DMenu");
+    connect(plot2DMenu, SIGNAL(aboutToShow()), this, SLOT(plotMenuAboutToShow()));
+    menuBar()->addMenu(plot2DMenu);
+
+    plotDataMenu = new QMenu(this);
+	plotDataMenu->setObjectName("plotDataMenu");
+	plotDataMenu->setCheckable(true);
+    connect(plotDataMenu, SIGNAL(aboutToShow()), this, SLOT(plotDataMenuAboutToShow()));
+    menuBar()->addMenu(plotDataMenu);
+
+	normMenu = new QMenu(this);
+	normMenu->setObjectName("normMenu");
+
+	fillMenu = new QMenu();
+	fillMenu->setObjectName("fillMenu");
+
+	analysisMenu = new QMenu(this);
+	analysisMenu->setObjectName("analysisMenu");
+    connect(analysisMenu, SIGNAL(aboutToShow()), this, SLOT(analysisMenuAboutToShow()));
+    menuBar()->addMenu(analysisMenu);
+
+	tableMenu = new QMenu(this);
+	tableMenu->setObjectName("tableMenu");
+    connect(tableMenu, SIGNAL(aboutToShow()), this, SLOT(tableMenuAboutToShow()));
+    menuBar()->addMenu(tableMenu);
+
+	smoothMenu = new QMenu(this);
+	smoothMenu->setObjectName("smoothMenu");
+
+	filterMenu = new QMenu(this);
+	filterMenu->setObjectName("filterMenu");
+
+	decayMenu = new QMenu(this);
+	decayMenu->setObjectName("decayMenu");
+
+	multiPeakMenu = new QMenu(this);
+	multiPeakMenu->setObjectName("multiPeakMenu");
+
+	format = new QMenu(this);
+	format->setObjectName("formatMenu");
+	menuBar()->addMenu(format);
+
+	windowsMenu = new QMenu(this);
+	windowsMenu->setObjectName("windowsMenu");
+	windowsMenu->setCheckable(true);
+	connect(windowsMenu, SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));
+	menuBar()->addMenu(windowsMenu);
+
+	foldersMenu = new QMenu(this);
+	foldersMenu->setCheckable(true);
+
+	help = new QMenu(this);
+	help->setObjectName("helpMenu");
+	menuBar()->addMenu(help);
+
+	help->addAction(actionShowHelp);
+	help->addAction(actionChooseHelpFolder);
+	help->insertSeparator();
+	help->addAction(actionHomePage);
+	help->addAction(actionCheckUpdates);
+	help->addAction(actionDownloadManual);
+	help->addAction(actionTranslations);
+	help->insertSeparator();
+	help->addAction(actionTechnicalSupport);
+	help->addAction(actionDonate);
+	help->addAction(actionHelpForums);
+	help->addAction(actionHelpBugReports);
+	help->insertSeparator();
+	help->addAction(actionAbout);
+
+	QList<QMenu *> menus;
+	menus << windowsMenu << view << graphMenu << fileMenu << format << edit;
+	menus << help << plot2DMenu << analysisMenu;
+	menus << matrixMenu << plot3DMenu << plotDataMenu << scriptingMenu;
+	menus << tableMenu << newMenu << exportPlotMenu << importMenu;
+
+	foreach (QMenu *m, menus)
+    	connect(m, SIGNAL(triggered(QAction *)), this, SLOT(performCustomAction(QAction *)));
+
+	disableActions();
+}
+
+void ApplicationWindow::tableMenuAboutToShow()
+{
+    tableMenu->clear();
+	fillMenu->clear();
+
+    QMenu *setAsMenu = tableMenu->addMenu(tr("Set Columns &As"));
+	setAsMenu->addAction(actionSetXCol);
+	setAsMenu->addAction(actionSetYCol);
+	setAsMenu->addAction(actionSetZCol);
+	setAsMenu->insertSeparator();
+	setAsMenu->addAction(actionSetLabelCol);
+	setAsMenu->addAction(actionDisregardCol);
+	setAsMenu->insertSeparator();
+	setAsMenu->addAction(actionSetXErrCol);
+	setAsMenu->addAction(actionSetYErrCol);
+	setAsMenu->insertSeparator();
+	setAsMenu->addAction(tr("&Read-only"), this, SLOT(setReadOnlyColumns()));
+	setAsMenu->addAction(tr("Read/&Write"), this, SLOT(setReadWriteColumns()));
+
+	tableMenu->addAction(actionShowColumnOptionsDialog);
+	tableMenu->insertSeparator();
+
+	tableMenu->addAction(actionShowColumnValuesDialog);
+	tableMenu->addAction(actionTableRecalculate);
+
+	fillMenu->addAction(actionSetAscValues);
+	fillMenu->addAction(actionSetRandomValues);
+	tableMenu->addMenu (fillMenu);
+
+	tableMenu->addAction(actionClearTable);
+	tableMenu->insertSeparator();
+	tableMenu->addAction(actionAddColToTable);
+	tableMenu->addAction(actionShowColsDialog);
+	tableMenu->insertSeparator();
+	tableMenu->addAction(actionHideSelectedColumns);
+	tableMenu->addAction(actionShowAllColumns);
+	tableMenu->addAction(actionAdjustColumnWidth);
+	tableMenu->insertSeparator();
+	tableMenu->addAction(actionMoveColFirst);
+	tableMenu->addAction(actionMoveColLeft);
+	tableMenu->addAction(actionMoveColRight);
+	tableMenu->addAction(actionMoveColLast);
+	tableMenu->addAction(actionSwapColumns);
+	tableMenu->insertSeparator();
+	tableMenu->addAction(actionShowRowsDialog);
+	tableMenu->addAction(actionDeleteRows);
+
+	QMenu *moveRowMenu = tableMenu->addMenu(tr("Move Row"));
+	moveRowMenu->addAction(actionMoveRowUp);
+	moveRowMenu->addAction(actionMoveRowDown);
+
+	tableMenu->insertSeparator();
+	tableMenu->addAction(actionGoToRow);
+	tableMenu->addAction(actionGoToColumn);
+	tableMenu->addAction(actionExtractTableData);
+	tableMenu->insertSeparator();
+
+	QMenu *convertToMatrixMenu = tableMenu->addMenu(tr("Convert to &Matrix"));
+	convertToMatrixMenu->addAction(actionConvertTableDirect);
+	convertToMatrixMenu->addAction(actionConvertTableBinning);
+	convertToMatrixMenu->addAction(actionConvertTableRegularXYZ);
+
+    reloadCustomActions();
+}
+
+void ApplicationWindow::plotDataMenuAboutToShow()
+{
+    plotDataMenu->clear();
+	plotDataMenu->addAction(btnPointer);
+	plotDataMenu->insertSeparator();
+	plotDataMenu->addAction(actionMagnify);
+	plotDataMenu->addAction(actionMagnifyHor);
+	plotDataMenu->addAction(actionMagnifyVert);
+	plotDataMenu->addAction(btnZoomIn);
+	plotDataMenu->addAction(btnZoomOut);
+	plotDataMenu->addAction(actionUnzoom);
+	plotDataMenu->insertSeparator();
+	plotDataMenu->addAction(btnCursor);
+	plotDataMenu->addAction(btnSelect);
+	plotDataMenu->addAction(btnPicker);
+	plotDataMenu->insertSeparator();
+	plotDataMenu->addAction(actionDrawPoints);
+	plotDataMenu->addAction(btnMovePoints);
+	plotDataMenu->addAction(btnRemovePoints);
+	plotDataMenu->addAction(actionDragCurve);
+
+    reloadCustomActions();
+}
+
+void ApplicationWindow::plotMenuAboutToShow()
+{
+	plot2DMenu->clear();
+
+	plot2DMenu->addAction(actionPlotL);
+	plot2DMenu->addAction(actionPlotP);
+	plot2DMenu->addAction(actionPlotLP);
+
+    QMenu *specialPlotMenu = plot2DMenu->addMenu (tr("Special Line/Symb&ol"));
+	specialPlotMenu->addAction(actionPlotVerticalDropLines);
+	specialPlotMenu->addAction(actionPlotSpline);
+	specialPlotMenu->addAction(actionPlotVertSteps);
+	specialPlotMenu->addAction(actionPlotHorSteps);
+	specialPlotMenu->insertSeparator();
+	specialPlotMenu->addAction(actionPlotDoubleYAxis);
+	specialPlotMenu->addAction(actionWaterfallPlot);
+	specialPlotMenu->addAction(actionAddZoomPlot);
+
+	plot2DMenu->insertSeparator();
+	plot2DMenu->addAction(actionPlotVerticalBars);
+	plot2DMenu->addAction(actionPlotHorizontalBars);
+	QMenu *specialBarMenu = plot2DMenu->addMenu (tr("Spec&ial Bar/Column"));
+	specialBarMenu->addAction(actionStackBars);
+	specialBarMenu->addAction(actionStackColumns);
+
+	plot2DMenu->addAction(actionPlotArea);
+	plot2DMenu->addAction(actionPlotPie);
+	plot2DMenu->addAction(actionPlotVectXYXY);
+	plot2DMenu->addAction(actionPlotVectXYAM);
+	plot2DMenu->insertSeparator();
+
+	QMenu *statMenu = plot2DMenu->addMenu (tr("Statistical &Graphs"));
+	statMenu->addAction(actionBoxPlot);
+	statMenu->addAction(actionPlotHistogram);
+	statMenu->addAction(actionPlotStackedHistograms);
+	statMenu->insertSeparator();
+	statMenu->addAction(actionStemPlot);
+
+    QMenu *panelsMenu = plot2DMenu->addMenu (tr("Pa&nel"));
+	panelsMenu->addAction(actionPlot2VerticalLayers);
+	panelsMenu->addAction(actionPlot2HorizontalLayers);
+	panelsMenu->addAction(actionPlot4Layers);
+	panelsMenu->addAction(actionPlotStackedLayers);
+	panelsMenu->addAction(actionCustomLayout);
+
+	QMenu *gridMenu = plot2DMenu->addMenu (tr("Shared A&xes Panel"));
+	gridMenu->addAction(actionVertSharedAxisLayers);
+	gridMenu->addAction(actionHorSharedAxisLayers);
+	gridMenu->addAction(actionSharedAxesLayers);
+	gridMenu->addAction(actionStackSharedAxisLayers);
+	gridMenu->addAction(actionCustomSharedAxisLayers);
+
+	QMenu *plot3D = plot2DMenu->addMenu (tr("3&D Plot"));
+	plot3D->addAction(actionPlot3DRibbon);
+	plot3D->addAction(actionPlot3DBars);
+	plot3D->addAction(actionPlot3DScatter);
+	plot3D->addAction(actionPlot3DTrajectory);
+
+    reloadCustomActions();
+}
+
+void ApplicationWindow::customMenu(QMdiSubWindow* w)
+{
+    analysisMenu->menuAction()->setVisible(false);
+    tableMenu->menuAction()->setVisible(false);
+    plotDataMenu->menuAction()->setVisible(false);
+    graphMenu->menuAction()->setVisible(false);
+    matrixMenu->menuAction()->setVisible(false);
+	format->menuAction()->setVisible(false);
+    plot2DMenu->menuAction()->setVisible(false);
+    plot3DMenu->menuAction()->setVisible(false);
+#ifndef SCRIPTING_PYTHON
+	scriptingMenu->menuAction()->setVisible(false);
+#endif
+
+	// these use the same keyboard shortcut (Ctrl+Return) and should not be enabled at the same time
+	actionNoteEvaluate->setEnabled(false);
+	actionTableRecalculate->setEnabled(false);
+	// these use the same keyboard shortcut (Alt+C) and should not be enabled at the same time
+	actionShowCurvesDialog->setEnabled(false);
+	actionAddColToTable->setEnabled(false);
+	// these use the same keyboard shortcut (Alt+Q) and should not be enabled at the same time
+	actionAddFormula->setEnabled(false);
+	actionShowColumnValuesDialog->setEnabled(false);
+	actionSetMatrixValues->setEnabled(false);
+	// these use the same keyboard shortcut (Ctrl+Alt+F) and should not be enabled at the same time
+	actionAddFunctionCurve->setEnabled(false);
+	actionFind->setEnabled(false);
+
+	// clear undo stack view (in case window is not a matrix)
+	d_undo_view->setStack(0);
+	actionUndo->setEnabled(false);
+	actionRedo->setEnabled(false);
+
+	actionCopyWindow->setEnabled(w);
+	actionPrint->setEnabled(w);
+	actionPrintPreview->setEnabled(w);
+	actionExportPDF->setEnabled(w);
+
+	if(w){
+		actionPrintAllPlots->setEnabled(projectHas2DPlots());
+		actionPrint->setEnabled(true);
+		actionCutSelection->setEnabled(true);
+		actionCopySelection->setEnabled(true);
+		actionPasteSelection->setEnabled(true);
+		actionClearSelection->setEnabled(true);
+		actionSaveTemplate->setEnabled(true);
+		QStringList tables = tableNames() + matrixNames();
+		if (!tables.isEmpty())
+			actionShowExportASCIIDialog->setEnabled(true);
+		else
+			actionShowExportASCIIDialog->setEnabled(false);
+
+		if (w->isA("MultiLayer")) {
+			actionAddFunctionCurve->setEnabled(true);
+			actionShowCurvesDialog->setEnabled(true);
+			actionAddFormula->setEnabled(true);
+
+			graphMenu->menuAction()->setVisible(true);
+			plotDataMenu->menuAction()->setVisible(true);
+			analysisMenu->menuAction()->setVisible(true);
+			format->menuAction()->setVisible(true);
+			format->clear();
+			format->addAction(actionShowPlotDialog);
+			format->insertSeparator();
+            format->addAction(actionShowScaleDialog);
+            format->addAction(actionShowAxisDialog);
+            actionShowAxisDialog->setEnabled(true);
+            format->insertSeparator();
+            format->addAction(actionShowGridDialog);
+			format->addAction(actionShowTitleDialog);
+		} else if (w->isA("Graph3D")) {
+			disableActions();
+
+			actionPrint->setEnabled(true);
+			actionSaveTemplate->setEnabled(true);
+
+			format->menuAction()->setVisible(true);
+			format->clear();
+			format->addAction(actionShowPlotDialog);
+			format->addAction(actionShowScaleDialog);
+			format->addAction(actionShowAxisDialog);
+			format->addAction(actionShowTitleDialog);
+			if (((Graph3D*)w)->coordStyle() == Qwt3D::NOCOORD)
+				actionShowAxisDialog->setEnabled(false);
+		} else if (w->inherits("Table")) {
+			plot2DMenu->menuAction()->setVisible(true);
+			analysisMenu->menuAction()->setVisible(true);
+			tableMenu->menuAction()->setVisible(true);
+
+			actionTableRecalculate->setEnabled(true);
+			actionAddColToTable->setEnabled(true);
+			actionShowColumnValuesDialog->setEnabled(true);
+		} else if (w->isA("Matrix")){
+			actionTableRecalculate->setEnabled(true);
+			actionSetMatrixValues->setEnabled(true);
+
+			plot3DMenu->menuAction()->setVisible(true);
+			analysisMenu->menuAction()->setVisible(true);
+			matrixMenu->menuAction()->setVisible(true);
+
+			d_undo_view->setEmptyLabel(w->objectName() + ": " + tr("Empty Stack"));
+			QUndoStack *stack = ((Matrix *)w)->undoStack();
+			d_undo_view->setStack(stack);
+		} else if (qobject_cast<Note*>(w)){
+			#ifndef SCRIPTING_PYTHON
+			scriptingMenu->menuAction()->setVisible(true);
+			#endif
+			actionSaveTemplate->setEnabled(false);
+			actionNoteEvaluate->setEnabled(true);
+			actionFind->setEnabled(true);
+		} else
+			disableActions();
+	} else
+		disableActions();
+
+	reloadCustomActions();
+}
+
+void ApplicationWindow::disableActions()
+{
+	actionSaveTemplate->setEnabled(false);
+	actionPrintAllPlots->setEnabled(false);
+	actionPrint->setEnabled(false);
+
+	actionCutSelection->setEnabled(false);
+	actionCopySelection->setEnabled(false);
+	actionPasteSelection->setEnabled(false);
+	actionClearSelection->setEnabled(false);
+}
+
+void ApplicationWindow::customColumnActions()
+{
+	actionAdjustColumnWidth->setEnabled(false);
+    actionMoveColFirst->setEnabled(false);
+    actionMoveColLeft->setEnabled(false);
+    actionMoveColRight->setEnabled(false);
+    actionMoveColLast->setEnabled(false);
+    actionSetXCol->setEnabled(false);
+    actionSetYCol->setEnabled(false);
+    actionSetZCol->setEnabled(false);
+    actionSetLabelCol->setEnabled(false);
+    actionSetYErrCol->setEnabled(false);
+    actionDisregardCol->setEnabled(false);
+    actionSwapColumns->setEnabled(false);
+    actionSetAscValues->setEnabled(false);
+    actionSetRandomValues->setEnabled(false);
+
+	Table *t = (Table*)activeWindow(TableWindow);
+    if (!t)
+		return;
+
+    int selectedCols = t->selectedColsNumber();
+    if (selectedCols == 1){
+        int col = t->selectedColumn();
+        if (col > 0){
+            actionMoveColFirst->setEnabled(true);
+            actionMoveColLeft->setEnabled(true);
+        }
+
+        if (col < t->numCols() - 1){
+            actionMoveColRight->setEnabled(true);
+            actionMoveColLast->setEnabled(true);
+        }
+	}
+
+	if (selectedCols >= 1){
+	    actionSetAscValues->setEnabled(true);
+        actionSetRandomValues->setEnabled(true);
+        actionSetXCol->setEnabled(true);
+        actionSetYCol->setEnabled(true);
+        actionSetZCol->setEnabled(true);
+        actionSetYErrCol->setEnabled(true);
+        actionSetLabelCol->setEnabled(true);
+        actionDisregardCol->setEnabled(true);
+        actionAdjustColumnWidth->setEnabled(true);
+	}
+
+	if (selectedCols == 2)
+	    actionSwapColumns->setEnabled(true);
+}
+
+void ApplicationWindow::customToolBars(QMdiSubWindow* w)
+{
+    disableToolbars();
+	if (!w)
+        return;
+
+    if (w->isA("MultiLayer") && d_plot_tool_bar){
+        if(!plotTools->isVisible())
+            plotTools->show();
+        plotTools->setEnabled (true);
+        custom2DPlotTools((MultiLayer *)w);
+		if(d_format_tool_bar && !formatToolBar->isVisible()){
+			formatToolBar->setEnabled (true);
+            formatToolBar->show();
+		}
+    } else if (w->inherits("Table")){
+        if(d_table_tool_bar){
+            if(!tableTools->isVisible())
+                tableTools->show();
+            tableTools->setEnabled (true);
+        }
+        if (d_column_tool_bar){
+            if(!columnTools->isVisible())
+                columnTools->show();
+            columnTools->setEnabled (true);
+            customColumnActions();
+        }
+    } else if (w->isA("Matrix") && d_matrix_tool_bar){
+         if(!plotMatrixBar->isVisible())
+            plotMatrixBar->show();
+        plotMatrixBar->setEnabled (true);
+    } else if (w->isA("Graph3D") && d_plot3D_tool_bar){
+		if(!plot3DTools->isVisible())
+			plot3DTools->show();
+
+		plot3DTools->setEnabled(((Graph3D*)w)->plotStyle() != Qwt3D::NOPLOT);
+		custom3DActions(w);
+    } else if (w->isA("Note")){
+		if(d_format_tool_bar && !formatToolBar->isVisible())
+            formatToolBar->show();
+		if(d_notes_tool_bar && !noteTools->isVisible())
+            noteTools->show();
+
+        formatToolBar->setEnabled (true);
+        noteTools->setEnabled (true);
+        setFormatBarFont(((Note*)w)->currentEditor()->currentFont());
+    }
+}
+
+void ApplicationWindow::disableToolbars()
+{
+	plotTools->setEnabled(false);
+	tableTools->setEnabled(false);
+	columnTools->setEnabled(false);
+	plot3DTools->setEnabled(false);
+	plotMatrixBar->setEnabled(false);
+	noteTools->setEnabled(false);
+}
+
+void ApplicationWindow::plot3DRibbon()
+{
+	MdiSubWindow *w = activeWindow(TableWindow);
+    if (!w)
+		return;
+
+	Table *table = static_cast<Table*>(w);
+	if(table->selectedColumns().count() == 1){
+		if (!validFor3DPlot(table))
+			return;
+		plotXYZ(table, table->colName(table->selectedColumn()), Graph3D::Ribbon);
+	} else
+		QMessageBox::warning(this, tr("QtiPlot - Plot error"), tr("You must select exactly one column for plotting!"));
+}
+
+void ApplicationWindow::plot3DWireframe()
+{
+	plot3DMatrix (0, Qwt3D::WIREFRAME);
+}
+
+void ApplicationWindow::plot3DHiddenLine()
+{
+	plot3DMatrix (0, Qwt3D::HIDDENLINE);
+}
+
+void ApplicationWindow::plot3DPolygons()
+{
+	plot3DMatrix (0, Qwt3D::FILLED);
+}
+
+void ApplicationWindow::plot3DWireSurface()
+{
+	plot3DMatrix (0, Qwt3D::FILLEDMESH);
+}
+
+void ApplicationWindow::plot3DBars()
+{
+	MdiSubWindow *w = activeWindow();
+    if (!w)
+		return;
+
+	if (w->inherits("Table")){
+		Table *table = static_cast<Table *>(w);
+		if (!validFor3DPlot(table))
+			return;
+
+		if(table->selectedColumns().count() == 1)
+			plotXYZ(table, table->colName(table->selectedColumn()), Graph3D::Bars);
+		else
+			QMessageBox::warning(this, tr("QtiPlot - Plot error"),tr("You must select exactly one column for plotting!"));
+	}
+	else if(w->inherits("Matrix"))
+		plot3DMatrix(0, Qwt3D::USER);
+}
+
+void ApplicationWindow::plot3DScatter()
+{
+	MdiSubWindow *w = activeWindow();
+	if (!w)
+		return;
+
+	if (w->inherits("Table"))
+	{
+		Table *table = static_cast<Table *>(w);
+		if (!validFor3DPlot(table))
+			return;
+
+		if(table->selectedColumns().count() == 1)
+			plotXYZ(table, table->colName(table->selectedColumn()), Graph3D::Scatter);
+		else
+			QMessageBox::warning(this, tr("QtiPlot - Plot error"),tr("You must select exactly one column for plotting!"));
+	}
+	else if(w->inherits("Matrix"))
+		plot3DMatrix (0, Qwt3D::POINTS);
+}
+
+void ApplicationWindow::plot3DTrajectory()
+{
+	Table *table = (Table *)activeWindow(TableWindow);
+    if (!table)
+		return;
+    if (!validFor3DPlot(table))
+        return;
+
+    if(table->selectedColumns().count() == 1)
+        plotXYZ(table, table->colName(table->selectedColumn()), Graph3D::Trajectory);
+    else
+        QMessageBox::warning(this, tr("QtiPlot - Plot error"), tr("You must select exactly one column for plotting!"));
+}
+
+void ApplicationWindow::plotBoxDiagram()
+{
+    generate2DGraph(Graph::Box);
+}
+
+void ApplicationWindow::plotVerticalBars()
+{
+	generate2DGraph(Graph::VerticalBars);
+}
+
+void ApplicationWindow::plotHorizontalBars()
+{
+	generate2DGraph(Graph::HorizontalBars);
+}
+
+void ApplicationWindow::plotStackBar()
+{
+	generate2DGraph(Graph::StackBar);
+}
+
+void ApplicationWindow::plotStackColumn()
+{
+	generate2DGraph(Graph::StackColumn);
+}
+
+MultiLayer* ApplicationWindow::plotHistogram()
+{
+    return generate2DGraph(Graph::Histogram);
+}
+
+MultiLayer* ApplicationWindow::plotHistogram(Matrix *m)
+{
+	if (!m){
+		m = (Matrix*)activeWindow(MatrixWindow);
+		if (!m)
+			return 0;
+	}
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+	MultiLayer* g = newGraph();
+	if (g)
+		g->activeLayer()->addHistogram(m);
+	QApplication::restoreOverrideCursor();
+	return g;
+}
+
+void ApplicationWindow::plotArea()
+{
+	generate2DGraph(Graph::Area);
+}
+
+void ApplicationWindow::plotPie()
+{
+	Table *table = (Table *)activeWindow(TableWindow);
+    if (!table)
+		return;
+
+	if(table->selectedColumns().count() != 1){
+		QMessageBox::warning(this, tr("QtiPlot - Plot error"),
+				tr("You must select exactly one column for plotting!"));
+		return;
+	}
+
+	QStringList s = table->selectedColumns();
+	if (s.count()>0){
+		Q3TableSelection sel = table->getSelection();
+		multilayerPlot(table, s, Graph::Pie, sel.topRow(), sel.bottomRow());
+	} else
+		QMessageBox::warning(this, tr("QtiPlot - Error"), tr("Please select a column to plot!"));
+}
+
+void ApplicationWindow::plotL()
+{
+	generate2DGraph(Graph::Line);
+}
+
+void ApplicationWindow::plotP()
+{
+	generate2DGraph(Graph::Scatter);
+}
+
+void ApplicationWindow::plotLP()
+{
+	generate2DGraph(Graph::LineSymbols);
+}
+
+void ApplicationWindow::plotVerticalDropLines()
+{
+	generate2DGraph(Graph::VerticalDropLines);
+}
+
+void ApplicationWindow::plotSpline()
+{
+	generate2DGraph(Graph::Spline);
+}
+
+void ApplicationWindow::plotVertSteps()
+{
+	generate2DGraph(Graph::VerticalSteps);
+}
+
+void ApplicationWindow::plotHorSteps()
+{
+	generate2DGraph(Graph::HorizontalSteps);
+}
+
+void ApplicationWindow::plotVectXYXY()
+{
+	Table *table = (Table *)activeWindow(TableWindow);
+    if (!table)
+		return;
+	if (!validFor2DPlot(table, Graph::VectXYXY))
+		return;
+
+	QStringList s = table->selectedColumns();
+	if (s.count() == 4) {
+		Q3TableSelection sel = table->getSelection();
+		multilayerPlot(table, s, Graph::VectXYXY, sel.topRow(), sel.bottomRow());
+	} else
+		QMessageBox::warning(this, tr("QtiPlot - Error"), tr("Please select four columns for this operation!"));
+}
+
+void ApplicationWindow::plotVectXYAM()
+{
+    Table *table = (Table *)activeWindow(TableWindow);
+    if (!table)
+		return;
+	if (!validFor2DPlot(table, Graph::VectXYAM))
+		return;
+
+	QStringList s = table->selectedColumns();
+	if (s.count() == 4){
+		Q3TableSelection sel = table->getSelection();
+		multilayerPlot(table, s, Graph::VectXYAM, sel.topRow(), sel.bottomRow());
+	} else
+		QMessageBox::warning(this, tr("QtiPlot - Error"), tr("Please select four columns for this operation!"));
+}
+
+void ApplicationWindow::renameListViewItem(const QString& oldName,const QString& newName)
+{
+	Q3ListViewItem *it=lv->findItem (oldName,0, Q3ListView::ExactMatch | Qt::CaseSensitive );
+	if (it)
+		it->setText(0,newName);
+}
+
+void ApplicationWindow::setListViewLabel(const QString& caption,const QString& label)
+{
+	Q3ListViewItem *it = lv->findItem ( caption, 0, Q3ListView::ExactMatch | Qt::CaseSensitive );
+	if (it){
+		QString s = label;
+		it->setText(5, s.replace("\n", " "));
+	}
+}
+
+void ApplicationWindow::setListViewDate(const QString& caption,const QString& date)
+{
+	Q3ListViewItem *it=lv->findItem ( caption, 0, Q3ListView::ExactMatch | Qt::CaseSensitive );
+	if (it)
+		it->setText(4,date);
+}
+
+void ApplicationWindow::setListView(const QString& caption,const QString& view)
+{
+	Q3ListViewItem *it=lv->findItem ( caption,0, Q3ListView::ExactMatch | Qt::CaseSensitive );
+	if (it)
+		it->setText(2,view);
+}
+
+void ApplicationWindow::setListViewSize(const QString& caption,const QString& size)
+{
+	Q3ListViewItem *it=lv->findItem ( caption,0, Q3ListView::ExactMatch | Qt::CaseSensitive );
+	if (it)
+		it->setText(3,size);
+}
+
+QString ApplicationWindow::listViewDate(const QString& caption)
+{
+	Q3ListViewItem *it=lv->findItem (caption,0, Q3ListView::ExactMatch | Qt::CaseSensitive );
+	if (it)
+		return it->text(4);
+	else
+		return "";
+}
+
+void ApplicationWindow::updateTableNames(const QString& oldName, const QString& newName)
+{
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach (MdiSubWindow *w, windows) {
+		if (w->isA("MultiLayer")) {
+			QList<Graph *> layers = ((MultiLayer*)w)->layersList();
+			foreach(Graph *g, layers)
+				g->updateCurveNames(oldName, newName);
+		} else if (w->isA("Graph3D")) {
+			QString name = ((Graph3D*)w)->formula();
+			if (name.contains(oldName, true)) {
+				name.replace(oldName,newName);
+				((Graph3D*)w)->setPlotAssociation(name);
+			}
+		}
+	}
+}
+
+void ApplicationWindow::updateColNames(const QString& oldName, const QString& newName)
+{
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach (MdiSubWindow *w, windows){
+		if (w->isA("MultiLayer")){
+			QList<Graph *> layers = ((MultiLayer*)w)->layersList();
+			foreach(Graph *g, layers)
+                g->updateCurveNames(oldName, newName, false);
+		}
+		else if (w->isA("Graph3D")){
+			QString name = ((Graph3D*)w)->formula();
+			if (name.contains(oldName)){
+				name.replace(oldName,newName);
+				((Graph3D*)w)->setPlotAssociation(name);
+			}
+		}
+	}
+}
+
+void ApplicationWindow::changeMatrixName(const QString& oldName, const QString& newName)
+{
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach(MdiSubWindow *w, windows){
+		if (w->isA("Graph3D"))
+		{
+			QString s = ((Graph3D*)w)->formula();
+			if (s.contains(oldName))
+			{
+				s.replace(oldName, newName);
+				((Graph3D*)w)->setPlotAssociation(s);
+			}
+		}
+		else if (w->isA("MultiLayer"))
+		{
+			QList<Graph *> layers = ((MultiLayer*)w)->layersList();
+			foreach(Graph *g, layers){
+				for (int i=0; i<g->curveCount(); i++){
+					QwtPlotItem *sp = (QwtPlotItem *)g->plotItem(i);
+					if (sp && sp->rtti() == QwtPlotItem::Rtti_PlotSpectrogram && sp->title().text() == oldName)
+						sp->setTitle(newName);
+				}
+			}
+		}
+	}
+}
+
+void ApplicationWindow::remove3DMatrixPlots(Matrix *m)
+{
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach(MdiSubWindow *w, windows){
+		if (w->isA("Graph3D") && ((Graph3D*)w)->matrix() == m)
+			((Graph3D*)w)->clearData();
+		else if (w->isA("MultiLayer")){
+			QList<Graph *> layers = ((MultiLayer*)w)->layersList();
+			foreach(Graph *g, layers){
+				QList<QwtPlotItem *> curvesList = g->curvesList();
+				foreach (QwtPlotItem *it, curvesList){
+					if (it->rtti() == QwtPlotItem::Rtti_PlotSpectrogram){
+						if (((Spectrogram *)it)->matrix() == m)
+                            g->removeCurve(it);
+					} else if (((PlotCurve *)it)->type() == Graph::Histogram){
+                        if (((QwtHistogram *)it)->matrix() == m)
+                            g->removeCurve(it);
+					}
+				}
+				g->updatePlot();
+			}
+		}
+	}
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::updateMatrixPlots(Matrix *m)
+{
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach(MdiSubWindow *w, windows){
+		if (w->isA("Graph3D") && ((Graph3D*)w)->matrix() == m)
+			((Graph3D*)w)->updateMatrixData(m);
+		else if (w->isA("MultiLayer")){
+			QList<Graph *> layers = ((MultiLayer*)w)->layersList();
+			foreach(Graph *g, layers){
+				QList<QwtPlotItem *> curvesList = g->curvesList();
+				foreach (QwtPlotItem *it, curvesList){
+					if (it->rtti() == QwtPlotItem::Rtti_PlotSpectrogram){
+                        Spectrogram *sp = (Spectrogram *)it;
+                        if (sp->matrix() == m){
+                            sp->updateData();
+                            g->updatePlot();
+                        }
+				    } else if (((PlotCurve *)it)->type() == Graph::Histogram){
+						QwtHistogram *h = (QwtHistogram *)it;
+                        if (h->matrix() == m){
+                            h->loadData();
+                            g->updatePlot();
+                        }
+					}
+				}
+			}
+		}
+	}
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::add3DData()
+{
+	if (!hasTable()){
+		QMessageBox::warning(this,tr("QtiPlot - Warning"),
+				tr("<h4>There are no tables available in this project.</h4>"
+					"<p><h4>Please create a table and try again!</h4>"));
+		return;
+	}
+
+	QStringList zColumns = columnsList(Table::Z);
+	if ((int)zColumns.count() <= 0){
+		QMessageBox::critical(this,tr("QtiPlot - Warning"),
+				tr("There are no available columns with plot designation set to Z!"));
+		return;
+	}
+
+	bool ok;
+	QString column = QInputDialog::getItem(this, tr("QtiPlot - Choose data set"),
+									tr("Column") + ": ", zColumns, 0, false, &ok);
+	if (ok && !column.isEmpty())
+		insertNew3DData(column);
+}
+
+void ApplicationWindow::change3DData()
+{
+	bool ok;
+	QString column = QInputDialog::getItem(this, tr("QtiPlot - Choose data set"),
+									tr("Column") + ": ", columnsList(Table::Z), 0, false, &ok);
+	if (ok && !column.isEmpty())
+		change3DData(column);
+}
+
+void ApplicationWindow::change3DMatrix()
+{
+	QStringList matrices = matrixNames();
+	int currentIndex = 0;
+	Graph3D* g = (Graph3D*)activeWindow(Plot3DWindow);
+	if (g && g->matrix())
+		currentIndex = matrices.indexOf(g->matrix()->objectName());
+
+	bool ok;
+	QString matrixName = QInputDialog::getItem(this, tr("QtiPlot - Choose matrix to plot"),
+							tr("Matrix") + ": ", matrices, currentIndex, false, &ok);
+	if (ok && !matrixName.isEmpty())
+		change3DMatrix(matrixName);
+}
+
+void ApplicationWindow::change3DMatrix(const QString& matrix_name)
+{
+	Graph3D *g = (Graph3D*)activeWindow(Plot3DWindow);
+    if (!g)
+		return;
+
+	Matrix *m = matrix(matrix_name);
+	if (!m)
+        return;
+
+	if (d_3D_autoscale)
+        g->addMatrixData(m);
+    else
+		g->addMatrixData(m, g->xStart(), g->xStop(), g->yStart(), g->yStop(), g->zStart(), g->zStop());
+
+	emit modified();
+}
+
+void ApplicationWindow::add3DMatrixPlot()
+{
+	QStringList matrices = matrixNames();
+	if ((int)matrices.count() <= 0){
+		QMessageBox::warning(this, tr("QtiPlot - Warning"),
+				tr("<h4>There are no matrices available in this project.</h4>"
+					"<p><h4>Please create a matrix and try again!</h4>"));
+		return;
+	}
+
+	bool ok;
+	QString matrixName = QInputDialog::getItem(this, tr("QtiPlot - Choose matrix to plot"),
+							tr("Matrix") + ": ", matrices, 0, false, &ok);
+	if (ok && !matrixName.isEmpty())
+		insert3DMatrixPlot(matrixName);
+}
+
+void ApplicationWindow::insert3DMatrixPlot(const QString& matrix_name)
+{
+	Graph3D *g = (Graph3D*)activeWindow(Plot3DWindow);
+    if (!g)
+		return;
+
+	g->addMatrixData(matrix(matrix_name));
+	emit modified();
+}
+
+void ApplicationWindow::insertNew3DData(const QString& colName)
+{
+	Graph3D *g = (Graph3D*)activeWindow(Plot3DWindow);
+    if (!g)
+		return;
+
+	g->insertNewData(table(colName),colName);
+	emit modified();
+}
+
+void ApplicationWindow::change3DData(const QString& colName)
+{
+	Graph3D *g = (Graph3D*)activeWindow(Plot3DWindow);
+    if (!g)
+		return;
+
+	g->changeDataColumn(table(colName), colName, g->tablePlotType());
+	emit modified();
+}
+
+void ApplicationWindow::editSurfacePlot()
+{
+	Graph3D *g = (Graph3D*)activeWindow(Plot3DWindow);
+    if (!g)
+		return;
+
+	SurfaceDialog* sd = new SurfaceDialog(this);
+	sd->setAttribute(Qt::WA_DeleteOnClose);
+
+	if (g->hasData() && g->userFunction())
+		sd->setFunction(g);
+	else if (g->hasData() && g->parametricSurface())
+		sd->setParametricSurface(g);
+	else
+		sd->setGraph(g);
+	sd->exec();
+}
+
+void ApplicationWindow::newSurfacePlot()
+{
+	SurfaceDialog* sd = new SurfaceDialog(this);
+	sd->setAttribute(Qt::WA_DeleteOnClose);
+	sd->exec();
+}
+
+Graph3D* ApplicationWindow::plotSurface(const QString& formula, double xl, double xr,
+		double yl, double yr, double zl, double zr, int columns, int rows)
+{
+	Graph3D *plot = newPlot3D();
+	if(!plot)
+		return 0;
+
+	plot->addFunction(formula, xl, xr, yl, yr, zl, zr, columns, rows);
+	plot->setDataColorMap(d_3D_color_map);
+	plot->update();
+
+	emit modified();
+	return plot;
+}
+
+Graph3D* ApplicationWindow::plotParametricSurface(const QString& xFormula, const QString& yFormula,
+		const QString& zFormula, double ul, double ur, double vl, double vr,
+		int columns, int rows, bool uPeriodic, bool vPeriodic)
+{
+	Graph3D *plot = newPlot3D();
+	if(!plot)
+		return 0;
+	plot->addParametricSurface(xFormula, yFormula, zFormula, ul, ur, vl, vr,
+								columns, rows, uPeriodic, vPeriodic);
+	plot->setDataColorMap(d_3D_color_map);
+	plot->update();
+
+	emit modified();
+	return plot;
+}
+
+void ApplicationWindow::updateSurfaceFuncList(const QString& s)
+{
+	surfaceFunc.remove(s);
+	surfaceFunc.push_front(s);
+	while ((int)surfaceFunc.size() > 10)
+		surfaceFunc.pop_back();
+}
+
+Graph3D* ApplicationWindow::addRibbon(const QString& caption, const QString& formula,
+		double xl, double xr, double yl, double yr, double zl, double zr)
+{
+	Table* t = table(formula.left(formula.find("_", 0)));
+	if (!t)
+		return 0;
+
+	QString s = formula;
+	s.remove("(X)").remove("(Y)");
+	QStringList l = s.split(",");
+	if (l.size() != 2)
+		return 0;
+
+	Graph3D *plot = newPlot3D(caption);
+	if(!plot)
+		return 0;
+
+	plot->addRibbon(t, l[0], l[1], xl, xr, yl, yr, zl, zr);
+	plot->setDataColorMap(d_3D_color_map);
+	plot->update();
+
+	return plot;
+}
+
+Graph3D* ApplicationWindow::newPlot3D(const QString& title)
+{
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	QString label = title;
+	if (label.isEmpty() || alreadyUsedName(label))
+		label = generateUniqueName(tr("Graph"));
+
+	Graph3D *plot = new Graph3D("", this, 0);
+	plot->setWindowTitle(label);
+	plot->setName(label);
+
+	initPlot3D(plot);
+
+	emit modified();
+	QApplication::restoreOverrideCursor();
+	return plot;
+}
+
+Graph3D* ApplicationWindow::plotXYZ(Table* table, const QString& zColName, int type)
+{
+	int zCol = table->colIndex(zColName);
+	if (zCol < 0)
+		return 0;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	Graph3D *plot = newPlot3D();
+	if(!plot)
+		return 0;
+
+	if (type == Graph3D::Ribbon) {
+		int ycol = table->colIndex(zColName);
+		plot->addRibbon(table, table->colName(table->colX(ycol)), zColName);
+	} else
+		plot->addData(table, table->colX(zCol), table->colY(zCol), zCol, type);
+
+	plot->setDataColorMap(d_3D_color_map);
+	plot->update();
+
+	emit modified();
+	QApplication::restoreOverrideCursor();
+	return plot;
+}
+
+void ApplicationWindow::initPlot3D(Graph3D *plot)
+{
+	if (d_mdi_windows_area)
+		d_workspace->addSubWindow(plot);
+	else
+		plot->setParent(0);
+
+	connectSurfacePlot(plot);
+
+	plot->setIcon(QPixmap(":/trajectory.png"));
+	plot->show();
+	plot->setFocus();
+
+	addListViewItem(plot);
+
+	if (!plot3DTools->isVisible())
+		plot3DTools->show();
+
+	if (!plot3DTools->isEnabled())
+		plot3DTools->setEnabled(true);
+
+	customMenu(plot);
+	customToolBars(plot);
+}
+
+void ApplicationWindow::exportMatrix(const QString& exportFilter)
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	ImageExportDialog *ied = new ImageExportDialog(m, this, d_extended_export_dialog);
+	ied->setDir(imagesDirPath);
+	ied->selectFile(m->objectName());
+	if (exportFilter.isEmpty())
+    	ied->selectFilter(d_image_export_filter);
+	else
+		ied->selectFilter(exportFilter);
+
+	if ( ied->exec() != QDialog::Accepted )
+		return;
+	imagesDirPath = ied->directory().path();
+
+	QString selected_filter = ied->selectedFilter().remove("*");
+	QString file_name = ied->selectedFiles()[0];
+	if(!file_name.endsWith(selected_filter, Qt::CaseInsensitive))
+		file_name.append(selected_filter);
+
+	if (selected_filter.contains(".eps") || selected_filter.contains(".pdf") || selected_filter.contains(".ps"))
+		m->exportVector(file_name, ied->vectorResolution(), ied->color());
+	else if (selected_filter.contains(".svg"))
+		m->exportSVG(file_name);
+#ifdef EMF_OUTPUT
+	else if (selected_filter.contains(".emf"))
+		m->exportEMF(file_name);
+#endif
+	else if (selected_filter.contains(".odf"))
+		m->exportRasterImage(file_name, ied->quality(), ied->bitmapResolution());
+	else {
+		QList<QByteArray> list = QImageWriter::supportedImageFormats();
+		for (int i=0; i<(int)list.count(); i++){
+			if (selected_filter.contains("." + (list[i]).lower()))
+				m->exportRasterImage(file_name, ied->quality(), ied->bitmapResolution());
+		}
+	}
+}
+
+Matrix* ApplicationWindow::importImage(const QString& fileName, bool newWindow)
+{
+	QString fn = fileName;
+	if (fn.isEmpty()){
+		fn = getFileName(this, tr("QtiPlot - Import image from file"), imagesDirPath, imageFilter(), 0, false);
+		if ( !fn.isEmpty() ){
+			QFileInfo fi(fn);
+			imagesDirPath = fi.dirPath(true);
+		}
+	}
+
+    QImage image(fn);
+    if (image.isNull())
+        return 0;
+
+    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+    MdiSubWindow *w = activeWindow(MatrixWindow);
+    Matrix* m = NULL;
+    if (w && !newWindow){
+        m = (Matrix *)w;
+        m->importImage(fn);
+    } else {
+        m = new Matrix(scriptEnv, image, "", this);
+        initMatrix(m, generateUniqueName(tr("Matrix")));
+        m->show();
+        m->setWindowLabel(fn);
+        m->setCaptionPolicy(MdiSubWindow::Both);
+    }
+
+    QApplication::restoreOverrideCursor();
+    return m;
+}
+
+QString ApplicationWindow::imageFilter()
+{
+	QList<QByteArray> list = QImageReader::supportedImageFormats();
+	QString filter = tr("Images") + " (", aux1, aux2;
+	for (int i = 0; i < (int)list.count(); i++){
+		aux1 = " *." + list[i] + " ";
+		aux2 += " *." + list[i] + ";;";
+		filter += aux1;
+	}
+	filter += ");;" + aux2;
+	return filter;
+}
+
+void ApplicationWindow::loadImage()
+{
+	QString fn = getFileName(this, tr("QtiPlot - Load image from file"), imagesDirPath, imageFilter(), 0, false);
+	if ( !fn.isEmpty() ){
+		loadImage(fn);
+		QFileInfo fi(fn);
+		imagesDirPath = fi.dirPath(true);
+	}
+}
+
+void ApplicationWindow::loadImage(const QString& fn)
+{
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	MultiLayer *plot = multilayerPlot(generateUniqueName(tr("Graph")));
+	plot->setWindowLabel(fn);
+	plot->setCaptionPolicy(MdiSubWindow::Both);
+
+	Graph *g = plot->activeLayer();
+	g->setTitle("");
+	for (int i=0; i<4; i++)
+		g->enableAxis(i, false);
+	g->addImage(fn);
+	QApplication::restoreOverrideCursor();
+}
+
+MultiLayer* ApplicationWindow::multilayerPlot(const QString& caption, int layers, int rows, int cols)
+{
+	MultiLayer* ml = new MultiLayer(this, layers, rows, cols);
+	initMultilayerPlot(ml, caption);
+	return ml;
+}
+
+MultiLayer* ApplicationWindow::newGraph(const QString& caption)
+{
+	MultiLayer *ml = multilayerPlot(generateUniqueName(caption));
+	if (ml){
+		Graph *g = ml->activeLayer();
+		if (g){
+			setPreferences(g);
+			g->newLegend();
+		}
+		ml->arrangeLayers(false, true);
+	}
+
+	return ml;
+}
+
+MultiLayer* ApplicationWindow::multilayerPlot(Table* w, const QStringList& colList, int style, int startRow, int endRow)
+{//used when plotting selected columns
+	if (!w)
+		return 0;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	MultiLayer* g = multilayerPlot(generateUniqueName(tr("Graph")));
+	Graph *ag = g->activeLayer();
+	if (!ag)
+		return 0;
+
+	setPreferences(ag);
+	ag->addCurves(w, colList, style, defaultCurveLineWidth, defaultSymbolSize, startRow, endRow);
+	ag->newLegend();
+
+	g->arrangeLayers(false, true);
+	QApplication::restoreOverrideCursor();
+	return g;
+}
+
+MultiLayer* ApplicationWindow::multilayerPlot(int c, int r, int style, const MultiLayer::AlignPolicy& align)
+{//used when plotting from the panel menu
+	Table *t = (Table *)activeWindow(TableWindow);
+    if (!t)
+		return 0;
+
+	if (!validFor2DPlot(t, (Graph::CurveType)style))
+		return 0;
+
+	QStringList list = t->drawableColumnSelection();
+	if((int)list.count() < 1) {
+		QMessageBox::warning(this, tr("QtiPlot - Plot error"), tr("Please select a Y column to plot!"));
+		return 0;
+	}
+
+	int curves = list.count();
+	if (r < 0)
+		r = curves;
+
+	int layers = c*r;
+	MultiLayer* g = multilayerPlot(generateUniqueName(tr("Graph")), layers, r, c);
+	QList<Graph *> layersList = g->layersList();
+	int i = 0;
+	foreach(Graph *ag, layersList){
+		setPreferences(ag);
+		if (i < curves){
+			QStringList lst = QStringList() << list[i];
+			for (int j = 0; j < curves; j++){
+				int col = t->colIndex(list[j]);
+				if (t->colPlotDesignation(col) == Table::xErr ||
+					t->colPlotDesignation(col) == Table::yErr ||
+					t->colPlotDesignation(col) == Table::Label){
+					lst << list[j];
+				}
+			}
+			ag->addCurves(t, lst, style, defaultCurveLineWidth, defaultSymbolSize);
+		}
+		i++;
+	}
+
+	if (align == MultiLayer::AlignCanvases){
+		g->setAlignPolicy(align);
+		g->setSpacing(0, 0);
+		g->setCommonLayerAxes();
+		connect(layersList.last(), SIGNAL(updatedLayout(Graph *)), g, SLOT(updateLayersLayout(Graph *)));
+	} else {
+		g->arrangeLayers(false, true);
+		foreach(Graph *ag, layersList){
+			if (ag->curveCount())
+				ag->newLegend();
+		}
+	}
+	return g;
+}
+
+MultiLayer* ApplicationWindow::waterfallPlot()
+{
+	Table *t = (Table *)activeWindow(TableWindow);
+    if (!t)
+		return 0;
+
+	return waterfallPlot(t, t->selectedYColumns());
+}
+
+MultiLayer* ApplicationWindow::waterfallPlot(Table *t, const QStringList& list)
+{
+	if (!t)
+		return 0;
+
+	int curves = list.count();
+	if(curves < 1){
+		QMessageBox::warning(this, tr("QtiPlot - Plot error"),
+		tr("Please select a Y column to plot!"));
+		return 0;
+	}
+
+	MultiLayer* ml = new MultiLayer(this, curves, 1, 1);
+	QList<Graph *> layersList = ml->layersList();
+	int i = 0;
+	foreach(Graph *g, layersList){
+		DataCurve *cv = g->insertCurve(t, list[i], Graph::Line);
+		if (cv)
+			cv->setPen(QPen(d_indexed_colors[i], defaultCurveLineWidth));
+		i++;
+	}
+	QString legend = QString();
+	initMultilayerPlot(ml, QString());
+	foreach(Graph *g, layersList){
+		g->hide();
+		legend += g->legendText(true) + "\n";
+		setPreferences(g);
+		g->setCanvasFrame(0);
+		g->setTitle(QString::null);
+		g->setMargin(0);
+		g->setFrame(0);
+		g->raise();
+	}
+
+	ml->setWaterfallLayout();
+	Graph *g = layersList.last();
+	if (g)
+		g->newLegend(legend.trimmed())->move(QPoint(5, 5));
+	return ml;
+}
+
+void ApplicationWindow::initMultilayerPlot(MultiLayer* g, const QString& name)
+{
+	QString label = name;
+	while(alreadyUsedName(label))
+		label = generateUniqueName(tr("Graph"));
+
+	g->setWindowTitle(label);
+	g->setName(label);
+	g->setIcon(QPixmap(":/graph.png"));
+	g->setScaleLayersOnPrint(d_scale_plots_on_print);
+	g->printCropmarks(d_print_cropmarks);
+
+	if (d_mdi_windows_area)
+		d_workspace->addSubWindow(g);
+	else
+		g->setParent(0);
+
+	connectMultilayerPlot(g);
+	g->showNormal();
+
+	addListViewItem(g);
+}
+
+void ApplicationWindow::setAutoUpdateTableValues(bool on)
+{
+	if (d_auto_update_table_values == on)
+		return;
+
+	d_auto_update_table_values = on;
+
+	Folder *f = projectFolder();
+	while (f){
+		QList<MdiSubWindow *> folderWindows = f->windowsList();
+		foreach(MdiSubWindow *w, folderWindows){
+            if (w->inherits("Table"))
+            	((Table *)w)->setAutoUpdateValues(d_auto_update_table_values);
+		}
+		f = f->folderBelow();
+	}
+}
+
+void ApplicationWindow::customTable(Table* w)
+{
+	QColorGroup cg;
+	cg.setColor(QColorGroup::Base, tableBkgdColor);
+	cg.setColor(QColorGroup::Text, tableTextColor);
+	w->setPalette(QPalette(cg, cg, cg));
+
+	w->setHeaderColor(tableHeaderColor);
+	w->setTextFont(tableTextFont);
+	w->setHeaderFont(tableHeaderFont);
+	w->showComments(d_show_table_comments);
+	w->setNumericPrecision(d_decimal_digits);
+}
+
+void ApplicationWindow::setPreferences(Graph* g)
+{
+	if (!g)
+		return;
+
+	if (!g->isPiePlot()){
+		for (int i = 0; i < QwtPlot::axisCnt; i++){
+			bool show = d_show_axes[i];
+			g->enableAxis(i, show);
+			if(show){
+				ScaleDraw *sd = (ScaleDraw *)g->axisScaleDraw (i);
+				sd->enableComponent(QwtAbstractScaleDraw::Labels, d_show_axes_labels[i]);
+				sd->setSpacing(d_graph_tick_labels_dist);
+				if (i == QwtPlot::yRight && !d_show_axes_labels[i])
+					g->setAxisTitle(i, tr(" "));
+			}
+		}
+
+		g->updateSecondaryAxis(QwtPlot::xTop);
+		g->updateSecondaryAxis(QwtPlot::yRight);
+
+		QList<int> ticksList;
+		ticksList<<majTicksStyle<<majTicksStyle<<majTicksStyle<<majTicksStyle;
+		g->setMajorTicksType(ticksList);
+		ticksList.clear();
+		ticksList<<minTicksStyle<<minTicksStyle<<minTicksStyle<<minTicksStyle;
+		g->setMinorTicksType(ticksList);
+
+		g->setTicksLength (minTicksLength, majTicksLength);
+		g->setAxesLinewidth(axesLineWidth);
+		g->drawAxesBackbones(drawBackbones);
+		g->setCanvasFrame(canvasFrameWidth, d_canvas_frame_color);
+		for (int i = 0; i < QwtPlot::axisCnt; i++)
+			g->setAxisTitleDistance(i, d_graph_axes_labels_dist);
+	}
+
+	g->setAxisTitlePolicy(d_graph_axis_labeling);
+	g->setSynchronizedScaleDivisions(d_synchronize_graph_scales);
+	g->initFonts(plotAxesFont, plotNumbersFont);
+	g->initTitle(titleOn, plotTitleFont);
+
+	g->setMargin(defaultPlotMargin);
+	g->enableAutoscaling(autoscale2DPlots);
+	g->setAutoscaleFonts(autoScaleFonts);
+	g->setAntialiasing(antialiasing2DPlots);
+	g->setFrame(d_graph_border_width, d_graph_border_color);
+
+	QColor c = d_graph_background_color;
+	c.setAlpha(d_graph_background_opacity);
+	g->setBackgroundColor(c);
+
+	c = d_graph_canvas_color;
+	c.setAlpha(d_graph_canvas_opacity);
+	g->setCanvasBackground(c);
+}
+
+/*
+ * return the current Plot (used for the Python interface)
+ */
+MultiLayer* ApplicationWindow::currentPlot()
+{
+	MultiLayer* p = (MultiLayer*)activeWindow(MultiLayerWindow);
+	return p;
+}
+
+/*
+ * return the current Table (used for the Python interface)
+ */
+Table* ApplicationWindow::currentTable()
+{
+	Table* w = (Table*)activeWindow(TableWindow);
+	return w;
+}
+
+/*
+ *creates a new empty table
+ */
+Table* ApplicationWindow::newTable()
+{
+	Table* w = new Table(scriptEnv, 30, 2, "", this, 0);
+	initTable(w, generateUniqueName(tr("Table")));
+	w->showNormal();
+	return w;
+}
+
+/*
+ *used when opening a project file
+ */
+Table* ApplicationWindow::newTable(const QString& caption, int r, int c)
+{
+	Table* w = new Table(scriptEnv, r, c, "", this, 0);
+	initTable(w, caption);
+	if (d_is_appending_file && w->objectName() != caption){//the table was renamed
+		renamedTables << caption << w->objectName();
+		if (d_inform_rename_table){
+			QApplication::restoreOverrideCursor();
+			QMessageBox:: warning(this, tr("QtiPlot - Renamed Window"),
+			tr("The table '%1' already exists. It has been renamed '%2'.").arg(caption).arg(w->objectName()));
+			QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+		}
+	}
+	w->showNormal();
+	return w;
+}
+
+Table* ApplicationWindow::newTable(int r, int c, const QString& name, const QString& legend)
+{
+	Table* w = new Table(scriptEnv, r, c, legend, this, 0);
+	initTable(w, name);
+	return w;
+}
+
+Table* ApplicationWindow::newHiddenTable(const QString& name, const QString& label, int r, int c, const QString& text)
+{
+	Table* w = new Table(scriptEnv, r, c, label, this, 0);
+
+	if (!text.isEmpty()) {
+		QStringList rows = text.split("\n", QString::SkipEmptyParts);
+		QStringList list = rows[0].split("\t");
+		w->setHeader(list);
+
+		QString rlist;
+		for (int i=0; i<r; i++){
+			rlist=rows[i+1];
+			list = rlist.split("\t");
+			for (int j=0; j<c; j++)
+				w->setText(i, j, list[j]);
+		}
+	}
+
+	initTable(w, name);
+	hideWindow(w);
+	return w;
+}
+
+void ApplicationWindow::initTable(Table* w, const QString& caption)
+{
+	QString name = caption;
+	name = name.replace ("_","-");
+
+	while(name.isEmpty() || alreadyUsedName(name))
+		name = generateUniqueName(tr("Table"));
+
+	if (d_mdi_windows_area)
+		d_workspace->addSubWindow(w);
+	else
+		w->setParent(0);
+
+	connectTable(w);
+	customTable(w);
+
+	w->setName(name);
+	w->setIcon(QPixmap(":/worksheet.png") );
+	addListViewItem(w);
+}
+
+/*
+ * !creates a new table with type statistics on target columns/rows of table base
+ */
+TableStatistics *ApplicationWindow::newTableStatistics(Table *base, int type, QList<int> target, const QString &caption)
+{
+	TableStatistics* s = new TableStatistics(scriptEnv, this, base, (TableStatistics::Type) type, target);
+	if (caption.isEmpty())
+		initTable(s, s->objectName());
+	else
+		initTable(s, caption);
+	s->showNormal();
+	return s;
+}
+
+/*
+ * return the current note (used for the Python interface)
+ */
+Note* ApplicationWindow::currentNote()
+{
+	Note* m = (Note*)activeWindow(NoteWindow);
+	return m;
+}
+
+/*
+ *creates a new empty note window
+ */
+Note* ApplicationWindow::newNote(const QString& caption)
+{
+	Note* m = new Note(scriptEnv, "", this);
+
+	QString name = caption;
+	while(name.isEmpty() || alreadyUsedName(name))
+		name = generateUniqueName(tr("Notes"));
+
+	m->setName(name);
+	m->setIcon(QPixmap(":/note.png"));
+	m->askOnCloseEvent(confirmCloseNotes);
+
+	if (d_mdi_windows_area)
+		d_workspace->addSubWindow(m);
+	else
+		m->setParent(0);
+
+	addListViewItem(m);
+
+	connect(m, SIGNAL(modifiedWindow(MdiSubWindow*)), this, SLOT(modifiedProject(MdiSubWindow*)));
+	connect(m, SIGNAL(resizedWindow(MdiSubWindow*)),this,SLOT(modifiedProject(MdiSubWindow*)));
+	connect(m, SIGNAL(closedWindow(MdiSubWindow*)), this, SLOT(closeWindow(MdiSubWindow*)));
+	connect(m, SIGNAL(hiddenWindow(MdiSubWindow*)), this, SLOT(hideWindow(MdiSubWindow*)));
+	connect(m, SIGNAL(statusChanged(MdiSubWindow*)), this, SLOT(updateWindowStatus(MdiSubWindow*)));
+	connect(m, SIGNAL(dirPathChanged(const QString&)), this, SLOT(scriptsDirPathChanged(const QString&)));
+	connect(m, SIGNAL(currentEditorChanged()), this, SLOT(scriptingMenuAboutToShow()));
+
+	m->showNormal();
+	return m;
+}
+
+void ApplicationWindow::connectScriptEditor(ScriptEdit *editor)
+{
+	if (!editor)
+		return;
+
+	QTextDocument *doc = editor->document();
+	actionUndo->setEnabled(doc->isUndoAvailable());
+	actionRedo->setEnabled(doc->isRedoAvailable());
+
+	connect(editor, SIGNAL(undoAvailable(bool)), actionUndo, SLOT(setEnabled(bool)));
+	connect(editor, SIGNAL(redoAvailable(bool)), actionRedo, SLOT(setEnabled(bool)));
+}
+
+/*
+ * return the current Matrix (used for the Python interface)
+ */
+Matrix* ApplicationWindow::currentMatrix()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	return m;
+}
+
+Matrix* ApplicationWindow::newMatrix(int rows, int columns)
+{
+	Matrix* m = new Matrix(scriptEnv, rows, columns, "", this, 0);
+	initMatrix(m, generateUniqueName(tr("Matrix")));
+	m->showNormal();
+	return m;
+}
+
+Matrix* ApplicationWindow::newMatrix(const QString& caption, int r, int c)
+{
+	Matrix* w = new Matrix(scriptEnv, r, c, "", this, 0);
+	initMatrix(w, caption);
+	if (d_is_appending_file && w->objectName() != caption){//the matrix was renamed
+		renamedTables << caption << w->objectName();
+		if (d_inform_rename_table){
+			QApplication::restoreOverrideCursor();
+			QMessageBox:: warning(this, tr("QtiPlot - Renamed Window"),
+			tr("The table '%1' already exists. It has been renamed '%2'.").arg(caption).arg(w->objectName()));
+			QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+		}
+	}
+
+	w->showNormal();
+	return w;
+}
+
+void ApplicationWindow::viewMatrixImage()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+	m->undoStack()->push(new MatrixSetViewCommand(m, m->viewType(), Matrix::ImageView, tr("Set Image Mode")));
+	m->setViewType(Matrix::ImageView);
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::viewMatrixTable()
+{
+	Matrix* m = static_cast<Matrix*>(activeWindow(MatrixWindow));
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+    m->undoStack()->push(new MatrixSetViewCommand(m, m->viewType(), Matrix::TableView, tr("Set Data Mode")));
+	m->setViewType(Matrix::TableView);
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::viewMatrixXY()
+{
+    Matrix* m = static_cast<Matrix*>(activeWindow(MatrixWindow));
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+    m->undoStack()->push(new MatrixSetHeaderViewCommand(m, m->headerViewType(), Matrix::XY, tr("Show X/Y")));
+	m->setHeaderViewType(Matrix::XY);
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::viewMatrixColumnRow()
+{
+    Matrix* m = static_cast<Matrix*>(activeWindow(MatrixWindow));
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+    m->undoStack()->push(new MatrixSetHeaderViewCommand(m, m->headerViewType(), Matrix::ColumnRow, tr("Show Column/Row")));
+	m->setHeaderViewType(Matrix::ColumnRow);
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::setMatrixDefaultScale()
+{
+	Matrix* m = static_cast<Matrix*>(activeWindow(MatrixWindow));
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+	m->undoStack()->push(new MatrixSetColorMapCommand(m, m->colorMapType(), m->colorMap(),
+						Matrix::Default, QwtLinearColorMap(), tr("Set Default Palette")));
+	m->setDefaultColorMap();
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::setMatrixGrayScale()
+{
+	Matrix* m = static_cast<Matrix*>(activeWindow(MatrixWindow));
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+	m->undoStack()->push(new MatrixSetColorMapCommand(m, m->colorMapType(), m->colorMap(),
+						Matrix::GrayScale, QwtLinearColorMap(), tr("Set Gray Scale Palette")));
+	m->setGrayScale();
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::setMatrixRainbowScale()
+{
+	Matrix* m = static_cast<Matrix*>(activeWindow(MatrixWindow));
+	if (!m)
+		return;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+	m->undoStack()->push(new MatrixSetColorMapCommand(m, m->colorMapType(), m->colorMap(),
+						Matrix::Rainbow, QwtLinearColorMap(), tr("Set Rainbow Palette")));
+	m->setRainbowColorMap();
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::showColorMapDialog()
+{
+	Matrix* m = static_cast<Matrix*>(activeWindow(MatrixWindow));
+	if (!m)
+		return;
+
+	ColorMapDialog *cmd = new ColorMapDialog(this);
+	cmd->setAttribute(Qt::WA_DeleteOnClose);
+	cmd->setMatrix(m);
+	cmd->exec();
+}
+
+void ApplicationWindow::transposeMatrix()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	m->transpose();
+}
+
+void ApplicationWindow::flipMatrixVertically()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	m->flipVertically();
+}
+
+void ApplicationWindow::flipMatrixHorizontally()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	m->flipHorizontally();
+}
+
+void ApplicationWindow::rotateMatrix90()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	m->rotate90();
+}
+
+void ApplicationWindow::rotateMatrixMinus90()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	m->rotate90(false);
+}
+
+void ApplicationWindow::matrixDeterminant()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	QDateTime dt = QDateTime::currentDateTime ();
+	QString info=dt.toString(Qt::LocalDate);
+	info+= "\n" + tr("Determinant of ") + QString(m->objectName()) + ":\t";
+	info+= "det = " + QString::number(m->determinant()) + "\n";
+	info+="-------------------------------------------------------------\n";
+
+	current_folder->appendLogInfo(info);
+
+	showResults(true);
+}
+
+void ApplicationWindow::invertMatrix()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return;
+
+	m->invert();
+}
+
+Table* ApplicationWindow::convertMatrixToTableDirect()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return 0;
+
+	return matrixToTable(m, Direct);
+}
+
+Table* ApplicationWindow::convertMatrixToTableXYZ()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return 0;
+
+	return matrixToTable(m, XYZ);
+}
+
+Table* ApplicationWindow::convertMatrixToTableYXZ()
+{
+	Matrix* m = (Matrix*)activeWindow(MatrixWindow);
+	if (!m)
+		return 0;
+
+	return matrixToTable(m, YXZ);
+}
+
+Table* ApplicationWindow::matrixToTable(Matrix* m, MatrixToTableConversion conversionType)
+{
+	if (!m)
+		return 0;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	int rows = m->numRows();
+	int cols = m->numCols();
+	MatrixModel *mModel = m->matrixModel();
+
+	Table* w = NULL;
+	if (conversionType == Direct){
+		w = new Table(scriptEnv, rows, cols, "", this, 0);
+		for (int i = 0; i<rows; i++){
+			for (int j = 0; j<cols; j++)
+				w->setCell(i, j, m->cell(i,j));
+		}
+	} else if (conversionType == XYZ){
+		int tableRows = rows*cols;
+		w = new Table(scriptEnv, tableRows, 3, "", this, 0);
+		for (int i = 0; i<rows; i++){
+			for (int j = 0; j<cols; j++){
+				int cell = i*cols + j;
+				w->setCell(cell, 0, mModel->x(j));
+				w->setCell(cell, 1, mModel->y(i));
+				w->setCell(cell, 2, mModel->cell(i, j));
+			}
+		}
+	} else if (conversionType == YXZ){
+		int tableRows = rows*cols;
+		w = new Table(scriptEnv, tableRows, 3, "", this, 0);
+		for (int i = 0; i<cols; i++){
+			for (int j = 0; j<rows; j++){
+				int cell = i*rows + j;
+				w->setCell(cell, 0, mModel->x(i));
+				w->setCell(cell, 1, mModel->y(j));
+				w->setCell(cell, 2, mModel->cell(i, j));
+			}
+		}
+	}
+
+
+	initTable(w, generateUniqueName(tr("Table")));
+	w->setWindowLabel(m->windowLabel());
+	w->setCaptionPolicy(m->captionPolicy());
+	w->resize(m->size());
+	w->showNormal();
+
+	QApplication::restoreOverrideCursor();
+	return w;
+}
+
+void ApplicationWindow::initMatrix(Matrix* m, const QString& caption)
+{
+	QString name = caption;
+	while(alreadyUsedName(name)){name = generateUniqueName(tr("Matrix"));}
+
+	m->setWindowTitle(name);
+	m->setName(name);
+	m->setIcon( QPixmap(":/matrix.png") );
+	m->askOnCloseEvent(confirmCloseMatrix);
+	m->setNumericPrecision(d_decimal_digits);
+
+	if (d_mdi_windows_area)
+		d_workspace->addSubWindow(m);
+	else
+		m->setParent(0);
+
+	addListViewItem(m);
+
+	QUndoStack *stack = m->undoStack();
+	connect(stack, SIGNAL(canUndoChanged(bool)), actionUndo, SLOT(setEnabled(bool)));
+	connect(stack, SIGNAL(canRedoChanged(bool)), actionRedo, SLOT(setEnabled(bool)));
+	connect(m, SIGNAL(modifiedWindow(MdiSubWindow*)), this, SLOT(modifiedProject(MdiSubWindow*)));
+	connect(m, SIGNAL(modifiedData(Matrix*)), this, SLOT(updateMatrixPlots(Matrix *)));
+	connect(m, SIGNAL(resizedWindow(MdiSubWindow*)),this,SLOT(modifiedProject(MdiSubWindow*)));
+	connect(m, SIGNAL(closedWindow(MdiSubWindow*)), this, SLOT(closeWindow(MdiSubWindow*)));
+	connect(m, SIGNAL(hiddenWindow(MdiSubWindow*)), this, SLOT(hideWindow(MdiSubWindow*)));
+	connect(m, SIGNAL(statusChanged(MdiSubWindow*)),this, SLOT(updateWindowStatus(MdiSubWindow*)));
+	connect(m, SIGNAL(showContextMenu()), this, SLOT(showWindowContextMenu()));
+
+	emit modified();
+}
+
+void ApplicationWindow::showBinMatrixDialog()
+{
+	Table* t = (Table*)activeWindow(TableWindow);
+	if (!t)
+		return;
+
+	Q3TableSelection sel = t->getSelection();
+	if (t->selectedYColumns().size() != 1 || fabs(sel.topRow() - sel.bottomRow()) < 2){
+        QMessageBox::warning(this, tr("QtiPlot - Column selection error"),
+			tr("You must select a single Y column that has an associated X column!"));
+		return;
+	}
+
+	CreateBinMatrixDialog *cbmd = new CreateBinMatrixDialog(t, sel.topRow(), sel.bottomRow(), this);
+	cbmd->exec();
+}
+
+Matrix* ApplicationWindow::convertTableToMatrixRegularXYZ()
+{
+	Table* t = (Table*)activeWindow(TableWindow);
+	if (!t)
+		return 0;
+
+	Q3TableSelection sel = t->getSelection();
+	if (t->selectedColumns().size() != 1 ||
+		t->colPlotDesignation(t->colIndex(t->selectedColumns()[0])) != Table::Z ||
+		fabs(sel.topRow() - sel.bottomRow()) < 2){
+        QMessageBox::warning(this, tr("QtiPlot - Column selection error"),
+			tr("You must select exactly one Z column!"));
+		return 0;
+	}
+
+	int zcol = t->colIndex(t->selectedColumns()[0]);
+	int ycol = t->colY(zcol);
+	int xcol = t->colX(ycol);
+
+	int cells = 0;
+	int startRow = sel.topRow();
+	int endRow = sel.bottomRow();
+	for (int i = startRow; i <= endRow; i++){
+		QString xs = t->text(i, xcol);
+		QString ys = t->text(i, ycol);
+		QString zs = t->text(i, zcol);
+		if (!xs.isEmpty() && !ys.isEmpty() && !zs.isEmpty())
+			cells++;
+	}
+
+	if (!cells)
+		return 0;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	QLocale locale = this->locale();
+	bool xVariesFirst = false;
+	int firstValidRow = sel.topRow();
+	double x0 = 0.0, y0 = 0.0, xstart = 0.0, ystart = 0.0;
+	double tolerance = 0.15;
+	for (int i = startRow; i <= endRow; i++){
+		QString xs = t->text(i, xcol);
+		QString ys = t->text(i, ycol);
+		QString zs = t->text(i, zcol);
+		if (!xs.isEmpty() && !ys.isEmpty() && !zs.isEmpty()){
+			x0 = locale.toDouble(xs);
+			y0 = locale.toDouble(ys);
+			xstart = x0;
+			ystart = y0;
+			firstValidRow = i;
+
+			for (int j = i + 1; j <= endRow; j++){
+				xs = t->text(j, xcol);
+				ys = t->text(j, ycol);
+				zs = t->text(j, zcol);
+				if (!xs.isEmpty() && !ys.isEmpty() && !zs.isEmpty()){
+					double x = locale.toDouble(xs);
+					double y = locale.toDouble(ys);
+					if (fabs(x - x0) > tolerance*x0 && fabs(y - y0) <= tolerance*y0)
+						xVariesFirst = true;
+					break;
+				}
+			}
+			break;
+		}
+	}
+
+	int rows = 0;
+	int cols = 0;
+	for (int i = firstValidRow; i <= endRow; i++){
+		QString xs = t->text(i, xcol);
+		QString ys = t->text(i, ycol);
+		QString zs = t->text(i, zcol);
+		if (!xs.isEmpty() && !ys.isEmpty() && !zs.isEmpty()){
+			double x = locale.toDouble(xs);
+			double y = locale.toDouble(ys);
+			if (xVariesFirst){
+				if (fabs(y - y0) <= tolerance*y0){
+					cols++;
+					y0 = y;
+				} else
+					break;
+			} else {
+				if (fabs(x - x0) <= tolerance*x0){
+					rows++;
+					x0 = x;
+				} else
+					break;
+			}
+		}
+	}
+
+	if (rows)
+		cols = cells/rows;
+	else
+		rows = cells/cols;
+
+	double xend = xstart, yend = ystart;
+	Matrix* m = newMatrix(rows, cols);
+	for (int i = startRow; i <= endRow; i++){
+		QString xs = t->text(i, xcol);
+		QString ys = t->text(i, ycol);
+		QString zs = t->text(i, zcol);
+		if (!xs.isEmpty() && !ys.isEmpty() && !zs.isEmpty()){
+			int row = 0, col = 0;
+			if (xVariesFirst){
+				col = i%cols;
+				row = i/cols;
+			} else {
+				row = i%rows;
+				col = i/rows;
+			}
+
+			double x = locale.toDouble(xs);
+			double y = locale.toDouble(ys);
+			if (x > xend)
+				xend = x;
+			if (y > yend)
+				yend = y;
+
+			m->setCell(row, col, locale.toDouble(zs));
+		}
+	}
+
+	m->setCoordinates(QMIN(xstart, xend), QMAX(xstart, xend), QMIN(ystart, yend), QMAX(ystart, yend));
+
+	QApplication::restoreOverrideCursor();
+	return m;
+}
+
+Matrix* ApplicationWindow::convertTableToMatrix()
+{
+	Table* t = (Table*)activeWindow(TableWindow);
+	if (!t)
+		return 0;
+
+	return tableToMatrix (t);
+}
+
+Matrix* ApplicationWindow::tableToMatrix(Table* t)
+{
+	if (!t)
+		return 0;
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	int rows = t->numRows();
+	int cols = t->numCols();
+
+	Matrix* m = newMatrix(rows, cols);
+	for (int i = 0; i<rows; i++){
+		for (int j = 0; j<cols; j++)
+			m->setCell(i, j, t->cell(i, j));
+	}
+
+	m->showNormal();
+
+	QApplication::restoreOverrideCursor();
+	return m;
+}
+
+MdiSubWindow* ApplicationWindow::window(const QString& name)
+{
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach(MdiSubWindow *w, windows){
+		if (w->objectName() == name)
+			return w;
+	}
+	return  NULL;
+}
+
+Table* ApplicationWindow::table(const QString& name)
+{
+	int pos = name.find("_", 0);
+	QString caption = name.left(pos);
+
+    Folder *f = projectFolder();
+	while (f){
+		QList<MdiSubWindow *> folderWindows = f->windowsList();
+		foreach(MdiSubWindow *w, folderWindows){
+			if (w->inherits("Table") && w->objectName() == caption)
+				return (Table*)w;
+		}
+		f = f->folderBelow();
+	}
+
+	return  0;
+}
+
+Matrix* ApplicationWindow::matrix(const QString& name)
+{
+	QString caption = name;
+	if (d_is_appending_file && !renamedTables.isEmpty() && renamedTables.contains(caption)){
+		int index = renamedTables.findIndex(caption);
+		caption = renamedTables[index + 1];
+	}
+
+	Folder *f = projectFolder();
+	while (f){
+		QList<MdiSubWindow *> folderWindows = f->windowsList();
+		foreach(MdiSubWindow *w, folderWindows){
+			if (w->isA("Matrix") && w->objectName() == caption)
+				return (Matrix*)w;
+		}
+		f = f->folderBelow();
+	}
+	return  0;
+}
+
+MdiSubWindow *ApplicationWindow::activeWindow(WindowType type)
+{
+	if (!d_active_window){
+		QList<MdiSubWindow *> windows = current_folder->windowsList();
+		if (!current_folder->activeWindow() && windows.size() > 0){
+			d_active_window = windows[0];
+		} else
+			return NULL;
+	}
+
+	switch(type){
+		case NoWindow:
+		break;
+
+		case TableWindow:
+			if (d_active_window->inherits("Table"))
+				return d_active_window;
+			else
+				return NULL;
+		break;
+
+		case MatrixWindow:
+			return qobject_cast<Matrix *>(d_active_window);
+		break;
+
+		case MultiLayerWindow:
+			return qobject_cast<MultiLayer *>(d_active_window);
+		break;
+
+		case NoteWindow:
+			return qobject_cast<Note *>(d_active_window);
+		break;
+
+		case Plot3DWindow:
+			return qobject_cast<Graph3D *>(d_active_window);
+		break;
+	}
+	return d_active_window;
+}
+
+void ApplicationWindow::windowActivated(QMdiSubWindow *w)
+{
+	MdiSubWindow *window = qobject_cast<MdiSubWindow *>(w);
+	if (!window)
+		return;
+
+	if (d_active_window && d_active_window == window)
+		return;
+
+	d_active_window = window;
+
+	customToolBars(window);
+	customMenu(window);
+
+	if (d_opening_file)
+		return;
+
+	QList<MdiSubWindow *> windows = current_folder->windowsList();
+	foreach(MdiSubWindow *ow, windows){
+		if (ow != window && ow->status() == MdiSubWindow::Maximized){
+			ow->setNormal();
+			break;
+		}
+	}
+
+	Folder *f = window->folder();
+	if (f)
+		f->setActiveWindow(window);
+
+	emit modified();
+}
+
+void ApplicationWindow::addErrorBars()
+{
+	MdiSubWindow *w = activeWindow(MultiLayerWindow);
+    if (!w)
+		return;
+
+	MultiLayer* plot = (MultiLayer*)w;
+	if (plot->isEmpty()){
+		QMessageBox::warning(this,tr("QtiPlot - Warning"),
+				tr("<h4>There are no plot layers available in this window.</h4>"
+					"<p><h4>Please add a layer and try again!</h4>"));
+		return;
+	}
+
+	Graph* g = (Graph*)plot->activeLayer();
+	if (!g)
+        return;
+
+    if (!g->curveCount()){
+		QMessageBox::warning(this, tr("QtiPlot - Warning"), tr("There are no curves available on this plot!"));
+		return;
+	}
+
+	if (g->isPiePlot()){
+        QMessageBox::warning(this, tr("QtiPlot - Warning"), tr("This functionality is not available for pie plots!"));
+        return;
+	}
+
+    ErrDialog* ed = new ErrDialog(this);
+    connect (ed, SIGNAL(options(const QString&, int, double, int)), this, SLOT(defineErrorBars(const QString&, int, double, int)));
+    connect (ed, SIGNAL(options(const QString&, const QString&, int)), this, SLOT(defineErrorBars(const QString&, const QString&, int)));
+
+    ed->setCurveNames(g->analysableCurvesList());
+    ed->setSrcTables(tableList());
+    ed->exec();
+}
+
+void ApplicationWindow::defineErrorBars(const QString& name, int type, double percent, int direction)
+{
+    MdiSubWindow *w = activeWindow(MultiLayerWindow);
+    if (!w)
+		return;
+
+	Graph* g = ((MultiLayer*)w)->activeLayer();
+	if (!g)
+		return;
+
+	Table *t = table(name);
+	if (!t){//user defined function
+		QMessageBox::critical(this, tr("QtiPlot - Error bars error"),
+				tr("This feature is not available for user defined function curves!"));
+		return;
+	}
+
+	DataCurve *master_curve = (DataCurve *)g->curve(name);
+	QString xColName = master_curve->xColumnName();
+	if (xColName.isEmpty())
+		return;
+
+	if (direction == QwtErrorPlotCurve::Horizontal)
+		t->addCol(Table::xErr);
+	else
+		t->addCol(Table::yErr);
+
+	int r = master_curve->dataSize();
+	int rows = t->numRows();
+	int c = t->numCols() - 1;
+	int ycol = t->colIndex(name);
+	if (!direction)
+		ycol = t->colIndex(xColName);
+
+	QVarLengthArray<double> Y(r);
+	if (direction == QwtErrorPlotCurve::Horizontal){
+		for (int i = 0; i < r; i++)
+			Y[i] = master_curve->x(i);
+	} else {
+		for (int i = 0; i < r; i++)
+			Y[i] = master_curve->y(i);
+	}
+
+	QString errColName = t->colName(c);
+
+	if (type == 0){
+        double prc = 0.01*percent;
+		int aux = 0;
+		for (int i = 0; i < rows; i++){
+			if (!t->text(i, ycol).isEmpty() && aux < r){
+				t->setCell(i, c, Y[aux]*prc);
+				aux++;
+			}
+		}
+	} else if (type == 1) {
+		double sd = gsl_stats_sd(Y.data(), 1, r);
+		for (int i = 0; i < rows; i++){
+			if (!t->text(i, ycol).isEmpty())
+				t->setCell(i, c, sd);
+		}
+	}
+	QwtErrorPlotCurve *er = g->addErrorBars(xColName, name, t, errColName, direction);
+	if (er){
+		er->setColor(master_curve->pen().color());
+		g->replot();
+		emit modified();
+	}
+}
+
+void ApplicationWindow::defineErrorBars(const QString& curveName, const QString& errColumnName, int direction)
+{
+	Table *w = table(curveName);
+	if (!w){//user defined function --> no worksheet available
+		QMessageBox::critical(this,tr("QtiPlot - Error"),
+				tr("This feature is not available for user defined function curves!"));
+		return;
+	}
+
+	Table *errTable = table(errColumnName);
+	if (w->numRows() != errTable->numRows()){
+		QMessageBox::critical(this,tr("QtiPlot - Error"),  tr("The selected columns have different numbers of rows!"));
+		addErrorBars();
+		return;
+	}
+
+	int errCol = errTable->colIndex(errColumnName);
+	if (errTable->isEmptyColumn(errCol)){
+		QMessageBox::critical(this, tr("QtiPlot - Error"), tr("The selected error column is empty!"));
+		addErrorBars();
+		return;
+	}
+
+	MultiLayer *plot = (MultiLayer *)activeWindow(MultiLayerWindow);
+    if (!plot)
+		return;
+
+	Graph* g = plot->activeLayer();
+	if (!g)
+		return;
+
+	QwtErrorPlotCurve *er = g->addErrorBars(curveName, errTable, errColumnName, direction);
+	if (er){
+		DataCurve *mc = er->masterCurve();
+		if (mc){
+			er->setColor(mc->pen().color());
+			g->replot();
+		}
+		emit modified();
+	}
+}
+
+void ApplicationWindow::removeCurves(const QString& name)
+{
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach(MdiSubWindow *w, windows){
+		if (w->isA("MultiLayer")){
+			QList<Graph *> layers = ((MultiLayer*)w)->layersList();
+			foreach(Graph *g, layers)
+                g->removeCurves(name);
+		} else if (w->isA("Graph3D")){
+			if ( (((Graph3D*)w)->formula()).contains(name) )
+				((Graph3D*)w)->clearData();
+		}
+	}
+	QApplication::restoreOverrideCursor();
+}
+
+void ApplicationWindow::updateCurves(Table *t, const QString& name)
+{
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach(MdiSubWindow *w, windows){
+		if (w->isA("MultiLayer")){
+			QList<Graph *> layers = ((MultiLayer*)w)->layersList();
+			foreach(Graph *g, layers)
+                g->updateCurvesData(t, name);
+		} else if (w->isA("Graph3D")){
+			Graph3D* g = (Graph3D*)w;
+			if ((g->formula()).contains(name))
+				g->updateData(t);
+		}
+	}
+}
+
+void ApplicationWindow::showPreferencesDialog()
+{
+	ConfigDialog* cd = new ConfigDialog(this);
+	cd->setColumnSeparator(columnSeparator);
+	cd->exec();
+}
+
+void ApplicationWindow::setSaveSettings(bool autoSaving, int min)
+{
+	if (autoSave==autoSaving && autoSaveTime==min)
+		return;
+
+	autoSave=autoSaving;
+	autoSaveTime=min;
+
+	killTimer(savingTimerId);
+
+	if (autoSave)
+		savingTimerId=startTimer(autoSaveTime*60000);
+	else
+		savingTimerId=0;
+}
+
+void ApplicationWindow::changeAppStyle(const QString& s)
+{
+	// style keys are case insensitive
+	if (appStyle.toLower() == s.toLower())
+		return;
+
+	qApp->setStyle(s);
+	appStyle = qApp->style()->objectName();
+
+	QPalette pal = qApp->palette();
+	pal.setColor (QPalette::Active, QPalette::Base, QColor(panelsColor));
+	qApp->setPalette(pal);
+
+}
+
+void ApplicationWindow::changeAppFont(const QFont& f)
+{
+	if (appFont == f)
+		return;
+
+	appFont = f;
+	updateAppFonts();
+}
+
+void ApplicationWindow::updateAppFonts()
+{
+	qApp->setFont(appFont);
+	this->setFont(appFont);
+	info->setFont(QFont(appFont.family(), 2 + appFont.pointSize(), QFont::Bold,false));
+}
+
+void ApplicationWindow::updateConfirmOptions(bool askTables, bool askMatrices, bool askPlots2D,
+		bool askPlots3D, bool askNotes)
+{
+	QList<MdiSubWindow *> windows = windowsList();
+
+
+	if (confirmCloseTable != askTables){
+		confirmCloseTable=askTables;
+		foreach(MdiSubWindow *w, windows){
+			if (w->inherits("Table"))
+				w->askOnCloseEvent(confirmCloseTable);
+		}
+	}
+
+	if (confirmCloseMatrix != askMatrices){
+		confirmCloseMatrix = askMatrices;
+		foreach(MdiSubWindow *w, windows){
+			if (w->isA("Matrix"))
+				w->askOnCloseEvent(confirmCloseMatrix);
+		}
+	}
+
+	if (confirmClosePlot2D != askPlots2D){
+		confirmClosePlot2D=askPlots2D;
+		foreach(MdiSubWindow *w, windows){
+			if (w->isA("MultiLayer"))
+				w->askOnCloseEvent(confirmClosePlot2D);
+		}
+	}
+
+	if (confirmClosePlot3D != askPlots3D){
+		confirmClosePlot3D=askPlots3D;
+		foreach(MdiSubWindow *w, windows){
+			if (w->isA("Graph3D"))
+				w->askOnCloseEvent(confirmClosePlot3D);
+		}
+	}
+
+	if (confirmCloseNotes != askNotes){
+		confirmCloseNotes = askNotes;
+		foreach(MdiSubWindow *w, windows){
+			if (w->isA("Note"))
+				w->askOnCloseEvent(confirmCloseNotes);
+		}
+	}
+}
+
+void ApplicationWindow::setGraphDefaultSettings(bool autoscale, bool scaleFonts,
+												bool resizeLayers, bool antialiasing)
+{
+	if (autoscale2DPlots == autoscale &&
+		autoScaleFonts == scaleFonts &&
+		autoResizeLayers != resizeLayers &&
+		antialiasing2DPlots == antialiasing)
+		return;
+
+	autoscale2DPlots = autoscale;
+	autoScaleFonts = scaleFonts;
+	autoResizeLayers = !resizeLayers;
+	antialiasing2DPlots = antialiasing;
+
+	QList<MdiSubWindow *> windows = windowsList();
+	foreach(MdiSubWindow *w, windows){
+		if (w->isA("MultiLayer")){
+			((MultiLayer*)w)->setScaleLayersOnResize(autoResizeLayers);
+			QList<Graph *> layers = ((MultiLayer*)w)->layersList();
+			foreach(Graph *g, layers){
+				g->enableAutoscaling(autoscale2DPlots);
+				g->updateScale();
+				g->setAutoscaleFonts(autoScaleFonts);
+				g->setAntialiasing(antialiasing2DPlots);
+			}
+		}
+	}
+}
+
+void ApplicationWindow::setArrowDefaultSettings(double lineWidth,  const QColor& c, Qt::PenStyle style,
+		int headLength, int headAngle, bool fillHead)
+{
+	if (defaultArrowLineWidth == lineWidth &&
+		defaultArrowColor == c &&
+		defaultArrowLineStyle == style &&
+		defaultArrowHeadLength == headLength &&
+		defaultArrowHeadAngle == headAngle &&
+		defaultArrowHeadFill == fillHead)
+		return;
+
+	defaultArrowLineWidth = lineWidth;
+	defaultArrowColor = c;
+	defaultArrowLineStyle = style;
+	defaultArrowHeadLength = headLength;
+	defaultArrowHeadAngle = headAngle;
+	defaultArrowHeadFill = fillHead;
+	saveSettings();
+}
+
+ApplicationWindow * ApplicationWindow::plotFile(const QString& fn)
+{
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+	ApplicationWindow *app = new ApplicationWindow();
+	app->restoreApplicationGeometry();
+
+    QList<QByteArray> lst = QImageReader::supportedImageFormats() << "JPG";
+    QStringList tempList;
+    foreach(QByteArray temp,lst)// convert QList<QByteArray> to QStringList to be able to 'filter'
+        tempList.append(QString(temp));
+
+    QFileInfo fi(fn);
+    QStringList l = tempList.filter(fi.suffix(), Qt::CaseInsensitive);
+    if (l.count() > 0)
+        app->importImage(fn);
+    else {
+        Table* t = app->newTable();
+        if (!t) {
+            QApplication::restoreOverrideCursor();
+            return NULL;
+        }
+        t->importASCII(fn, app->columnSeparator, 0, app->renameColumns, app->strip_spaces, app->simplify_spaces,
+                app->d_ASCII_import_comments, app->d_ASCII_comment_string,
+				app->d_ASCII_import_read_only, Table::Overwrite, app->d_ASCII_import_locale, app->d_ASCII_end_line);
+        t->setCaptionPolicy(MdiSubWindow::Both);
+        app->multilayerPlot(t, t->YColumns(), defaultCurveStyle);
+    }
+
+	QApplication::restoreOverrideCursor();
+    savedProject();//force saved state
+    close();
+	return app;
+}
+
+Table * ApplicationWindow::importOdfSpreadsheet(const QString& fileName, int sheet)
+{
+#ifdef ODS_IMPORT
+	QString fn = fileName;
+	if (fn.isEmpty()){
+		fn = getFileName(this, tr("Open ODF Spreadsheet File"), QString::null, "*.ods", 0, false);
+		if (fn.isEmpty())
+			return NULL;
+	}
+
+	QuaZipFile file(fn, "content.xml");
+	if(!file.open(QIODevice::ReadOnly)){
+		QMessageBox::critical(this, tr("QtiPlot"), tr("Couldn't open file %1").arg(fn));
+		return NULL;
+	}
+	QTemporaryFile out;
+	if (out.open()){
+		char c;
+		while(file.getChar(&c))
+			out.putChar(c);
+		out.close();
+	}
+	file.close();
+
+	OdsFileHandler handler(this, fn);
+	QXmlSimpleReader reader;
+	reader.setContentHandler(&handler);
+	reader.setErrorHandler(&handler);
+
+	QXmlInputSource xmlInputSource(&out);
+	if (reader.parse(xmlInputSource)){
+		int sheets = handler.sheetsCount();
+		if (sheet > sheets){
+			QMessageBox::critical(this, tr("QtiPlot"), tr("File %1 contains only %2 sheets!").arg(fn).arg(sheets));
+		} else if (sheet > 0){
+			Table *aux = NULL;
+			for (int i = 0; i < sheets; i++){
+				Table *t = handler.sheet(i);
+				if (i == sheet - 1)
+					aux = t;
+				else {
+					t->askOnCloseEvent(false);
+					t->close();
+				}
+			}
+			return aux;
+		}
+		return handler.sheet(sheets - 1);
+	}
+	return NULL;
+#else
+	QMessageBox::critical(this, tr("QtiPlot"), tr("QtiPlot was built without ODF spreadsheet support!"));
+	return NULL;
+#endif
+}
+
+Table * ApplicationWindow::importExcel(const QString& fileName, int sheet)
+{
+#ifdef XLS_IMPORT
+	QString fn = fileName;
+	if (fn.isEmpty()){
+		fn = getFileName(this, tr("Open Excel File"), QString::null, "*.xls", 0, false);
+		if (fn.isEmpty())
+			return NULL;
+	}
+
+	// open workbook, choose standard conversion
+	xlsWorkBook* pWB = xls_open(fn.toAscii().data(), "iso-8859-15//TRANSLIT");
+	if (!pWB)
+		return NULL;
+
+	if (sheet > 0 && sheet > pWB->sheets.count){
+		QMessageBox::critical(this, tr("QtiPlot"), tr("File %1 contains only %2 sheets, operation aborted!").arg(fn).arg(pWB->sheets.count));
+		return NULL;
+	}
+
+	Table *table = NULL;
+	for (int i = 0; i < pWB->sheets.count; i++){// process all sheets
+		int currentSheet = i + 1;
+		if (sheet > 0 && sheet != currentSheet)
+			continue;
+
+		xlsWorkSheet* pWS = xls_getWorkSheet(pWB, i);// open and parse the sheet
+		xls_parseWorkSheet(pWS);
+
+		int rows = pWS->rows.lastrow + 1;
+		int cols = pWS->rows.lastcol;
+		if (rows == 1 && !cols){
+			if (sheet > 0 && sheet == currentSheet){
+				QMessageBox::critical(this, tr("QtiPlot"), tr("Sheet %1 is empty, operation aborted!").arg(sheet));
+				return NULL;
+			} else
+				continue;
+		}
+
+		table = newTable(rows, cols, QString::null, fn + ", " + tr("sheet") + ": " + QString(pWB->sheets.sheet[i].name));
+		QDate d1(1899, 12, 30);//start date in Excel files see(http://sc.openoffice.org/excelfileformat.pdf)
+		QTime t1(0, 0);
+		double daySeconds = 24*60*60;
+		for (int t = 0; t <= pWS->rows.lastrow; t++){// process all rows of the sheet
+			struct st_row::st_row_data* row = &pWS->rows.row[t];
+			for (int tt = 0; tt <= pWS->rows.lastcol; tt++){
+				st_cell::st_cell_data cell = row->cells.cell[tt];
+				if (!cell.ishiden){
+					// display the colspan as only one cell, but reject rowspans (they can't be converted to CSV)
+					if (cell.rowspan > 1){
+						printf("%d,%d: rowspan=%i", tt, t, cell.rowspan);
+						continue;
+					}
+					// display the value of the cell (either numeric or string)
+					if (cell.id == 0x0BD){ // number
+						if (table->columnType(tt) == Table::Date){
+							QDate d2 = d1.addDays(cell.d);
+							table->setText(t, tt, d2.toString("dd.MM.yyyy"));
+						} else if (table->columnType(tt) == Table::Time){
+							QTime t2 = t1.addSecs(qRound(cell.d*daySeconds));
+							table->setText(t, tt, t2.toString("hh:mm:ss"));
+						} else
+							table->setCell(t, tt, cell.d);
+					} else if (cell.id == 0x27e){//date
+						QDate d2 = d1.addDays(cell.d);
+						table->setDateFormat("dd.MM.yyyy", tt, false);
+						table->setText(t, tt, d2.toString("dd.MM.yyyy"));
+					} else if (cell.id == 0x203){//time
+						table->setTimeFormat("hh:mm:ss", tt, false);
+						QTime t2 = t1.addSecs(qRound(cell.d*daySeconds));
+						table->setText(t, tt, t2.toString("hh:mm:ss"));
+					} else if (cell.id == 0x06 && cell.l == 0)//formula
+						table->setCell(t, tt, cell.d);
+					else if (cell.str != NULL)
+						table->setText(t, tt, QString(cell.str));
+				}
+			}
+		}
+		table->showNormal();
+
+		if (sheet > 0 && sheet == currentSheet)
+			break;
+	}
+	xls_close(pWB);
+
+	updateRecentProjectsList(fn);
+	return table;
+#else
+	QMessageBox::critical(this, tr("QtiPlot"), tr("QtiPlot was built without libxls support!"));
+	return NULL;
+#endif
+}
+
+Table * ApplicationWindow::importWaveFile()
+{
+	QString fn = getFileName(this, tr("Open File"), QString::null, "*.wav", 0, false);
+	if (fn.isEmpty())
+		return NULL;
+
+	QString log = QDateTime::currentDateTime ().toString(Qt::LocalDate) + " - ";
+	log += tr("Imported sound file") + ": " + fn + "\n";
+	ifstream file(fn, ios::in | ios::binary);
+
+	file.seekg(4, ios::beg);
+	int chunkSize;
+	file.read( (char*) &chunkSize, 4 ); // read the ChunkSize
+
+	file.seekg(16, ios::beg);
+	int	subChunk1Size;
+	file.read( (char*) &subChunk1Size, 4 ); // read the SubChunk1Size
+
+	short format;
+	file.read( (char*) &format, sizeof(short) ); // read the file format.  This should be 1 for PCM
+	log += tr("Format") + ": ";
+	if (format != 1){
+		QMessageBox::information(this, tr("QtiPlot"),
+		tr("This is not a PCM type WAV file, operation aborted!"));
+		log +=  QString::number(format) + "\n";
+		showResults(log, true);
+		return NULL;
+	} else
+		log += tr("PCM") + "\n";
+
+	short channels;
+	file.read( (char*) &channels, sizeof(short) ); // read the # of channels (1 or 2)
+	QStringList header;
+	if (channels == 2)
+		header << tr("Time") << tr("Left") << tr("Right");
+	else if (channels == 1)
+		header << tr("Time") << tr("Data");
+	log += tr("Channels") + ": " + QString::number(channels) + "\n";
+
+	int sampleRate;
+	file.read( (char*) &sampleRate, sizeof(int) );
+	log += tr("Sample Rate") + ": " + QString::number(sampleRate) + "\n";
+
+	int byteRate;
+	file.read( (char*) &byteRate, sizeof(int) );
+	log += tr("Byte Rate") + ": " + QString::number(byteRate) + "\n";
+
+	short blockAlign;
+	file.read( (char*) &blockAlign, sizeof(short) );
+	log += tr("Block Align") + ": " + QString::number(blockAlign) + "\n";
+
+	short bitsPerSample;
+	file.read( (char*) &bitsPerSample, sizeof(short) );
+	log += tr("Bits Per Sample") + ": " + QString::number(bitsPerSample) + "\n";
+	log += "__________________________________\n";
+	showResults(log, true);
+
+	int rows = (chunkSize - 36)/blockAlign;
+	Table *t = newTable(rows, int(channels + 1), QFileInfo(fn).baseName(), fn);
+	if (!t)
+		return NULL;
+
+	t->setHeader(header);
+
+	file.seekg(44, ios::beg);
+
+	double dt = 1.0/(double)sampleRate;
+	int aux = 1;
+	if (bitsPerSample == 8){
+		if (channels == 2)
+			file.seekg(46, ios::beg);//???Why???
+		int size = 1;
+		uchar ch;
+		while(!file.eof()){
+			int i = aux - 1;
+			t->setCell(i, 0, dt*aux);
+			for (int j = 1; j <= channels; j++){
+				file.read((char*) &ch, size);
+				t->setText(i, j, QString::number(ch));
+			}
+			aux++;
+		}
+	} else if (bitsPerSample == 16){
+		int size = sizeof(short);
+		short ch;
+		while(!file.eof()){
+			int i = aux - 1;
+			t->setCell(i, 0, dt*aux);
+			for (int j = 1; j <= channels; j++){
+				file.read((char*) &ch, size);
+				t->setText(i, j, QString::number(ch));
+			}
+			aux++;
+		}
+	}
+
+	file.close();
+	t->show();
+	return t;
+}
+
+void ApplicationWindow::importASCII()
+{
+	ImportASCIIDialog *import_dialog = new ImportASCIIDialog(!activeWindow(TableWindow) && !activeWindow(MatrixWindow), this, d_extended_import_ASCII_dialog);
+	import_dialog->setDirectory(asciiDirPath);
+	import_dialog->selectFilter(d_ASCII_file_filter);
+	if (d_import_ASCII_dialog_size.isValid())
+		import_dialog->resize(d_import_ASCII_dialog_size);
+	if (import_dialog->exec() != QDialog::Accepted)
+		return;
+
+	asciiDirPath = import_dialog->directory().path();
+    d_ASCII_import_mode = import_dialog->importMode();
+    columnSeparator = import_dialog->columnSeparator();
+    ignoredLines = import_dialog->ignoredLines();
+    renameColumns = import_dialog->useFirstRow();
+    strip_spaces = import_dialog->stripSpaces();
+    simplify_spaces = import_dialog->simplifySpaces();
+    d_ASCII_import_locale = import_dialog->decimalSeparators();
+    d_ASCII_comment_string = import_dialog->commentString();
+    d_ASCII_import_comments = import_dialog->useSecondRow();
+    d_ASCII_import_read_only = import_dialog->readOnly();
+	d_ASCII_end_line = (EndLineChar)import_dialog->endLineChar();
+    saveSettings();
+
+	importASCII(import_dialog->selectedFiles(),
+			import_dialog->importMode(),
+			import_dialog->columnSeparator(),
+			import_dialog->ignoredLines(),
+			import_dialog->renameColumns(),
+			import_dialog->stripSpaces(),
+			import_dialog->simplifySpaces(),
+			import_dialog->importComments(),
+			import_dialog->decimalSeparators(),
+			import_dialog->commentString(),
+			import_dialog->readOnly(),
+			import_dialog->endLineChar(),
+			import_dialog->columnTypes());
+}
+
+void ApplicationWindow::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_import_comments, QLocale local_separators, const QString& local_comment_string,
+		bool import_read_only, int endLineChar, const QList<int>& colTypes)
+{
+	if (files.isEmpty())
+		return;
+
+	switch(import_mode) {
+		case ImportASCIIDialog::NewTables:
+			{
+				int dx = 0, dy = 0;
+				QStringList sorted_files = files;
+				sorted_files.sort();
+				int filesCount = sorted_files.size();
+				for (int i=0; i<filesCount; i++){
+					Table *w = newTable();
+					if (!w)
+						continue;
+
+					w->importASCII(sorted_files[i], local_column_separator, local_ignored_lines,
+                                   local_rename_columns, local_strip_spaces, local_simplify_spaces,
+                                   local_import_comments, local_comment_string, import_read_only,
+								   Table::Overwrite, local_separators, endLineChar, -1, colTypes);
+					if (!w) continue;
+					w->setWindowLabel(sorted_files[i]);
+					w->setCaptionPolicy(MdiSubWindow::Both);
+
+					QString name = QFileInfo(sorted_files[i]).baseName();
+					if (!alreadyUsedName(name) && !name.contains(QRegExp("\\W")))
+						setWindowName(w, name);
+
+					if (i == 0){
+						dx = w->verticalHeaderWidth();
+						dy = w->frameGeometry().height() - w->widget()->height();
+					}
+					if (filesCount > 1)
+						w->move(QPoint(i*dx, i*dy));
+				}
+				modifiedProject();
+				break;
+			}
+        case ImportASCIIDialog::NewMatrices:
+			{
+				int dx = 0, dy = 0;
+				QStringList sorted_files = files;
+				sorted_files.sort();
+				int filesCount = sorted_files.size();
+				for (int i=0; i<filesCount; i++){
+					Matrix *w = newMatrix();
+					if (!w)
+                        continue;
+					w->importASCII(sorted_files[i], local_column_separator, local_ignored_lines,
+                                local_strip_spaces, local_simplify_spaces, local_comment_string,
+								Matrix::Overwrite, local_separators, endLineChar);
+					w->setWindowLabel(sorted_files[i]);
+					w->setCaptionPolicy(MdiSubWindow::Both);
+
+					QString name = QFileInfo(sorted_files[i]).baseName();
+					if (!alreadyUsedName(name) && !name.contains(QRegExp("\\W")))
+						setWindowName(w, name);
+
+					if (i == 0){
+						dx = w->verticalHeaderWidth();
+						dy = w->frameGeometry().height() - w->widget()->height();
+					}
+					if (filesCount > 1)
+						w->move(QPoint(i*dx,i*dy));
+				}
+				modifiedProject();
+				break;
+			}
+
+		case ImportASCIIDialog::NewColumns:
+		case ImportASCIIDialog::NewRows:
+			{
+				MdiSubWindow *w = activeWindow();
+				if (!w)
+                    return;
+
+				if (w->inherits("Table")){
+					Table *t = (Table*)w;
+					for (int i = 0; i < files.size(); i++){
+                        t->importASCII(files[i], local_column_separator, local_ignored_lines, local_rename_columns,
+							local_strip_spaces, local_simplify_spaces, local_import_comments,
+							local_comment_string, import_read_only, (Table::ImportMode)(import_mode - 2),
+							local_separators, endLineChar, -1, colTypes);
+					}
+					t->notifyChanges();
+					emit modifiedProject(t);
+				} else if (w->isA("Matrix")){
+					Matrix *m = (Matrix *)w;
+					for (int i=0; i<files.size(); i++){
+						m->importASCII(files[i], local_column_separator, local_ignored_lines,
+                         local_strip_spaces, local_simplify_spaces, local_comment_string,
+						 (Matrix::ImportMode)(import_mode - 2), local_separators, endLineChar);
+					}
+				}
+				w->setWindowLabel(files.join("; "));
+				w->setCaptionPolicy(MdiSubWindow::Name);
+				break;
+			}
+		case ImportASCIIDialog::Overwrite:
+			{
+				MdiSubWindow *w = activeWindow();
+				if (!w)
+                    return;
+
+				if (w->inherits("Table")){
+				    Table *t = (Table *)w;
+					t->importASCII(files[0], local_column_separator, local_ignored_lines, local_rename_columns,
+                                    local_strip_spaces, local_simplify_spaces, local_import_comments,
+									local_comment_string, import_read_only, Table::Overwrite, local_separators, endLineChar, -1, colTypes);
+					t->notifyChanges();
+				} else if (w->isA("Matrix")){
+				    Matrix *m = (Matrix *)w;
+					m->importASCII(files[0], local_column_separator, local_ignored_lines,
+                          local_strip_spaces, local_simplify_spaces, local_comment_string,
+						  Matrix::Overwrite, local_separators, endLineChar);
+				}
+
+                w->setWindowLabel(files[0]);
+				w->setCaptionPolicy(MdiSubWindow::Both);
+
+				QString name = QFileInfo(files[0]).baseName();
+				if (!alreadyUsedName(name) && !name.contains(QRegExp("\\W")))
+					setWindowName(w, name);
+
+                modifiedProject();
+				break;
+			}
+	}
+}
+
+void ApplicationWindow::open()
+{
+	if (showSaveProjectMessage() == QMessageBox::Cancel)
+		return;
+
+	OpenProjectDialog *open_dialog = new OpenProjectDialog(this, d_extended_open_dialog);
+	open_dialog->setDirectory(workingDir);
+
+	if (open_dialog->exec() != QDialog::Accepted || open_dialog->selectedFiles().isEmpty())
+		return;
+	workingDir = open_dialog->directory().path();
+
+	switch(open_dialog->openMode()) {
+		case OpenProjectDialog::NewProject:
+			{
+				QString fn = open_dialog->selectedFiles()[0];
+				QFileInfo fi(fn);
+
+				if (projectname != "untitled"){
+					QFileInfo fi(projectname);
+					QString pn = fi.absFilePath();
+					if (fn == pn){
+						QMessageBox::warning(this, tr("QtiPlot - File openning error"),
+								tr("The file: <b>%1</b> is the current file!").arg(fn));
+						return;
+					}
+				}
+
+				if (!fi.exists ()){
+					QMessageBox::critical(this, tr("QtiPlot - File openning error"),
+					tr("The file: <b>%1</b> doesn't exist!").arg(fn));
+					return;
+				}
+
+				saveSettings();//the recent projects must be saved
+
+				#ifdef BROWSER_PLUGIN
+				if (isProjectFile(fn))
+					closeProject();
+				open(fn, false, false);
+				#else
+				ApplicationWindow *a = open (fn);
+				if (a){
+					a->workingDir = workingDir;
+					if (isProjectFile(fn))
+						this->close();
+				}
+				#endif
+
+				break;
+			}
+		case OpenProjectDialog::NewFolder:
+			appendProject(open_dialog->selectedFiles()[0]);
+			break;
+	}
+}
+
+bool ApplicationWindow::isProjectFile(const QString& fn)
+{
+	if (fn.endsWith(".qti", Qt::CaseInsensitive) || fn.endsWith(".qti.gz", Qt::CaseInsensitive) ||
+		fn.endsWith(".qti~", Qt::CaseInsensitive) ||
+		fn.endsWith(".opj",Qt::CaseInsensitive) || fn.endsWith(".ogg",Qt::CaseInsensitive))
+		return true;
+	return false;
+}
+
+ApplicationWindow* ApplicationWindow::open(const QString& fn, bool factorySettings, bool newProject)
+{
+	QFileInfo fi(fn);
+	if (!fi.isReadable()){
+		QMessageBox::critical(this, tr("QtiPlot - File openning error"),
+		tr("You don't have the permission to open this file: <b>%1</b>").arg(fn));
+		return NULL;
+	}
+
+#ifdef OPJ_IMPORT
+	if (fn.endsWith(".opj", Qt::CaseInsensitive) || fn.endsWith(".ogm", Qt::CaseInsensitive) ||
+		fn.endsWith(".ogw", Qt::CaseInsensitive) || fn.endsWith(".ogg", Qt::CaseInsensitive))
+		return importOPJ(fn, factorySettings, newProject);
+	else
+#endif
+	if (fn.endsWith(".py", Qt::CaseInsensitive))
+		return loadScript(fn);
+	else if (fn.endsWith(".xls", Qt::CaseInsensitive)){
+		importExcel(fn);
+		return this;
+	} else if (fn.endsWith(".ods", Qt::CaseInsensitive)){
+		importOdfSpreadsheet(fn);
+		return this;
+	}
+
+	QString fname = fn;
+	if (fn.endsWith(".qti.gz", Qt::CaseInsensitive)){//decompress using zlib
+		file_uncompress((char *)fname.ascii());
+		fname = fname.left(fname.size() - 3);
+	}
+
+	QFile f(fname);
+	QTextStream t( &f );
+	f.open(QIODevice::ReadOnly);
+	QString s = t.readLine();
+	f.close();
+
+    QStringList lst = s.split(QRegExp("\\s"), QString::SkipEmptyParts);
+	bool qtiProject = (lst.count() < 2 || lst[0] != "QtiPlot") ? false : true;
+	if (!qtiProject){
+		if (QFile::exists(fname + "~")){
+            int choice = QMessageBox::question(this, tr("QtiPlot - File opening error"),
+					tr("The file <b>%1</b> is corrupted, but there exists a backup copy.<br>Do you want to open the backup instead?").arg(fn),
+					QMessageBox::Yes|QMessageBox::Default, QMessageBox::No|QMessageBox::Escape);
+            if (choice == QMessageBox::Yes)
+                return open(fname + "~");
+            else
+                QMessageBox::critical(this, tr("QtiPlot - File opening error"),  tr("The file: <b> %1 </b> was not created using QtiPlot!").arg(fn));
+            return 0;
+		}
+
+		return plotFile(fn);
+	}
+
+    QStringList vl = lst[1].split(".", QString::SkipEmptyParts);
+    d_file_version = 100*(vl[0]).toInt()+10*(vl[1]).toInt()+(vl[2]).toInt();
+
+	ApplicationWindow* app = openProject(fname, factorySettings, newProject);
+
+	f.close();
+	return app;
+}
+
+void ApplicationWindow::openRecentProject(int index)
+{
+	QString fn = recent->text(index);
+	int pos = fn.find(" ", 0);
+	fn = fn.right(fn.length() - pos - 1);
+
+	if (projectname != "untitled"){
+		QFileInfo fi(projectname);
+		QString pn = fi.absFilePath();
+
+		if (QDir::toNativeSeparators(fn) == QDir::toNativeSeparators(pn)){
+			QMessageBox::warning(this, tr("QtiPlot - File openning error"),
+					tr("The file: <p><b> %1 </b><p> is the current file!").arg(QDir::toNativeSeparators(fn)));
+			return;
+		}
+	}
+
+	if (isProjectFile(fn)){
+		if (showSaveProjectMessage() == QMessageBox::Cancel)
+			return;
+	}
+
+	QFile f(fn);
+	if (!f.exists()){
+		QMessageBox::critical(this, tr("QtiPlot - File Open Error"),
+				tr("The file: <b> %1 </b> <p>does not exist anymore!"
+					"<p>It will be removed from the list.").arg(fn));
+
+		for (int i = 0; i < recentProjects.size(); i++){
+			if (QDir::toNativeSeparators(recentProjects[i]) == fn){
+				recentProjects.removeAt(i);
+				break;
+			}
+		}
+        updateRecentProjectsList();
+		return;
+	}
+
+	if (!fn.isEmpty()){
+		saveSettings();//the recent projects must be saved
+	#ifdef BROWSER_PLUGIN
+		if (isProjectFile(fn))
+			closeProject();
+		open (fn, false, false);
+	#else
+		bool isSaved = saved;
+		ApplicationWindow * a = open (fn);
+		if (a){
+			if (isSaved)
+				savedProject();//force saved state
+			if (isProjectFile(fn))
+				close();
+			else
+				modifiedProject();
+		}
+	#endif
+	}
+}
+
+ApplicationWindow* ApplicationWindow::openProject(const QString& fn, bool factorySettings, bool newProject)
+{
+	ApplicationWindow *app = this;
+	if (newProject)
+		app = new ApplicationWindow(factorySettings);
+
+	app->projectname = fn;
+	app->d_file_version = d_file_version;
+	app->setWindowTitle(tr("QtiPlot") + " - " + fn);
+	app->d_opening_file = true;
+	app->d_workspace->blockSignals(true);
+
+	QFile f(fn);
+	QTextStream t( &f );
+	t.setEncoding(QTextStream::UnicodeUTF8);
+	f.open(QIODevice::ReadOnly);
+
+	QFileInfo fi(fn);
+	QString baseName = fi.fileName();
+
+	t.readLine();
+	if (d_file_version < 73)
+		t.readLine();
+
+	QString s = t.readLine();