Merge lp:~valavanisalex/ubuntu/maverick/qtiplot/qtiplot-fix-605027-merge0.9.8-1 into lp:ubuntu/maverick/qtiplot

[Alex Valavanis]

Unmerged revisions

18. By Alex Valavanis on 2010-07-29

Removed debian-changes-0.9.8-1: Unnecessary

17. By Alex Valavanis on 2010-07-29

* Merge with Debian unstable (LP: #605027)
* debian/control: Fix Qt 4.7 compatibility (LP: #598826)
  + Build-Depends: libqtassistantclient-dev
  + Recommends: qt-assistant-compat
* Rm debian/patches/debian-changes-0.9.8-1: Maverick has Python 2.6
* New upstream release
* Bump standards version to 3.9.0
* Change python version to 2.6
* 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

16. By Alex Valavanis on 2010-07-28

Merging shared upstream rev into target branch.

15. By Alex Valavanis on 2010-07-28

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-29 13:54:48 +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-29 13:54:48 +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-29 13:54:48 +0000
@@ -0,0 +1,248 @@
+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)
+}
+
+# check if support for Microsoft Excel should be enabled
+win32: contains(CONFIG, Excel) {
+	CONFIG += qaxcontainer
+	DEFINES += HAS_EXCEL
+	SOURCES += src/core/ExcelImport.cpp
+}
+
+###############################################################
+
+# 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-29 13:54:48 +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-29 13:54:48 +0000
@@ -0,0 +1,18713 @@
+/***************************************************************************
+	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 <SelectionMoveResizer.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 <BaselineDialog.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
+	#include <ExcelFormat.h>
+	#include <BasicExcel.hpp>
+	using namespace ExcelFormat;
+#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_force_muParser = true;
+	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(QKeySequence(tr("Shift+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->addSeparator();
+	plotTools->addAction(actionRaiseEnrichment);
+	plotTools->addAction(actionLowerEnrichment);
+
+	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
+
+	fileMenuAboutToShow();
+	windowsMenuAboutToShow();
+
+	// 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);
+	// these use the same keyboard shortcut (Ctrl+Alt+G) and should not be enabled at the same time
+	actionExportGraph->setEnabled(false);
+	actionGoToRow->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){
+		analysisMenuAboutToShow();
+
+		actionPrintAllPlots->setEnabled(projectHas2DPlots());
+		actionPrint->setEnabled(true);
+		actionCutSelection->setEnabled(true);
+		actionCopySelection->setEnabled(true);
+		actionPasteSelection->setEnabled(true);
+		actionClearSelection->setEnabled(true);
+		actionSaveTemplate->setEnabled(true);
+		actionSaveWindow->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);
+			actionExportGraph->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);
+			actionSaveWindow->setEnabled(true);
+			actionExportGraph->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")) {
+			tableMenuAboutToShow();
+
+			plot2DMenu->menuAction()->setVisible(true);
+			analysisMenu->menuAction()->setVisible(true);
+			tableMenu->menuAction()->setVisible(true);
+
+			actionTableRecalculate->setEnabled(true);
+			actionAddColToTable->setEnabled(true);
+			actionShowColumnValuesDialog->setEnabled(true);
+			actionGoToRow->setEnabled(true);
+		} else if (qobject_cast<Matrix*>(w)){
+			matrixMenuAboutToShow();
+
+			actionTableRecalculate->setEnabled(true);
+			actionSetMatrixValues->setEnabled(true);
+			actionGoToRow->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);
+	actionSaveWindow->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;
+	}
+
+	int ycol = t->colIndex(t->selectedYColumns()[0]);
+	if (t->isEmptyColumn(ycol)){
+		QMessageBox::critical(this, tr("QtiPlot - Error"), tr("The selected Y column is empty, operation aborted!"));
+		return;
+	} else if (t->isEmptyColumn(t->colX(ycol))){
+		QMessageBox::critical(this, tr("QtiPlot - Error"), tr("The associated X column is empty, operation aborted!"));
+		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();
+        for (int i = cols - 1; i >= 0; i--){
+                if (t->isEmptyColumn(i))
+                    cols--;
+        }
+
+        if (!cols){
+            QApplication::restoreOverrideCursor();
+            QMessageBox::critical(this, tr("QtiPlot - Error"), tr("The selected table is empty, operation aborted!"));
+            return 0;
+        }
+
+	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)){
+		updateRecentProjectsList(fn);
+		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
+}
+
+#ifdef XLS_IMPORT
+void ApplicationWindow::exportExcel()
+{
+	ExportDialog *ed = showExportASCIIDialog();
+	if (ed){
+		ed->setNameFilters(QStringList() << "*.xls");
+		ed->updateAdvancedOptions(".xls");
+	}
+}
+#endif
+
+Table * ApplicationWindow::importExcel(const QString& fileName, int sheet)
+{
+	QString fn = fileName;
+	if (fn.isEmpty()){
+		QString filter = "*.xls";
+	#ifdef HAS_EXCEL
+		filter = tr("Excel files") + " (*.xl *.xlsx *.xlsm *.xlsb *.xlam *.xltx *.xltm *.xls *.xla *.xlt *.xlm *.xlw)";
+	#endif
+		fn = getFileName(this, tr("Open Excel File"), QString::null, filter, 0, false);
+		if (fn.isEmpty())
+			return NULL;
+	}
+
+#ifdef HAS_EXCEL
+	Table *t = importUsingExcel(fn, sheet);
+	if (t)
+		return t;
+#endif
+
+#ifdef XLS_IMPORT
+	return importExcelCrossplatform(fn, sheet);
+#endif
+
+	return NULL;
+}
+
+#ifdef XLS_IMPORT
+Table * ApplicationWindow::importExcelCrossplatform(const QString& fn, int sheet)
+{
+	BasicExcel xls;
+	if (!xls.Load(fn)){
+		QMessageBox::critical(this, tr("QtiPlot"), tr("Couldn't open file %1").arg(fn));
+		return 0;
+	}
+
+	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
+
+	XLSFormatManager fmt_mgr(xls);
+
+	Table *table = NULL;
+	for (size_t s = 0; s < xls.GetTotalWorkSheets(); s++){// process all sheets
+		int currentSheet = s + 1;
+		if (sheet > 0 && sheet != currentSheet)
+			continue;
+
+		BasicExcelWorksheet* sh = xls.GetWorksheet(s);
+		if (!sh)
+			continue;
+
+		int rows = sh->GetTotalRows();
+		int cols = sh->GetTotalCols();
+		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(sh->GetAnsiSheetName()));
+		QTime t1(0, 0);
+		QDate d1(1899, 12, 30);//start date in Excel files see(http://sc.openoffice.org/excelfileformat.pdf)
+		double daySeconds = 24*60*60;
+		for(size_t i = 0; i < rows; i++){
+			for(size_t j = 0; j < cols; j++){
+				BasicExcelCell* cell = sh->Cell(i, j);
+				if (!cell)
+					continue;
+
+				CellFormat fmt(fmt_mgr, cell);
+				const wstring& fmt_string = fmt.get_format_string();
+				QString fmtString = QString::fromStdWString(fmt_string);
+
+				switch(cell->Type()){
+					case BasicExcelCell::UNDEFINED:
+						continue;
+					break;
+					case BasicExcelCell::STRING:
+						table->setText(i, j, cell->GetString());
+					break;
+					case BasicExcelCell::INT:
+					case BasicExcelCell::DOUBLE:
+					case BasicExcelCell::FORMULA:
+						if (fmt_string == XLS_FORMAT_DATE || fmt_string == XLS_FORMAT_DATETIME ||
+							fmt_string == L"D-MMM-YY" || fmt_string == L"D-MMM" || fmt_string == L"MMM-YY"){// date
+
+							if (fmt_string == XLS_FORMAT_DATE || fmt_string == XLS_FORMAT_DATETIME)
+								fmtString = "dd.MM.yyyy";
+							else
+								fmtString = fmtString.replace("D", "d").replace("Y", "y");
+
+							if (table->columnType(j) != Table::Date)
+								table->setDateFormat(fmtString, j, false);
+
+							QDate d2 = d1.addDays(cell->GetDouble());
+							table->setText(i, j, d2.toString(fmtString));
+						} else if (fmt_string == XLS_FORMAT_TIME || fmt_string == L"h:mm AM/PM" ||
+								fmt_string == L"h:mm:ss AM/PM" || fmt_string == L"h:mm" ||
+								fmt_string == L"mm:ss" || fmt_string == L"[h]:mm:ss" || fmt_string == L"mm:ss.0"){
+							if (table->columnType(j) != Table::Time)
+								table->setTimeFormat(fmtString, j, false);
+
+							QTime t2 = t1.addSecs(qRound(cell->GetDouble()*daySeconds));
+							table->setText(i, j, t2.toString(fmtString));
+						} else
+							table->setCell(i, j, cell->GetDouble());
+					break;
+				}
+			}
+		}
+		table->showNormal();
+
+		if (sheet > 0 && sheet == currentSheet)
+			break;
+	}
+	xls.Close();
+	updateRecentProjectsList(fn);
+	QApplication::restoreOverrideCursor();
+	return table;
+}
+#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(),
+			import_dialog->columnFormats());
+}
+
+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, const QStringList& colFormats)
+{
+	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, colFormats);
+					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, colFormats);
+					}
+					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, colFormats);
+					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
+#ifdef HAS_EXCEL
+	if (isExcelInstalled()){
+		if (fn.endsWith(".xl", Qt::CaseInsensitive) || fn.endsWith(".xlsx", Qt::CaseInsensitive) ||
+			fn.endsWith(".xlsm", Qt::CaseInsensitive) || fn.endsWith(".xlsb", Qt::CaseInsensitive) ||
+			fn.endsWith(".xlam", Qt::CaseInsensitive) || fn.endsWith(".xltx", Qt::CaseInsensitive) ||
+			fn.endsWith(".xltm", Qt::CaseInsensitive) || fn.endsWith(".xls", Qt::CaseInsensitive) ||
+			fn.endsWith(".xla", Qt::CaseInsensitive) || fn.endsWith(".xlt", Qt::CaseInsensitive) ||
+			fn.endsWith(".xlm", Qt::CaseInsensitive) || fn.endsWith(".xlw", Qt::CaseInsensitive)){
+			importExcel(fn);
+			return this;
+		}
+	} else
+#endif
+#ifdef XLS_IMPORT
+	if (fn.endsWith(".xls", Qt::CaseInsensitive)){
+		importExcel(fn);
+		return this;
+	}
+	else
+#endif
+	if (fn.endsWith(".py", Qt::CaseInsensitive))
+		return loadScript(fn);
+	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);