diff --git a/src/cantor_part.cpp b/src/cantor_part.cpp
index d5dcf337..4944eab9 100644
--- a/src/cantor_part.cpp
+++ b/src/cantor_part.cpp
@@ -1,895 +1,896 @@
 /*
     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.
 
     ---
     Copyright (C) 2009 Alexander Rieder <alexanderrieder@gmail.com>
 */
 
 #include "cantor_part.h"
 
 #include <config-cantor.h>
 
 #include <KLocalizedString>
 #include <QIcon>
 #include <KParts/Event>
 #include <KParts/GUIActivateEvent>
 #include <KPluginFactory>
 #include <KAboutData>
 
 #include <QAction>
 #include <KActionCollection>
 #include <QFileDialog>
 #include <KStandardAction>
 #include <KZip>
 #include <KToggleAction>
 #include <KService>
 #include <KServiceTypeTrader>
 #include <KRun>
 #include <QProgressDialog>
 #include <KMessageBox>
 #include <KNS3/UploadDialog>
 
 #include <QElapsedTimer>
 #include <QFile>
 #include <QTextStream>
 #include <QTextEdit>
 #include <QTimer>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QPrintDialog>
 #include <QVBoxLayout>
 
 #include "worksheet.h"
 #include "worksheetview.h"
 #include "searchbar.h"
 #include "scripteditor/scripteditorwidget.h"
 #include "lib/backend.h"
 #include "lib/extension.h"
 #include "lib/assistant.h"
 #include "lib/panelpluginhandler.h"
 #include "lib/panelplugin.h"
 #include "lib/worksheetaccess.h"
 
 #include "settings.h"
 
 
 //A concrete implementation of the WorksheetAccesssInterface
 class WorksheetAccessInterfaceImpl : public Cantor::WorksheetAccessInterface
 {
     //Q_OBJECT
   public:
     WorksheetAccessInterfaceImpl(QObject* parent, Worksheet* worksheet) :   WorksheetAccessInterface(parent),  m_worksheet(worksheet)
     {
         qDebug()<<"new worksheetaccess interface";
         connect(worksheet, SIGNAL(sessionChanged()), this, SIGNAL(sessionChanged()));
 
     }
 
     ~WorksheetAccessInterfaceImpl() override
     {
 
     }
 
     QByteArray saveWorksheetToByteArray() Q_DECL_OVERRIDE
     {
         return m_worksheet->saveToByteArray();
     }
 
     void loadWorksheetFromByteArray(QByteArray* data) Q_DECL_OVERRIDE
     {
         m_worksheet->load(data);
     }
 
     Cantor::Session* session() Q_DECL_OVERRIDE
     {
         return m_worksheet->session();
     }
 //  public Q_SLOTS:
   void evaluate() Q_DECL_OVERRIDE
     {
         m_worksheet->evaluate();
     }
 
     void interrupt() Q_DECL_OVERRIDE
     {
         m_worksheet->interrupt();
     }
 
   private:
     Worksheet* m_worksheet;
 };
 
 CantorPart::CantorPart( QWidget *parentWidget, QObject *parent, const QVariantList & args ): KParts::ReadWritePart(parent),
     m_searchBar(nullptr),
     m_initProgressDlg(nullptr),
     m_showProgressDlg(true),
     m_showBackendHelp(nullptr),
     m_statusBarBlocked(false)
 {
     qDebug()<<"Created a CantorPart";
 
     m_panelHandler=new Cantor::PanelPluginHandler(this);
     connect(m_panelHandler, SIGNAL(pluginsChanged()), this, SLOT(pluginsChanged()));
 
     QString backendName;
     if(args.isEmpty())
         backendName=QLatin1String("null");
     else
         backendName=args.first().toString();
 
     foreach(const QVariant& arg, args)
     {
         if (arg.toString() == QLatin1String("--noprogress") )
         {
             qWarning()<<"not showing the progress bar by request";
             m_showProgressDlg=false;
         }
     }
 
     Cantor::Backend* b=Cantor::Backend::createBackend(backendName);
     if(!b)
     {
         KMessageBox::error(parentWidget, i18n("Backend %1 is not installed", backendName), i18n("Error - Cantor"));
         setWidget(new QWidget(parentWidget));
         //fake being modified so the shell won't try to reuse this part
         ReadWritePart::setModified(true);
         return;
     }
 
     qDebug()<<"Backend "<<b->name()<<" offers extensions: "<<b->extensions();
 
     QWidget* widget = new QWidget(parentWidget);
     QVBoxLayout* layout = new QVBoxLayout(widget);
     m_worksheet=new Worksheet(b, widget);
     m_worksheetview=new WorksheetView(m_worksheet, widget);
     m_worksheetview->setEnabled(false); //disable input until the session has successfully logged in and emits the ready signal
     connect(m_worksheet, SIGNAL(modified()), this, SLOT(setModified()));
     connect(m_worksheet, SIGNAL(showHelp(const QString&)), this, SIGNAL(showHelp(const QString&)));
     connect(m_worksheet, SIGNAL(sessionChanged()), this, SLOT(worksheetSessionChanged()));
     connect(actionCollection(), SIGNAL(inserted(QAction*)), m_worksheet,
             SLOT(registerShortcut(QAction*)));
 
     layout->addWidget(m_worksheetview);
     // notify the part that this is our internal widget
     setWidget(widget);
 
     Cantor::WorksheetAccessInterface* iface=new WorksheetAccessInterfaceImpl(this, m_worksheet);
     Q_UNUSED(iface);
 
     // create our actions
     m_worksheet->createActions(actionCollection());
 
     KStandardAction::saveAs(this, SLOT(fileSaveAs()), actionCollection());
     m_save = KStandardAction::save(this, SLOT(save()), actionCollection());
     m_save->setPriority(QAction::LowPriority);
 
     QAction * savePlain=new QAction(i18n("Save Plain Text"), actionCollection());
     actionCollection()->addAction(QLatin1String("file_save_plain"), savePlain);
     savePlain->setIcon(QIcon::fromTheme(QLatin1String("document-save")));
     connect(savePlain, SIGNAL(triggered()), this, SLOT(fileSavePlain()));
 
     QAction * undo=KStandardAction::undo(m_worksheet, SIGNAL(undo()),
                                         actionCollection());
     undo->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(undoAvailable(bool)),
             undo, SLOT(setEnabled(bool)));
     QAction * redo=KStandardAction::redo(m_worksheet, SIGNAL(redo()),
                                         actionCollection());
     redo->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(redoAvailable(bool)),
             redo, SLOT(setEnabled(bool)));
 
     QAction * cut=KStandardAction::cut(m_worksheet, SIGNAL(cut()),
                                       actionCollection());
     cut->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(cutAvailable(bool)),
             cut, SLOT(setEnabled(bool)));
     QAction * copy=KStandardAction::copy(m_worksheet, SIGNAL(copy()),
                                         actionCollection());
     copy->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(copyAvailable(bool)),
             copy, SLOT(setEnabled(bool)));
     QAction * paste=KStandardAction::paste(m_worksheet, SIGNAL(paste()),
                                           actionCollection());
     paste->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(pasteAvailable(bool)),
             paste, SLOT(setEnabled(bool)));
 
     QAction * find=KStandardAction::find(this, SLOT(showSearchBar()),
                                         actionCollection());
     find->setPriority(QAction::LowPriority);
 
     QAction * replace=KStandardAction::replace(this, SLOT(showExtendedSearchBar()),
                                               actionCollection());
     replace->setPriority(QAction::LowPriority);
 
     m_findNext = KStandardAction::findNext(this, SLOT(findNext()),
                                            actionCollection());
     m_findNext->setEnabled(false);
     m_findPrev = KStandardAction::findPrev(this, SLOT(findPrev()),
                                            actionCollection());
     m_findPrev->setEnabled(false);
 
     QAction * latexExport=new QAction(i18n("Export to LaTeX"), actionCollection());
     actionCollection()->addAction(QLatin1String("file_export_latex"), latexExport);
     latexExport->setIcon(QIcon::fromTheme(QLatin1String("document-export")));
     connect(latexExport, SIGNAL(triggered()), this, SLOT(exportToLatex()));
 
     QAction * print = KStandardAction::print(this, SLOT(print()), actionCollection());
     print->setPriority(QAction::LowPriority);
 
     QAction * printPreview = KStandardAction::printPreview(this, SLOT(printPreview()), actionCollection());
     printPreview->setPriority(QAction::LowPriority);
 
     KStandardAction::zoomIn(m_worksheetview, SLOT(zoomIn()), actionCollection());
     KStandardAction::zoomOut(m_worksheetview, SLOT(zoomOut()), actionCollection());
 
     m_evaluate=new QAction(i18n("Evaluate Worksheet"), actionCollection());
     actionCollection()->addAction(QLatin1String("evaluate_worksheet"), m_evaluate);
     m_evaluate->setIcon(QIcon::fromTheme(QLatin1String("system-run")));
     m_evaluate->setShortcut(Qt::CTRL+Qt::Key_E);
     connect(m_evaluate, SIGNAL(triggered()), this, SLOT(evaluateOrInterrupt()));
 
     m_typeset=new KToggleAction(i18n("Typeset using LaTeX"), actionCollection());
     m_typeset->setChecked(Settings::self()->typesetDefault());
     actionCollection()->addAction(QLatin1String("enable_typesetting"), m_typeset);
     connect(m_typeset, SIGNAL(toggled(bool)), this, SLOT(enableTypesetting(bool)));
 
     m_highlight=new KToggleAction(i18n("Syntax Highlighting"), actionCollection());
     m_highlight->setChecked(Settings::self()->highlightDefault());
     actionCollection()->addAction(QLatin1String("enable_highlighting"), m_highlight);
     connect(m_highlight, SIGNAL(toggled(bool)), m_worksheet, SLOT(enableHighlighting(bool)));
 
     m_completion=new KToggleAction(i18n("Completion"), actionCollection());
     m_completion->setChecked(Settings::self()->completionDefault());
     actionCollection()->addAction(QLatin1String("enable_completion"), m_completion);
     connect(m_completion, SIGNAL(toggled(bool)), m_worksheet, SLOT(enableCompletion(bool)));
 
     m_exprNumbering=new KToggleAction(i18n("Line Numbers"), actionCollection());
     m_exprNumbering->setChecked(Settings::self()->expressionNumberingDefault());
     actionCollection()->addAction(QLatin1String("enable_expression_numbers"), m_exprNumbering);
     connect(m_exprNumbering, SIGNAL(toggled(bool)), m_worksheet, SLOT(enableExpressionNumbering(bool)));
 
     m_animateWorksheet=new KToggleAction(i18n("Animate Worksheet"), actionCollection());
     m_animateWorksheet->setChecked(Settings::self()->animationDefault());
     actionCollection()->addAction(QLatin1String("enable_animations"), m_animateWorksheet);
     connect(m_animateWorksheet, SIGNAL(toggled(bool)), m_worksheet, SLOT(enableAnimations(bool)));
 
     QAction * restart=new QAction(i18n("Restart Backend"), actionCollection());
     actionCollection()->addAction(QLatin1String("restart_backend"), restart);
     restart->setIcon(QIcon::fromTheme(QLatin1String("system-reboot")));
     connect(restart, SIGNAL(triggered()), this, SLOT(restartBackend()));
 
     QAction * evaluateCurrent=new QAction(i18n("Evaluate Entry"), actionCollection());
     actionCollection()->addAction(QLatin1String("evaluate_current"),  evaluateCurrent);
     actionCollection()->setDefaultShortcut(evaluateCurrent, Qt::SHIFT + Qt::Key_Return);
     connect(evaluateCurrent, SIGNAL(triggered()), m_worksheet, SLOT(evaluateCurrentEntry()));
 
     QAction * insertCommandEntry=new QAction(i18n("Insert Command Entry"), actionCollection());
     actionCollection()->addAction(QLatin1String("insert_command_entry"),  insertCommandEntry);
     actionCollection()->setDefaultShortcut(insertCommandEntry, Qt::CTRL + Qt::Key_Return);
     connect(insertCommandEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertCommandEntry()));
 
     QAction * insertTextEntry=new QAction(i18n("Insert Text Entry"), actionCollection());
     actionCollection()->addAction(QLatin1String("insert_text_entry"),  insertTextEntry);
     connect(insertTextEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertTextEntry()));
 
     QAction * insertLatexEntry=new QAction(i18n("Insert Latex Entry"), actionCollection());
     actionCollection()->addAction(QLatin1String("insert_latex_entry"),  insertLatexEntry);
     connect(insertLatexEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertLatexEntry()));
 
     QAction * insertPageBreakEntry=new QAction(i18n("Insert Page Break"), actionCollection());
     actionCollection()->addAction(QLatin1String("insert_page_break_entry"), insertPageBreakEntry);
     connect(insertPageBreakEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertPageBreakEntry()));
 
     QAction * insertImageEntry=new QAction(i18n("Insert Image"), actionCollection());
     actionCollection()->addAction(QLatin1String("insert_image_entry"), insertImageEntry);
     connect(insertImageEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertImageEntry()));
 
 
     /*
     QAction * insertCommandEntryBefore=new QAction(i18n("Insert Command Entry Before"), actionCollection());
     //insertCommandEntryBefore->setShortcut(Qt::CTRL + Qt::Key_Return);
     actionCollection()->addAction("insert_command_entry_before",  insertCommandEntryBefore);
     connect(insertCommandEntryBefore, SIGNAL(triggered()), m_worksheet, SLOT(insertCommandEntryBefore()));
 
     QAction * insertTextEntryBefore=new QAction(i18n("Insert Text Entry Before"), actionCollection());
     //insertTextEntryBefore->setShortcut(Qt::CTRL + Qt::Key_Return);
     actionCollection()->addAction("insert_text_entry_before",  insertTextEntryBefore);
     connect(insertTextEntryBefore, SIGNAL(triggered()), m_worksheet, SLOT(insertTextEntryBefore()));
 
     QAction * insertPageBreakEntryBefore=new QAction(i18n("Insert Page Break Before"), actionCollection());
     actionCollection()->addAction("insert_page_break_entry_before", insertPageBreakEntryBefore);
     connect(insertPageBreakEntryBefore, SIGNAL(triggered()), m_worksheet, SLOT(insertPageBreakEntryBefore()));
 
     QAction * insertImageEntryBefore=new QAction(i18n("Insert Image Entry Before"), actionCollection());
     //insertTextEntryBefore->setShortcut(Qt::CTRL + Qt::Key_Return);
     actionCollection()->addAction("insert_image_entry_before",  insertImageEntryBefore);
     connect(insertImageEntryBefore, SIGNAL(triggered()), m_worksheet, SLOT(insertImageEntryBefore()));
     */
 
     QAction * removeCurrent=new QAction(i18n("Remove current Entry"), actionCollection());
     actionCollection()->addAction(QLatin1String("remove_current"), removeCurrent);
     actionCollection()->setDefaultShortcut(removeCurrent, Qt::ShiftModifier + Qt::Key_Delete);
     connect(removeCurrent, SIGNAL(triggered()), m_worksheet, SLOT(removeCurrentEntry()));
 
     m_showBackendHelp=new QAction(i18n("Show %1 Help", b->name()) , actionCollection());
     m_showBackendHelp->setIcon(QIcon::fromTheme(QLatin1String("help-contents")));
     actionCollection()->addAction(QLatin1String("backend_help"), m_showBackendHelp);
     connect(m_showBackendHelp, SIGNAL(triggered()), this, SLOT(showBackendHelp()));
 
     QAction * publishWorksheet=new QAction(i18n("Publish Worksheet"), actionCollection());
     publishWorksheet->setIcon(QIcon::fromTheme(QLatin1String("get-hot-new-stuff")));
     actionCollection()->addAction(QLatin1String("file_publish_worksheet"), publishWorksheet);
     connect(publishWorksheet, SIGNAL(triggered()), this, SLOT(publishWorksheet()));
 
     KToggleAction* showEditor=new KToggleAction(i18n("Show Script Editor"), actionCollection());
     showEditor->setChecked(false);
     actionCollection()->addAction(QLatin1String("show_editor"), showEditor);
     connect(showEditor, SIGNAL(toggled(bool)), this, SLOT(showScriptEditor(bool)));
     showEditor->setEnabled(b->extensions().contains(QLatin1String("ScriptExtension")));
 
     QAction * showCompletion=new QAction(i18n("Show Completion"), actionCollection());
     actionCollection()->addAction(QLatin1String("show_completion"), showCompletion);
     QList<QKeySequence> showCompletionShortcuts;
     showCompletionShortcuts << Qt::Key_Tab << Qt::CTRL + Qt::Key_Space;
     actionCollection()->setDefaultShortcuts(showCompletion, showCompletionShortcuts);
     connect(showCompletion, SIGNAL(triggered()), m_worksheet, SLOT(showCompletion()));
 
     // set our XML-UI resource file
     setXMLFile(QLatin1String("cantor_part.rc"));
 
     // we are read-write by default
     setReadWrite(true);
 
     // we are not modified since we haven't done anything yet
     setModified(false);
 
     worksheetSessionChanged();
 }
 
 CantorPart::~CantorPart()
 {
     if (m_scriptEditor)
     {
         disconnect(m_scriptEditor, SIGNAL(destroyed()), this, SLOT(scriptEditorClosed()));
         delete m_scriptEditor;
     }
     if (m_searchBar)
         delete m_searchBar;
 }
 
 void CantorPart::setReadWrite(bool rw)
 {
     // notify your internal widget of the read-write state
     m_worksheetview->setInteractive(rw);
 
     ReadWritePart::setReadWrite(rw);
 }
 
 void CantorPart::setModified(bool modified)
 {
     // get a handle on our Save action and make sure it is valid
     if (!m_save)
         return;
 
     // if so, we either enable or disable it based on the current
     // state
     if (modified)
         m_save->setEnabled(true);
     else
         m_save->setEnabled(false);
 
     // in any event, we want our parent to do it's thing
     ReadWritePart::setModified(modified);
 }
 
 KAboutData& CantorPart::createAboutData()
 {
     // the non-i18n name here must be the same as the directory in
     // which the part's rc file is installed ('partrcdir' in the
     // Makefile)
 
     static KAboutData about(QLatin1String("cantorpart"),
                      QLatin1String("Cantor"),
                      QLatin1String(CANTOR_VERSION),
                      i18n("CantorPart"),
                      KAboutLicense::GPL,
                      i18n("(C) 2009-2015 Alexander Rieder"),
                      QString(),
                      QLatin1String("http://edu.kde.org/cantor"));
 
     about.addAuthor( i18n("Alexander Rieder"), QString(), QLatin1String("alexanderrieder@gmail.com") );
     return about;
 }
 
 bool CantorPart::openFile()
 {
     //don't crash if for some reason the worksheet is invalid
     if(m_worksheet==nullptr)
     {
         qWarning()<<"trying to open in an invalid cantor part";
         return false;
     }
 
     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
     QElapsedTimer timer;
 	timer.start();
     const bool rc = m_worksheet->load(localFilePath());
     QApplication::restoreOverrideCursor();
 
     if (rc) {
         qDebug()<< "Worksheet successfully loaded in " <<  (float)timer.elapsed()/1000 << " seconds).";
         updateCaption();
     }
 
     return rc;
 }
 
 bool CantorPart::saveFile()
 {
     // if we aren't read-write, return immediately
     if (isReadWrite() == false)
         return false;
 
     qDebug()<<"saving to: "<<url();
     if (url().isEmpty())
         fileSaveAs();
     else
         m_worksheet->save( localFilePath() );
     setModified(false);
 
     return true;
 }
 
 void CantorPart::fileSaveAs()
 {
     // this slot is called whenever the File->Save As menu is selected
     QString worksheetFilter = i18n("Cantor Worksheet (*.cws)");
     QString filter = worksheetFilter;
 
     //if the backend supports scripts, also append their scriptFile endings to the filter
     Cantor::Backend * const backend=m_worksheet->session()->backend();
     if (backend->extensions().contains(QLatin1String("ScriptExtension")))
     {
         Cantor::ScriptExtension* e=dynamic_cast<Cantor::ScriptExtension*>(backend->extension(QLatin1String("ScriptExtension")));
         filter+=QLatin1Char('\n')+e->scriptFileFilter();
     }
 
     QString selectedFilter;
     QString file_name = QFileDialog::getSaveFileName(widget(), i18n("Save as"), QString(), filter, &selectedFilter);
     if (file_name.isEmpty())
         return;
 
     //depending on user's selection, save as a worksheet or as a plain script file
     if (selectedFilter == worksheetFilter)
     {
         if (!file_name.endsWith(QLatin1String(".cws")))
             file_name += QLatin1String(".cws");
         saveAs(QUrl::fromLocalFile(file_name));
     }
     else
         m_worksheet->savePlain(file_name);
 
     updateCaption();
 }
 
 void CantorPart::fileSavePlain()
 {
     QString file_name = QFileDialog::getSaveFileName(widget(), i18n("Save"), QString(), QString());
     if (!file_name.isEmpty())
         m_worksheet->savePlain(file_name);
 }
 
 void CantorPart::exportToLatex()
 {
-    // this slot is called whenever the File->Save As menu is selected,
-    QString filter=i18n("*.tex|LaTeX Document");
-
     QString file_name = QFileDialog::getSaveFileName(widget(), i18n("Export to LaTeX"), QString(), QString());
 
     if (file_name.isEmpty() == false)
+        {
+        if (!file_name.endsWith(QLatin1String(".tex")))
+            file_name += QLatin1String(".tex");
         m_worksheet->saveLatex(file_name);
+        }
 }
 
 void CantorPart::guiActivateEvent( KParts::GUIActivateEvent * event )
 {
     KParts::ReadWritePart::guiActivateEvent(event);
     if(event->activated())
     {
         if(m_scriptEditor)
             m_scriptEditor->show();
     }else
     {
         if(m_scriptEditor)
             m_scriptEditor->hide();
     }
 }
 
 void CantorPart::evaluateOrInterrupt()
 {
     qDebug()<<"evalorinterrupt";
     if(m_worksheet->isRunning())
         m_worksheet->interrupt();
     else
         m_worksheet->evaluate();
 }
 void CantorPart::restartBackend()
 {
     m_worksheet->session()->logout();
     m_worksheet->session()->login();
 }
 
 void CantorPart::worksheetStatusChanged(Cantor::Session::Status status)
 {
     qDebug()<<"wsStatusChange"<<status;
     if(status==Cantor::Session::Running)
     {
         m_evaluate->setText(i18n("Interrupt"));
         m_evaluate->setShortcut(Qt::CTRL+Qt::Key_I);
         m_evaluate->setIcon(QIcon::fromTheme(QLatin1String("dialog-close")));
 
         setStatusMessage(i18n("Calculating..."));
     }else
     {
         m_evaluate->setText(i18n("Evaluate Worksheet"));
         m_evaluate->setShortcut(Qt::CTRL+Qt::Key_E);
         m_evaluate->setIcon(QIcon::fromTheme(QLatin1String("system-run")));
 
         setStatusMessage(i18n("Ready"));
     }
 }
 
 void CantorPart::showSessionError(const QString& message)
 {
     qDebug()<<"Error: "<<message;
     initialized();
     showImportantStatusMessage(i18n("Session Error: %1", message));
 }
 
 void CantorPart::worksheetSessionChanged()
 {
     connect(m_worksheet->session(), SIGNAL(statusChanged(Cantor::Session::Status)), this, SLOT(worksheetStatusChanged(Cantor::Session::Status)));
     connect(m_worksheet->session(), SIGNAL(loginStarted()),this, SLOT(worksheetSessionLoginStarted()));
     connect(m_worksheet->session(), SIGNAL(loginDone()),this, SLOT(worksheetSessionLoginDone()));
     connect(m_worksheet->session(), SIGNAL(error(const QString&)), this, SLOT(showSessionError(const QString&)));
 
     loadAssistants();
     m_panelHandler->setSession(m_worksheet->session());
     adjustGuiToSession();
     initialized();
 }
 
 void CantorPart::initialized()
 {
     if (m_worksheet->isEmpty())
         m_worksheet->appendCommandEntry();
 
     m_worksheetview->setEnabled(true);
     m_worksheetview->setFocus();
     setStatusMessage(i18n("Initialization complete"));
     updateCaption();
 }
 
 void CantorPart::worksheetSessionLoginStarted() {
     setStatusMessage(i18n("Initializing..."));
     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 }
 
 void CantorPart::worksheetSessionLoginDone() {
     setStatusMessage(i18n("Ready"));
     QApplication::restoreOverrideCursor();
 }
 
 void CantorPart::enableTypesetting(bool enable)
 {
     m_worksheet->session()->setTypesettingEnabled(enable);
 }
 
 void CantorPart::showBackendHelp()
 {
     qDebug()<<"showing backends help";
     Cantor::Backend* backend=m_worksheet->session()->backend();
     QUrl url = backend->helpUrl();
     qDebug()<<"launching url "<<url;
     new KRun(url, widget());
 }
 
 Worksheet* CantorPart::worksheet()
 {
     return m_worksheet;
 }
 
 void CantorPart::updateCaption()
 {
     QString filename=url().fileName();
     //strip away the extension
     filename=filename.left(filename.lastIndexOf(QLatin1Char('.')));
 
     if (filename.isEmpty())
         filename=i18n("Unnamed");
 
     emit setCaption(i18n("%1: %2", m_worksheet->session()->backend()->name(), filename));
 }
 
 void CantorPart::pluginsChanged()
 {
     foreach(Cantor::PanelPlugin* plugin, m_panelHandler->plugins())
     {
         connect(plugin, SIGNAL(requestRunCommand(QString)), this, SLOT(runCommand(QString)));
     }
 }
 
 void CantorPart::loadAssistants()
 {
     qDebug()<<"loading assistants...";
 
     QStringList assistantDirs;
     foreach(const QString &dir, QCoreApplication::libraryPaths()){
         assistantDirs << dir + QDir::separator() + QLatin1String("cantor/assistants");
     }
 
     QPluginLoader loader;
     foreach(const QString &dir, assistantDirs){
 
         qDebug() << "dir: " << dir;
         QStringList assistants;
         QDir assistantDir = QDir(dir);
 
         assistants = assistantDir.entryList();
 
         foreach (const QString &assistant, assistants){
             if (assistant==QLatin1String(".") || assistant==QLatin1String(".."))
                 continue;
 
             loader.setFileName(dir + QDir::separator() + assistant);
 
             if (!loader.load()){
                 qDebug() << "Error while loading assistant: " << assistant;
                 continue;
             }
 
             KPluginFactory* factory = KPluginLoader(loader.fileName()).factory();
             Cantor::Assistant* plugin = factory->create<Cantor::Assistant>(this);
 
             Cantor::Backend* backend=worksheet()->session()->backend();
 
             KPluginMetaData info(loader);
             plugin->setPluginInfo(info);
             plugin->setBackend(backend);
 
             qDebug()<<"plugin "<<info.name()<<" requires "<<plugin->requiredExtensions();
             bool supported=true;
             foreach(const QString& req, plugin->requiredExtensions())
                 supported=supported && backend->extensions().contains(req);
 
             qDebug()<<"plugin "<<info.name()<<" is "<<(supported ? "":" not ")<<" supported by "<<backend->name();
 
             if(supported)
             {
                 plugin->initActions();
                 connect(plugin, SIGNAL(requested()), this, SLOT(runAssistant()));
             }else
             {
                 removeChildClient(plugin);
                 plugin->deleteLater();
             }
         }
     }
 }
 
 void CantorPart::runAssistant()
 {
     Cantor::Assistant* a=qobject_cast<Cantor::Assistant*>(sender());
     QStringList cmds=a->run(widget());
     qDebug()<<cmds;
     if(!cmds.isEmpty())
         runCommand(cmds.join(QLatin1String("\n")));
 }
 
 void CantorPart::runCommand(const QString& cmd)
 {
     m_worksheet->appendCommandEntry(cmd);
 }
 
 void CantorPart::showSearchBar()
 {
     if (!m_searchBar) {
         m_searchBar = new SearchBar(widget(), m_worksheet);
         widget()->layout()->addWidget(m_searchBar);
         connect(m_searchBar, SIGNAL(destroyed(QObject*)),
                 this, SLOT(searchBarDeleted()));
     }
 
     m_findNext->setEnabled(true);
     m_findPrev->setEnabled(true);
 
     m_searchBar->showStandard();
     m_searchBar->setFocus();
 }
 
 void CantorPart::showExtendedSearchBar()
 {
     if (!m_searchBar) {
         m_searchBar = new SearchBar(widget(), m_worksheet);
         widget()->layout()->addWidget(m_searchBar);
         connect(m_searchBar, SIGNAL(destroyed(QObject*)),
                 this, SLOT(searchBarDeleted()));
     }
 
     m_findNext->setEnabled(true);
     m_findPrev->setEnabled(true);
 
     m_searchBar->showExtended();
     m_searchBar->setFocus();
 }
 
 void CantorPart::findNext()
 {
     if (m_searchBar)
         m_searchBar->next();
 }
 
 void CantorPart::findPrev()
 {
     if (m_searchBar)
         m_searchBar->prev();
 }
 
 void CantorPart::searchBarDeleted()
 {
     m_searchBar = nullptr;
     m_findNext->setEnabled(false);
     m_findPrev->setEnabled(false);
 }
 
 void CantorPart::adjustGuiToSession()
 {
 #ifdef WITH_EPS
     m_typeset->setVisible(m_worksheet->session()->backend()->capabilities().testFlag(Cantor::Backend::LaTexOutput));
 #else
     m_typeset->setVisible(false);
 #endif
     m_completion->setVisible(m_worksheet->session()->backend()->capabilities().testFlag(Cantor::Backend::Completion));
 
     //this is 0 on the first call
     if(m_showBackendHelp)
         m_showBackendHelp->setText(i18n("Show %1 Help", m_worksheet->session()->backend()->name()));
 }
 
 void CantorPart::publishWorksheet()
 {
     int ret = KMessageBox::questionYesNo(widget(),
                                          i18n("Do you want to upload current Worksheet to public web server?"),
                                          i18n("Question - Cantor"));
     if (ret != KMessageBox::Yes) return;
 
     if (isModified()||url().isEmpty())
     {
         ret = KMessageBox::warningContinueCancel(widget(),
                                                  i18n("The Worksheet is not saved. You should save it before uploading."),
                                                  i18n("Warning - Cantor"),  KStandardGuiItem::save(),  KStandardGuiItem::cancel());
         if (ret != KMessageBox::Continue) return;
         if (!saveFile()) return;
     }
 
     qDebug()<<"uploading file "<<url();
 
     // upload
     //HACK: use different .knsrc files for each category
     //remove this once KNS3 gains the ability to select category
     KNS3::UploadDialog dialog(QString::fromLatin1("cantor_%1.knsrc").arg(m_worksheet->session()->backend()->id().toLower()), widget());
     dialog.setUploadFile(url());
     dialog.exec();
 }
 
 void CantorPart::print()
 {
     QPrinter printer;
     QPointer<QPrintDialog> dialog = new QPrintDialog(&printer,  widget());
 
     // TODO: Re-enable print selection
     //if (m_worksheet->textCursor().hasSelection())
     //    dialog->addEnabledOption(QAbstractPrintDialog::PrintSelection);
 
     if (dialog->exec() == QDialog::Accepted)
         m_worksheet->print(&printer);
 
     delete dialog;
 }
 
 void CantorPart::printPreview()
 {
     QPrintPreviewDialog *dialog = new QPrintPreviewDialog(widget());
     connect(dialog, SIGNAL(paintRequested(QPrinter*)), m_worksheet, SLOT(print(QPrinter*)));
     dialog->exec();
 }
 
 void CantorPart::showScriptEditor(bool show)
 {
     if(show)
     {
         if (m_scriptEditor)
         {
             return;
         }
         Cantor::ScriptExtension* scriptE=dynamic_cast<Cantor::ScriptExtension*>(m_worksheet->session()->backend()->extension(QLatin1String("ScriptExtension")));
         if (!scriptE)
         {
             return;
         }
         m_scriptEditor=new ScriptEditorWidget(scriptE->scriptFileFilter(), scriptE->highlightingMode(), widget()->window());
         connect(m_scriptEditor, SIGNAL(runScript(const QString&)), this, SLOT(runScript(const QString&)));
         connect(m_scriptEditor, SIGNAL(destroyed()), this, SLOT(scriptEditorClosed()));
         m_scriptEditor->show();
     }else
     {
         m_scriptEditor->deleteLater();
     }
 }
 
 void CantorPart::scriptEditorClosed()
 {
     QAction* showEditor = actionCollection()->action(QLatin1String("show_editor"));
     if (showEditor)
     {
         showEditor->setChecked(false);
     }
 }
 
 void CantorPart::runScript(const QString& file)
 {
     Cantor::Backend* backend=m_worksheet->session()->backend();
     if(!backend->extensions().contains(QLatin1String("ScriptExtension")))
     {
         KMessageBox::error(widget(), i18n("This backend does not support scripts."), i18n("Error - Cantor"));
         return;
     }
 
     Cantor::ScriptExtension* scriptE=dynamic_cast<Cantor::ScriptExtension*>(backend->extension(QLatin1String("ScriptExtension")));
     m_worksheet->appendCommandEntry(scriptE->runExternalScript(file));
 }
 
 void CantorPart::blockStatusBar()
 {
     m_statusBarBlocked=true;
 }
 
 void CantorPart::unblockStatusBar()
 {
     m_statusBarBlocked=false;
     if(!m_cachedStatusMessage.isNull())
         setStatusMessage(m_cachedStatusMessage);
     m_cachedStatusMessage.clear();
 }
 
 void CantorPart::setStatusMessage(const QString& message)
 {
     if(!m_statusBarBlocked)
         emit setStatusBarText(message);
     else
         m_cachedStatusMessage=message;
 }
 
 void CantorPart::showImportantStatusMessage(const QString& message)
 {
     setStatusMessage(message);
     blockStatusBar();
     QTimer::singleShot(3000, this, SLOT(unblockStatusBar()));
 }
 
 K_PLUGIN_FACTORY_WITH_JSON(CantorPartFactory, "cantor_part.json", registerPlugin<CantorPart>();)
 #include "cantor_part.moc"
diff --git a/src/lib/latexresult.cpp b/src/lib/latexresult.cpp
index 5f41c402..8d1e498a 100644
--- a/src/lib/latexresult.cpp
+++ b/src/lib/latexresult.cpp
@@ -1,150 +1,150 @@
 /*
     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.
 
     ---
     Copyright (C) 2009 Alexander Rieder <alexanderrieder@gmail.com>
  */
 
 #include "latexresult.h"
 using namespace Cantor;
 
 #include <QFile>
 #include <QTextStream>
 #include <QDebug>
 
 class Cantor::LatexResultPrivate
 {
   public:
     LatexResultPrivate()
     {
         showCode=false;
     }
 
     bool showCode;
     QString code;
     QString plain;
 };
 
 LatexResult::LatexResult(const QString& code, const QUrl &url, const QString& plain) : EpsResult( url ),
                                                                                        d(new LatexResultPrivate)
 {
     d->code=code;
     d->plain=plain;
 }
 
 LatexResult::~LatexResult()
 {
     delete d;
 }
 
 int LatexResult::type()
 {
     return LatexResult::Type;
 }
 
 QString LatexResult::mimeType()
 {
     if(isCodeShown())
         return QLatin1String("text/plain");
     else
         return EpsResult::mimeType();
 }
 
 QString LatexResult::code()
 {
     return d->code;
 }
 
 QString LatexResult::plain()
 {
     return d->plain;
 }
 
 bool LatexResult::isCodeShown()
 {
     return d->showCode;
 }
 
 void LatexResult::showCode()
 {
     d->showCode=true;
 }
 
 void LatexResult::showRendered()
 {
     d->showCode=false;
 }
 
 QVariant LatexResult::data()
 {
     if(isCodeShown())
         return QVariant(code());
     else
         return EpsResult::data();
 }
 
 QString LatexResult::toHtml()
 {
     if (isCodeShown())
     {
             QString s=code();
 //             s.replace('\n', QLatin1String("<br/>\n"));
             return s;
     }
     else
     {
         return EpsResult::toHtml();
     }
 }
 
 QString LatexResult::toLatex()
 {
     return code();
 }
 
 QDomElement LatexResult::toXml(QDomDocument& doc)
 {
     qDebug()<<"saving textresult "<<toHtml();
     QDomElement e=doc.createElement(QLatin1String("Result"));
-    e.setAttribute(QLatin1String("type"), QLatin1String("latex"));
+    e.setAttribute(QLatin1String("type"), QLatin1String("application/x-latex"));
     QUrl url= EpsResult::data().toUrl();
     e.setAttribute(QLatin1String("filename"), url.fileName());
     QDomText txt=doc.createTextNode(code());
     e.appendChild(txt);
 
     return e;
 }
 
 void LatexResult::save(const QString& filename)
 {
     if(isCodeShown())
     {
         QFile file(filename);
 
         if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
             return;
 
         QTextStream stream(&file);
 
         stream<<code();
 
         file.close();
     }else
     {
         EpsResult::save(filename);
     }
 }
 
diff --git a/src/worksheet.cpp b/src/worksheet.cpp
index 192b30e4..590c28ea 100644
--- a/src/worksheet.cpp
+++ b/src/worksheet.cpp
@@ -1,1731 +1,1734 @@
 /*
     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.
 
     ---
     Copyright (C) 2009 Alexander Rieder <alexanderrieder@gmail.com>
     Copyright (C) 2012 Martin Kuettler <martin.kuettler@gmail.com>
  */
 
 #include <QBuffer>
 #include <QDebug>
 #include <QDrag>
 #include <QGraphicsWidget>
 #include <QPrinter>
 #include <QTimer>
 #include <QtXmlPatterns/QXmlQuery>
 
 #include <KMessageBox>
 #include <KActionCollection>
 #include <KFontAction>
 #include <KFontSizeAction>
 #include <KToggleAction>
 
 #include "worksheet.h"
 #include "settings.h"
 #include "commandentry.h"
 #include "textentry.h"
 #include "latexentry.h"
 #include "imageentry.h"
 #include "pagebreakentry.h"
 #include "placeholderentry.h"
 #include "lib/backend.h"
 #include "lib/extension.h"
 #include "lib/helpresult.h"
 #include "lib/session.h"
 #include "lib/defaulthighlighter.h"
 
 #include <config-cantorlib.h>
 
 const double Worksheet::LeftMargin = 4;
 const double Worksheet::RightMargin = 4;
 const double Worksheet::TopMargin = 4;
 
 Worksheet::Worksheet(Cantor::Backend* backend, QWidget* parent)
     : QGraphicsScene(parent)
 {
     m_session = backend->createSession();
     m_highlighter = nullptr;
 
     m_firstEntry = nullptr;
     m_lastEntry = nullptr;
     m_lastFocusedTextItem = nullptr;
     m_dragEntry = nullptr;
     m_placeholderEntry = nullptr;
     m_viewWidth = 0;
     m_protrusion = 0;
     m_dragScrollTimer = nullptr;
 
     m_isPrinting = false;
     m_loginDone = false;
     m_isLoadingFromFile = false;
 
     enableHighlighting(Settings::self()->highlightDefault());
     enableCompletion(Settings::self()->completionDefault());
     enableExpressionNumbering(Settings::self()->expressionNumberingDefault());
     enableAnimations(Settings::self()->animationDefault());
 }
 
 Worksheet::~Worksheet()
 {
     // This is necessary, because a SeachBar might access firstEntry()
     // while the scene is deleted. Maybe there is a better solution to
     // this problem, but I can't seem to find it.
     m_firstEntry = nullptr;
     if (m_loginDone)
         m_session->logout();
 }
 
 void Worksheet::loginToSession()
 {
     m_session->login();
 #ifdef WITH_EPS
     session()->setTypesettingEnabled(Settings::self()->typesetDefault());
 #else
     session()->setTypesettingEnabled(false);
 #endif
     m_loginDone = true;
 }
 
 void Worksheet::print(QPrinter* printer)
 {
     m_epsRenderer.useHighResolution(true);
     m_isPrinting = true;
     QRect pageRect = printer->pageRect();
     qreal scale = 1; // todo: find good scale for page size
     // todo: use epsRenderer()->scale() for printing ?
     const qreal width = pageRect.width()/scale;
     const qreal height = pageRect.height()/scale;
     setViewSize(width, height, scale, true);
 
     QPainter painter(printer);
     painter.scale(scale, scale);
     painter.setRenderHint(QPainter::Antialiasing);
     WorksheetEntry* entry = firstEntry();
     qreal y = 0;
 
     while (entry) {
         qreal h = 0;
         do {
             if (entry->type() == PageBreakEntry::Type) {
                 entry = entry->next();
                 break;
             }
             h += entry->size().height();
             entry = entry->next();
         } while (entry && h + entry->size().height() <= height);
 
         render(&painter, QRectF(0, 0, width, height),
                QRectF(0, y, width, h));
         y += h;
         if (entry)
             printer->newPage();
     }
 
     //render(&painter);
 
     painter.end();
     m_isPrinting = false;
     m_epsRenderer.useHighResolution(false);
     m_epsRenderer.setScale(-1);  // force update in next call to setViewSize,
     worksheetView()->updateSceneSize(); // ... which happens in here
 }
 
 bool Worksheet::isPrinting()
 {
     return m_isPrinting;
 }
 
 void Worksheet::setViewSize(qreal w, qreal h, qreal s, bool forceUpdate)
 {
     Q_UNUSED(h);
 
     m_viewWidth = w;
     if (s != m_epsRenderer.scale() || forceUpdate) {
         m_epsRenderer.setScale(s);
         for (WorksheetEntry *entry = firstEntry(); entry; entry = entry->next())
             entry->updateEntry();
     }
     updateLayout();
 }
 
 void Worksheet::updateLayout()
 {
     bool cursorRectVisible = false;
     bool atEnd = worksheetView()->isAtEnd();
     if (currentTextItem()) {
         QRectF cursorRect = currentTextItem()->sceneCursorRect();
         cursorRectVisible = worksheetView()->isVisible(cursorRect);
     }
 
     const qreal w = m_viewWidth - LeftMargin - RightMargin;
     qreal y = TopMargin;
     const qreal x = LeftMargin;
     for (WorksheetEntry *entry = firstEntry(); entry; entry = entry->next())
         y += entry->setGeometry(x, y, w);
     setSceneRect(QRectF(0, 0, m_viewWidth + m_protrusion, y));
     if (cursorRectVisible)
         makeVisible(worksheetCursor());
     else if (atEnd)
         worksheetView()->scrollToEnd();
 }
 
 void Worksheet::updateEntrySize(WorksheetEntry* entry)
 {
     bool cursorRectVisible = false;
     bool atEnd = worksheetView()->isAtEnd();
     if (currentTextItem()) {
         QRectF cursorRect = currentTextItem()->sceneCursorRect();
         cursorRectVisible = worksheetView()->isVisible(cursorRect);
     }
 
     qreal y = entry->y() + entry->size().height();
     for (entry = entry->next(); entry; entry = entry->next()) {
         entry->setY(y);
         y += entry->size().height();
     }
     setSceneRect(QRectF(0, 0, m_viewWidth + m_protrusion, y));
     if (cursorRectVisible)
         makeVisible(worksheetCursor());
     else if (atEnd)
         worksheetView()->scrollToEnd();
 }
 
 void Worksheet::addProtrusion(qreal width)
 {
     if (m_itemProtrusions.contains(width))
         ++m_itemProtrusions[width];
     else
         m_itemProtrusions.insert(width, 1);
     if (width > m_protrusion) {
         m_protrusion = width;
         qreal y = lastEntry()->size().height() + lastEntry()->y();
         setSceneRect(QRectF(0, 0, m_viewWidth + m_protrusion, y));
     }
 }
 
 void Worksheet::updateProtrusion(qreal oldWidth, qreal newWidth)
 {
     removeProtrusion(oldWidth);
     addProtrusion(newWidth);
 }
 
 void Worksheet::removeProtrusion(qreal width)
 {
     if (--m_itemProtrusions[width] == 0) {
         m_itemProtrusions.remove(width);
         if (width == m_protrusion) {
             qreal max = -1;
             foreach (qreal p, m_itemProtrusions.keys()) {
                 if (p > max)
                     max = p;
             }
             m_protrusion = max;
             qreal y = lastEntry()->size().height() + lastEntry()->y();
             setSceneRect(QRectF(0, 0, m_viewWidth + m_protrusion, y));
         }
     }
 }
 
 bool Worksheet::isEmpty()
 {
     return !m_firstEntry;
 }
 
 bool Worksheet::isLoadingFromFile()
 {
     return m_isLoadingFromFile;
 }
 
 void Worksheet::makeVisible(WorksheetEntry* entry)
 {
     QRectF r = entry->boundingRect();
     r = entry->mapRectToScene(r);
     r.adjust(0, -10, 0, 10);
     worksheetView()->makeVisible(r);
 }
 
 void Worksheet::makeVisible(const WorksheetCursor& cursor)
 {
     if (cursor.textCursor().isNull()) {
         if (cursor.entry())
             makeVisible(cursor.entry());
         return;
     }
     QRectF r = cursor.textItem()->sceneCursorRect(cursor.textCursor());
     QRectF er = cursor.entry()->boundingRect();
     er = cursor.entry()->mapRectToScene(er);
     er.adjust(0, -10, 0, 10);
     r.adjust(0, qMax(qreal(-100.0), er.top() - r.top()),
              0, qMin(qreal(100.0), er.bottom() - r.bottom()));
     worksheetView()->makeVisible(r);
 }
 
 WorksheetView* Worksheet::worksheetView()
 {
     return qobject_cast<WorksheetView*>(views()[0]);
 }
 
 void Worksheet::setModified()
 {
     emit modified();
 }
 
 WorksheetCursor Worksheet::worksheetCursor()
 {
     WorksheetEntry* entry = currentEntry();
     WorksheetTextItem* item = currentTextItem();
 
     if (!entry || !item)
         return WorksheetCursor();
     return WorksheetCursor(entry, item, item->textCursor());
 }
 
 void Worksheet::setWorksheetCursor(const WorksheetCursor& cursor)
 {
     if (!cursor.isValid())
         return;
 
     if (m_lastFocusedTextItem)
         m_lastFocusedTextItem->clearSelection();
 
     m_lastFocusedTextItem = cursor.textItem();
 
     cursor.textItem()->setTextCursor(cursor.textCursor());
 }
 
 WorksheetEntry* Worksheet::currentEntry()
 {
     QGraphicsItem* item = focusItem();
     if (!item /*&& !hasFocus()*/)
         item = m_lastFocusedTextItem;
     /*else
       m_focusItem = item;*/
     while (item && (item->type() < QGraphicsItem::UserType ||
                     item->type() >= QGraphicsItem::UserType + 100))
         item = item->parentItem();
     if (item) {
         WorksheetEntry* entry = qobject_cast<WorksheetEntry*>(item->toGraphicsObject());
         if (entry && entry->aboutToBeRemoved()) {
             if (entry->isAncestorOf(m_lastFocusedTextItem))
                 m_lastFocusedTextItem = nullptr;
             return nullptr;
         }
         return entry;
     }
     return nullptr;
 }
 
 WorksheetEntry* Worksheet::firstEntry()
 {
     return m_firstEntry;
 }
 
 WorksheetEntry* Worksheet::lastEntry()
 {
     return m_lastEntry;
 }
 
 void Worksheet::setFirstEntry(WorksheetEntry* entry)
 {
     if (m_firstEntry)
         disconnect(m_firstEntry, SIGNAL(aboutToBeDeleted()),
                    this, SLOT(invalidateFirstEntry()));
     m_firstEntry = entry;
     if (m_firstEntry)
         connect(m_firstEntry, SIGNAL(aboutToBeDeleted()),
                 this, SLOT(invalidateFirstEntry()), Qt::DirectConnection);
 }
 
 void Worksheet::setLastEntry(WorksheetEntry* entry)
 {
     if (m_lastEntry)
         disconnect(m_lastEntry, SIGNAL(aboutToBeDeleted()),
                    this, SLOT(invalidateLastEntry()));
     m_lastEntry = entry;
     if (m_lastEntry)
         connect(m_lastEntry, SIGNAL(aboutToBeDeleted()),
                 this, SLOT(invalidateLastEntry()), Qt::DirectConnection);
 }
 
 void Worksheet::invalidateFirstEntry()
 {
     if (m_firstEntry)
         setFirstEntry(m_firstEntry->next());
 }
 
 void Worksheet::invalidateLastEntry()
 {
     if (m_lastEntry)
         setLastEntry(m_lastEntry->previous());
 }
 
 WorksheetEntry* Worksheet::entryAt(qreal x, qreal y)
 {
     QGraphicsItem* item = itemAt(x, y, QTransform());
     while (item && (item->type() <= QGraphicsItem::UserType ||
                     item->type() >= QGraphicsItem::UserType + 100))
         item = item->parentItem();
     if (item)
         return qobject_cast<WorksheetEntry*>(item->toGraphicsObject());
     return nullptr;
 }
 
 WorksheetEntry* Worksheet::entryAt(QPointF p)
 {
     return entryAt(p.x(), p.y());
 }
 
 void Worksheet::focusEntry(WorksheetEntry *entry)
 {
     if (!entry)
         return;
     entry->focusEntry();
     //bool rt = entry->acceptRichText();
     //setActionsEnabled(rt);
     //setAcceptRichText(rt);
     //ensureCursorVisible();
 }
 
 void Worksheet::startDrag(WorksheetEntry* entry, QDrag* drag)
 {
     m_dragEntry = entry;
     WorksheetEntry* prev = entry->previous();
     WorksheetEntry* next = entry->next();
     m_placeholderEntry = new PlaceHolderEntry(this, entry->size());
     m_placeholderEntry->setPrevious(prev);
     m_placeholderEntry->setNext(next);
     if (prev)
         prev->setNext(m_placeholderEntry);
     else
         setFirstEntry(m_placeholderEntry);
     if (next)
         next->setPrevious(m_placeholderEntry);
     else
         setLastEntry(m_placeholderEntry);
     m_dragEntry->hide();
     Qt::DropAction action = drag->exec();
 
     qDebug() << action;
     if (action == Qt::MoveAction && m_placeholderEntry) {
         qDebug() << "insert in new position";
         prev = m_placeholderEntry->previous();
         next = m_placeholderEntry->next();
     }
     m_dragEntry->setPrevious(prev);
     m_dragEntry->setNext(next);
     if (prev)
         prev->setNext(m_dragEntry);
     else
         setFirstEntry(m_dragEntry);
     if (next)
         next->setPrevious(m_dragEntry);
     else
         setLastEntry(m_dragEntry);
     m_dragEntry->show();
     m_dragEntry->focusEntry();
     const QPointF scenePos = worksheetView()->sceneCursorPos();
     if (entryAt(scenePos) != m_dragEntry)
         m_dragEntry->hideActionBar();
     updateLayout();
     if (m_placeholderEntry) {
         m_placeholderEntry->setPrevious(nullptr);
         m_placeholderEntry->setNext(nullptr);
         m_placeholderEntry->hide();
         m_placeholderEntry->deleteLater();
         m_placeholderEntry = nullptr;
     }
     m_dragEntry = nullptr;
 }
 
 void Worksheet::evaluate()
 {
     qDebug()<<"evaluate worksheet";
     if (!m_loginDone)
         loginToSession();
 
     firstEntry()->evaluate(WorksheetEntry::EvaluateNext);
 
     emit modified();
 }
 
 void Worksheet::evaluateCurrentEntry()
 {
     if (!m_loginDone)
         loginToSession();
 
     WorksheetEntry* entry = currentEntry();
     if(!entry)
         return;
     entry->evaluateCurrentItem();
 }
 
 bool Worksheet::completionEnabled()
 {
     return m_completionEnabled;
 }
 
 void Worksheet::showCompletion()
 {
     //for backends which fetch the completion from the corresponding interpreter
     //we need to do the login first.
     //TODO: ideally, this logic is implemented in the actual session classes
     //and the worksheet doesn't need to know anything about this.
     //But as long as we have some additional logic in Worksheet::loginToSession(),
     //we need to handle this here.
     if (!m_loginDone && (m_session->backend()->name() == QLatin1String("Julia")
                     || m_session->backend()->name() == QLatin1String("Lua")
                     || m_session->backend()->name() == QLatin1String("R")
                     || m_session->backend()->name() == QLatin1String("Octave")) )
         loginToSession();
 
     WorksheetEntry* current = currentEntry();
     current->showCompletion();
 }
 
 WorksheetEntry* Worksheet::appendEntry(const int type)
 {
     WorksheetEntry* entry = WorksheetEntry::create(type, this);
 
     if (entry)
     {
         qDebug() << "Entry Appended";
         entry->setPrevious(lastEntry());
         if (lastEntry())
             lastEntry()->setNext(entry);
         if (!firstEntry())
             setFirstEntry(entry);
         setLastEntry(entry);
         updateLayout();
         makeVisible(entry);
         focusEntry(entry);
     }
     return entry;
 }
 
 WorksheetEntry* Worksheet::appendCommandEntry()
 {
    return appendEntry(CommandEntry::Type);
 }
 
 WorksheetEntry* Worksheet::appendTextEntry()
 {
    return appendEntry(TextEntry::Type);
 }
 
 
 WorksheetEntry* Worksheet::appendPageBreakEntry()
 {
     return appendEntry(PageBreakEntry::Type);
 }
 
 WorksheetEntry* Worksheet::appendImageEntry()
 {
    return appendEntry(ImageEntry::Type);
 }
 
 WorksheetEntry* Worksheet::appendLatexEntry()
 {
     return appendEntry(LatexEntry::Type);
 }
 
 void Worksheet::appendCommandEntry(const QString& text)
 {
     WorksheetEntry* entry = lastEntry();
     if(!entry->isEmpty())
     {
         entry = appendCommandEntry();
     }
 
     if (entry)
     {
         focusEntry(entry);
         entry->setContent(text);
         evaluateCurrentEntry();
     }
 }
 
 WorksheetEntry* Worksheet::insertEntry(const int type, WorksheetEntry* current)
 {
     if (!current)
         current = currentEntry();
 
     if (!current)
         return appendEntry(type);
 
     WorksheetEntry *next = current->next();
     WorksheetEntry *entry = nullptr;
 
     if (!next || next->type() != type || !next->isEmpty())
     {
         entry = WorksheetEntry::create(type, this);
         entry->setPrevious(current);
         entry->setNext(next);
         current->setNext(entry);
         if (next)
             next->setPrevious(entry);
         else
             setLastEntry(entry);
         updateLayout();
     } else {
         entry = next;
     }
 
     focusEntry(entry);
     makeVisible(entry);
     return entry;
 }
 
 WorksheetEntry* Worksheet::insertTextEntry(WorksheetEntry* current)
 {
     return insertEntry(TextEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertCommandEntry(WorksheetEntry* current)
 {
     return insertEntry(CommandEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertImageEntry(WorksheetEntry* current)
 {
     return insertEntry(ImageEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertPageBreakEntry(WorksheetEntry* current)
 {
     return insertEntry(PageBreakEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertLatexEntry(WorksheetEntry* current)
 {
     return insertEntry(LatexEntry::Type, current);
 }
 
 void Worksheet::insertCommandEntry(const QString& text)
 {
     WorksheetEntry* entry = insertCommandEntry();
     if(entry&&!text.isNull())
     {
         entry->setContent(text);
         evaluateCurrentEntry();
     }
 }
 
 WorksheetEntry* Worksheet::insertEntryBefore(int type, WorksheetEntry* current)
 {
     if (!current)
         current = currentEntry();
 
     if (!current)
         return nullptr;
 
     WorksheetEntry *prev = current->previous();
     WorksheetEntry *entry = nullptr;
 
     if(!prev || prev->type() != type || !prev->isEmpty())
     {
         entry = WorksheetEntry::create(type, this);
         entry->setNext(current);
         entry->setPrevious(prev);
         current->setPrevious(entry);
         if (prev)
             prev->setNext(entry);
         else
             setFirstEntry(entry);
         updateLayout();
     }
 
     focusEntry(entry);
     return entry;
 }
 
 WorksheetEntry* Worksheet::insertTextEntryBefore(WorksheetEntry* current)
 {
     return insertEntryBefore(TextEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertCommandEntryBefore(WorksheetEntry* current)
 {
     return insertEntryBefore(CommandEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertPageBreakEntryBefore(WorksheetEntry* current)
 {
     return insertEntryBefore(PageBreakEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertImageEntryBefore(WorksheetEntry* current)
 {
     return insertEntryBefore(ImageEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertLatexEntryBefore(WorksheetEntry* current)
 {
     return insertEntryBefore(LatexEntry::Type, current);
 }
 
 void Worksheet::interrupt()
 {
     if (m_session->status() == Cantor::Session::Running)
     {
         m_session->interrupt();
         emit updatePrompt();
     }
 }
 
 void Worksheet::interruptCurrentEntryEvaluation()
 {
     currentEntry()->interruptEvaluation();
 }
 
 void Worksheet::highlightItem(WorksheetTextItem* item)
 {
     if (!m_highlighter)
         return;
 
     QTextDocument *oldDocument = m_highlighter->document();
     QList<QList<QTextLayout::FormatRange> > formats;
 
     if (oldDocument)
     {
         for (QTextBlock b = oldDocument->firstBlock();
              b.isValid(); b = b.next())
         {
             formats.append(b.layout()->additionalFormats());
         }
     }
 
     // Not every highlighter is a Cantor::DefaultHighligther (e.g. the
     // highlighter for KAlgebra)
     Cantor::DefaultHighlighter* hl = qobject_cast<Cantor::DefaultHighlighter*>(m_highlighter);
     if (hl) {
         hl->setTextItem(item);
     } else {
         m_highlighter->setDocument(item->document());
     }
 
     if (oldDocument)
     {
         QTextCursor cursor(oldDocument);
         cursor.beginEditBlock();
         for (QTextBlock b = oldDocument->firstBlock();
              b.isValid(); b = b.next())
         {
             b.layout()->setAdditionalFormats(formats.first());
             formats.pop_front();
         }
         cursor.endEditBlock();
     }
 
 }
 
 void Worksheet::rehighlight()
 {
     if(m_highlighter)
     {
         // highlight every entry
         WorksheetEntry* entry;
         for (entry = firstEntry(); entry; entry = entry->next()) {
             WorksheetTextItem* item = entry->highlightItem();
             if (!item)
                 continue;
             highlightItem(item);
             m_highlighter->rehighlight();
         }
         entry = currentEntry();
         WorksheetTextItem* textitem = entry ? entry->highlightItem() : nullptr;
         if (textitem && textitem->hasFocus())
             highlightItem(textitem);
     } else
     {
         // remove highlighting from entries
         WorksheetEntry* entry;
         for (entry = firstEntry(); entry; entry = entry->next()) {
             WorksheetTextItem* item = entry->highlightItem();
             if (!item)
                 continue;
             for (QTextBlock b = item->document()->firstBlock();
                  b.isValid(); b = b.next())
             {
                 b.layout()->clearAdditionalFormats();
             }
         }
         update();
     }
 }
 
 void Worksheet::enableHighlighting(bool highlight)
 {
     if(highlight)
     {
         if(m_highlighter)
             m_highlighter->deleteLater();
 
         //octave highligther fetches the function names from octave -> we need to login here
         //TODO: re-design this later - highlighting should also be possible in the absence of the actual backend
         if (!m_loginDone && m_session->backend()->name() == QLatin1String("Octave"))
             loginToSession();
 
         m_highlighter=session()->syntaxHighlighter(this);
         if(!m_highlighter)
             m_highlighter=new Cantor::DefaultHighlighter(this);
 
         connect(m_highlighter, SIGNAL(rulesChanged()), this, SLOT(rehighlight()));
 
     }else
     {
         if(m_highlighter)
             m_highlighter->deleteLater();
         m_highlighter=nullptr;
     }
 
     rehighlight();
 }
 
 void Worksheet::enableCompletion(bool enable)
 {
     m_completionEnabled=enable;
 }
 
 Cantor::Session* Worksheet::session()
 {
     return m_session;
 }
 
 bool Worksheet::isRunning()
 {
     return m_session->status()==Cantor::Session::Running;
 }
 
 bool Worksheet::showExpressionIds()
 {
     return m_showExpressionIds;
 }
 
 bool Worksheet::animationsEnabled()
 {
     return m_animationsEnabled;
 }
 
 void Worksheet::enableAnimations(bool enable)
 {
     m_animationsEnabled = enable;
 }
 
 void Worksheet::enableExpressionNumbering(bool enable)
 {
     m_showExpressionIds=enable;
     emit updatePrompt();
 }
 
 QDomDocument Worksheet::toXML(KZip* archive)
 {
     QDomDocument doc( QLatin1String("CantorWorksheet") );
     QDomElement root=doc.createElement( QLatin1String("Worksheet") );
     root.setAttribute(QLatin1String("backend"), m_session->backend()->name());
     doc.appendChild(root);
 
     for( WorksheetEntry* entry = firstEntry(); entry; entry = entry->next())
     {
         QDomElement el = entry->toXml(doc, archive);
         root.appendChild( el );
     }
     return doc;
 }
 
 void Worksheet::save( const QString& filename )
 {
     QFile file(filename);
     if ( !file.open(QIODevice::WriteOnly) )
     {
         KMessageBox::error( worksheetView(),
                             i18n( "Cannot write file %1." , filename ),
                             i18n( "Error - Cantor" ));
         return;
     }
 
     save(&file);
 }
 
 QByteArray Worksheet::saveToByteArray()
 {
     QBuffer buffer;
     save(&buffer);
 
     return buffer.buffer();
 }
 
 void Worksheet::save( QIODevice* device)
 {
     qDebug()<<"saving to filename";
     KZip zipFile( device );
 
 
     if ( !zipFile.open(QIODevice::WriteOnly) )
     {
         KMessageBox::error( worksheetView(),
                             i18n( "Cannot write file." ),
                             i18n( "Error - Cantor" ));
         return;
     }
 
     QByteArray content = toXML(&zipFile).toByteArray();
     qDebug()<<"content: "<<content;
     zipFile.writeFile( QLatin1String("content.xml"), content.data());
 
     /*zipFile.close();*/
 }
 
 
 void Worksheet::savePlain(const QString& filename)
 {
     QFile file(filename);
     if(!file.open(QIODevice::WriteOnly))
     {
         KMessageBox::error(worksheetView(), i18n("Error saving file %1", filename), i18n("Error - Cantor"));
         return;
     }
 
     QString cmdSep=QLatin1String(";\n");
     QString commentStartingSeq = QLatin1String("");
     QString commentEndingSeq = QLatin1String("");
 
     Cantor::Backend * const backend=session()->backend();
     if (backend->extensions().contains(QLatin1String("ScriptExtension")))
     {
         Cantor::ScriptExtension* e=dynamic_cast<Cantor::ScriptExtension*>(backend->extension(QLatin1String(("ScriptExtension"))));
         cmdSep=e->commandSeparator();
         commentStartingSeq = e->commentStartingSequence();
         commentEndingSeq = e->commentEndingSequence();
     }
 
     QTextStream stream(&file);
 
     for(WorksheetEntry * entry = firstEntry(); entry; entry = entry->next())
     {
         const QString& str=entry->toPlain(cmdSep, commentStartingSeq, commentEndingSeq);
         if(!str.isEmpty())
             stream << str + QLatin1Char('\n');
     }
 
     file.close();
 }
 
 void Worksheet::saveLatex(const QString& filename)
 {
     qDebug()<<"exporting to Latex: " <<filename;
 
     QFile file(filename);
     if(!file.open(QIODevice::WriteOnly))
     {
         KMessageBox::error(worksheetView(), i18n("Error saving file %1", filename), i18n("Error - Cantor"));
         return;
     }
 
     QString xml = toXML().toString();
     QTextStream stream(&file);
     QXmlQuery query(QXmlQuery::XSLT20);
     query.setFocus(xml);
 
     QString stylesheet = QStandardPaths::locate(QStandardPaths::DataLocation, QLatin1String("xslt/latex.xsl"));
     if (stylesheet.isEmpty())
     {
         KMessageBox::error(worksheetView(), i18n("Error loading latex.xsl stylesheet"), i18n("Error - Cantor"));
         return;
     }
 
     query.setQuery(QUrl(stylesheet));
     QString out;
     if (query.evaluateTo(&out))
-        stream << out;
+        // Transform HTML escaped special characters to valid LaTeX characters (&, <, >)
+        stream << out.replace(QLatin1String("&amp;"), QLatin1String("&"))
+                     .replace(QLatin1String("&gt;"), QLatin1String(">"))
+                     .replace(QLatin1String("&lt;"), QLatin1String("<"));
     file.close();
 }
 
 bool Worksheet::load(const QString& filename )
 {
     QFile file(filename);
     if (!file.open(QIODevice::ReadOnly)) {
         KMessageBox::error(worksheetView(), i18n("Couldn't open the file %1", filename), i18n("Cantor"));
         return false;
     }
 
     bool rc = load(&file);
     if (rc)
         m_session->setWorksheetPath(filename);
 
     return rc;
 }
 
 void Worksheet::load(QByteArray* data)
 {
     QBuffer buf(data);
     load(&buf);
 }
 
 bool Worksheet::load(QIODevice* device)
 {
     KZip file(device);
     if (!file.open(QIODevice::ReadOnly)) {
         qDebug()<<"not a zip file";
         QApplication::restoreOverrideCursor();
         KMessageBox::error(worksheetView(), i18n("The selected file is not a valid Cantor project file."), i18n("Cantor"));
         return false;
     }
 
     const KArchiveEntry* contentEntry=file.directory()->entry(QLatin1String("content.xml"));
     if (!contentEntry->isFile())
     {
         qDebug()<<"content.xml file not found in the zip archive";
         QApplication::restoreOverrideCursor();
         KMessageBox::error(worksheetView(), i18n("The selected file is not a valid Cantor project file."), i18n("Cantor"));
         return false;
     }
 
     const KArchiveFile* content = static_cast<const KArchiveFile*>(contentEntry);
     QByteArray data = content->data();
 
 //     qDebug()<<"read: "<<data;
 
     QDomDocument doc;
     doc.setContent(data);
     QDomElement root=doc.documentElement();
 //     qDebug()<<root.tagName();
 
     const QString backendName=root.attribute(QLatin1String("backend"));
     Cantor::Backend* b=Cantor::Backend::createBackend(backendName);
     if (!b)
     {
         QApplication::restoreOverrideCursor();
         KMessageBox::error(worksheetView(), i18n("The backend with which this file was generated is not installed. It needs %1", backendName), i18n("Cantor"));
         return false;
     }
 
     if(!b->isEnabled())
     {
         QApplication::restoreOverrideCursor();
         KMessageBox::information(worksheetView(), i18n("There are some problems with the %1 backend,\n"\
                                             "please check your configuration or install the needed packages.\n"
                                             "You will only be able to view this worksheet.", backendName), i18n("Cantor"));
 
     }
 
     m_isLoadingFromFile = true;
 
     //cleanup the worksheet and all it contains
     delete m_session;
     m_session=nullptr;
     m_loginDone = false;
 
     //file can only be loaded in a worksheet that was not eidted/modified yet (s.a. CantorShell::load())
     //in this case on the default "first entry" is available -> delete it.
     if (m_firstEntry) {
         delete m_firstEntry;
         m_firstEntry = nullptr;
     }
 
     //delete all items from the scene
     clear();
 
     m_session=b->createSession();
 
     qDebug()<<"loading entries";
     QDomElement expressionChild = root.firstChildElement();
     WorksheetEntry* entry = nullptr;
     while (!expressionChild.isNull()) {
         QString tag = expressionChild.tagName();
         if (tag == QLatin1String("Expression"))
         {
             entry = appendCommandEntry();
             entry->setContent(expressionChild, file);
         } else if (tag == QLatin1String("Text"))
         {
             entry = appendTextEntry();
             entry->setContent(expressionChild, file);
         } else if (tag == QLatin1String("Latex"))
         {
             entry = appendLatexEntry();
             entry->setContent(expressionChild, file);
         } else if (tag == QLatin1String("PageBreak"))
         {
             entry = appendPageBreakEntry();
             entry->setContent(expressionChild, file);
         }
         else if (tag == QLatin1String("Image"))
         {
             entry = appendImageEntry();
             entry->setContent(expressionChild, file);
         }
 
         expressionChild = expressionChild.nextSiblingElement();
     }
 
     m_isLoadingFromFile = false;
 
     //Set the Highlighting, depending on the current state
     //If the session isn't logged in, use the default
     enableHighlighting( m_highlighter!=nullptr || Settings::highlightDefault() );
 
     emit sessionChanged();
     return true;
 }
 
 void Worksheet::gotResult(Cantor::Expression* expr)
 {
     if(expr==nullptr)
         expr=qobject_cast<Cantor::Expression*>(sender());
 
     if(expr==nullptr)
         return;
     //We're only interested in help results, others are handled by the WorksheetEntry
     if(expr->result()&&expr->result()->type()==Cantor::HelpResult::Type)
     {
         QString help=expr->result()->toHtml();
         //Do some basic LaTeX replacing
         help.replace(QRegExp(QLatin1String("\\\\code\\{([^\\}]*)\\}")), QLatin1String("<b>\\1</b>"));
         help.replace(QRegExp(QLatin1String("\\$([^\\$])\\$")), QLatin1String("<i>\\1</i>"));
 
         emit showHelp(help);
     }
 }
 
 void Worksheet::removeCurrentEntry()
 {
     qDebug()<<"removing current entry";
     WorksheetEntry* entry=currentEntry();
     if(!entry)
         return;
 
     // In case we just removed this
     if (entry->isAncestorOf(m_lastFocusedTextItem))
         m_lastFocusedTextItem = nullptr;
     entry->startRemoving();
 }
 
 EpsRenderer* Worksheet::epsRenderer()
 {
     return &m_epsRenderer;
 }
 
 QMenu* Worksheet::createContextMenu()
 {
     QMenu *menu = new QMenu(worksheetView());
     connect(menu, SIGNAL(aboutToHide()), menu, SLOT(deleteLater()));
 
     return menu;
 }
 
 void Worksheet::populateMenu(QMenu *menu, const QPointF& pos)
 {
     WorksheetEntry* entry = entryAt(pos);
     if (entry && !entry->isAncestorOf(m_lastFocusedTextItem)) {
         WorksheetTextItem* item =
             qgraphicsitem_cast<WorksheetTextItem*>(itemAt(pos, QTransform()));
         if (item && item->isEditable())
             m_lastFocusedTextItem = item;
     }
 
     if (!isRunning())
         menu->addAction(QIcon::fromTheme(QLatin1String("system-run")), i18n("Evaluate Worksheet"),
                         this, SLOT(evaluate()), 0);
     else
         menu->addAction(QIcon::fromTheme(QLatin1String("process-stop")), i18n("Interrupt"), this,
                         SLOT(interrupt()), 0);
     menu->addSeparator();
 
     if (entry) {
         QMenu* insert = new QMenu(menu);
         QMenu* insertBefore = new QMenu(menu);
 
         insert->addAction(i18n("Command Entry"), entry, SLOT(insertCommandEntry()));
         insert->addAction(i18n("Text Entry"), entry, SLOT(insertTextEntry()));
         insert->addAction(i18n("LaTeX Entry"), entry, SLOT(insertLatexEntry()));
         insert->addAction(i18n("Image"), entry, SLOT(insertImageEntry()));
         insert->addAction(i18n("Page Break"), entry, SLOT(insertPageBreakEntry()));
 
         insertBefore->addAction(i18n("Command Entry"), entry, SLOT(insertCommandEntryBefore()));
         insertBefore->addAction(i18n("Text Entry"), entry, SLOT(insertTextEntryBefore()));
         insertBefore->addAction(i18n("LaTeX Entry"), entry, SLOT(insertLatexEntryBefore()));
         insertBefore->addAction(i18n("Image"), entry, SLOT(insertImageEntryBefore()));
         insertBefore->addAction(i18n("Page Break"), entry, SLOT(insertPageBreakEntryBefore()));
 
         insert->setTitle(i18n("Insert"));
         insertBefore->setTitle(i18n("Insert Before"));
         menu->addMenu(insert);
         menu->addMenu(insertBefore);
     } else {
         menu->addAction(i18n("Insert Command Entry"), this, SLOT(appendCommandEntry()));
         menu->addAction(i18n("Insert Text Entry"), this, SLOT(appendTextEntry()));
         menu->addAction(i18n("Insert LaTeX Entry"), this, SLOT(appendLatexEntry()));
         menu->addAction(i18n("Insert Image"), this, SLOT(appendImageEntry()));
         menu->addAction(i18n("Insert Page Break"), this, SLOT(appendPageBreakEntry()));
     }
 }
 
 void Worksheet::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
 {
     // forward the event to the items
     QGraphicsScene::contextMenuEvent(event);
 
     if (!event->isAccepted()) {
         event->accept();
         QMenu *menu = createContextMenu();
         populateMenu(menu, event->scenePos());
 
         menu->popup(event->screenPos());
     }
 }
 
 void Worksheet::mousePressEvent(QGraphicsSceneMouseEvent* event)
 {
     QGraphicsScene::mousePressEvent(event);
     if (event->button() == Qt::LeftButton && !focusItem() && lastEntry() &&
         event->scenePos().y() > lastEntry()->y() + lastEntry()->size().height())
         lastEntry()->focusEntry(WorksheetTextItem::BottomRight);
 }
 
 void Worksheet::createActions(KActionCollection* collection)
 {
     // Mostly copied from KRichTextWidget::createActions(KActionCollection*)
     // It would be great if this wasn't necessary.
 
     // Text color
     QAction * action;
     /* This is "format-stroke-color" in KRichTextWidget */
     action = new QAction(QIcon::fromTheme(QLatin1String("format-text-color")),
                          i18nc("@action", "Text &Color..."), collection);
     action->setIconText(i18nc("@label text color", "Color"));
     action->setPriority(QAction::LowPriority);
     m_richTextActionList.append(action);
     collection->addAction(QLatin1String("format_text_foreground_color"), action);
     connect(action, SIGNAL(triggered()), this, SLOT(setTextForegroundColor()));
 
     // Text color
     action = new QAction(QIcon::fromTheme(QLatin1String("format-fill-color")),
                          i18nc("@action", "Text &Highlight..."), collection);
     action->setPriority(QAction::LowPriority);
     m_richTextActionList.append(action);
     collection->addAction(QLatin1String("format_text_background_color"), action);
     connect(action, SIGNAL(triggered()), this, SLOT(setTextBackgroundColor()));
 
     // Font Family
     m_fontAction = new KFontAction(i18nc("@action", "&Font"), collection);
     m_richTextActionList.append(m_fontAction);
     collection->addAction(QLatin1String("format_font_family"), m_fontAction);
     connect(m_fontAction, SIGNAL(triggered(QString)), this,
             SLOT(setFontFamily(QString)));
 
     // Font Size
     m_fontSizeAction = new KFontSizeAction(i18nc("@action", "Font &Size"),
                                            collection);
     m_richTextActionList.append(m_fontSizeAction);
     collection->addAction(QLatin1String("format_font_size"), m_fontSizeAction);
     connect(m_fontSizeAction, SIGNAL(fontSizeChanged(int)), this,
             SLOT(setFontSize(int)));
 
     // Bold
     m_boldAction = new KToggleAction(QIcon::fromTheme(QLatin1String("format-text-bold")),
                                      i18nc("@action boldify selected text", "&Bold"),
                                      collection);
     m_boldAction->setPriority(QAction::LowPriority);
     QFont bold;
     bold.setBold(true);
     m_boldAction->setFont(bold);
     m_richTextActionList.append(m_boldAction);
     collection->addAction(QLatin1String("format_text_bold"), m_boldAction);
     collection->setDefaultShortcut(m_boldAction, Qt::CTRL + Qt::Key_B);
     connect(m_boldAction, SIGNAL(triggered(bool)), this, SLOT(setTextBold(bool)));
 
     // Italic
     m_italicAction = new KToggleAction(QIcon::fromTheme(QLatin1String("format-text-italic")),
                                        i18nc("@action italicize selected text",
                                              "&Italic"),
                                        collection);
     m_italicAction->setPriority(QAction::LowPriority);
     QFont italic;
     italic.setItalic(true);
     m_italicAction->setFont(italic);
     m_richTextActionList.append(m_italicAction);
     collection->addAction(QLatin1String("format_text_italic"), m_italicAction);
     collection->setDefaultShortcut(m_italicAction, Qt::CTRL + Qt::Key_I);
     connect(m_italicAction, SIGNAL(triggered(bool)), this, SLOT(setTextItalic(bool)));
 
     // Underline
     m_underlineAction = new KToggleAction(QIcon::fromTheme(QLatin1String("format-text-underline")),
                                           i18nc("@action underline selected text",
                                                 "&Underline"),
                                           collection);
     m_underlineAction->setPriority(QAction::LowPriority);
     QFont underline;
     underline.setUnderline(true);
     m_underlineAction->setFont(underline);
     m_richTextActionList.append(m_underlineAction);
     collection->addAction(QLatin1String("format_text_underline"), m_underlineAction);
     collection->setDefaultShortcut(m_underlineAction, Qt::CTRL + Qt::Key_U);
     connect(m_underlineAction, SIGNAL(triggered(bool)), this, SLOT(setTextUnderline(bool)));
 
     // Strike
     m_strikeOutAction = new KToggleAction(QIcon::fromTheme(QLatin1String("format-text-strikethrough")),
                                           i18nc("@action", "&Strike Out"),
                                           collection);
     m_strikeOutAction->setPriority(QAction::LowPriority);
     m_richTextActionList.append(m_strikeOutAction);
     collection->addAction(QLatin1String("format_text_strikeout"), m_strikeOutAction);
     collection->setDefaultShortcut(m_strikeOutAction, Qt::CTRL + Qt::Key_L);
     connect(m_strikeOutAction, SIGNAL(triggered(bool)), this, SLOT(setTextStrikeOut(bool)));
 
     // Alignment
     QActionGroup *alignmentGroup = new QActionGroup(this);
 
     //   Align left
     m_alignLeftAction = new KToggleAction(QIcon::fromTheme(QLatin1String("format-justify-left")),
                                           i18nc("@action", "Align &Left"),
                                           collection);
     m_alignLeftAction->setPriority(QAction::LowPriority);
     m_alignLeftAction->setIconText(i18nc("@label left justify", "Left"));
     m_richTextActionList.append(m_alignLeftAction);
     collection->addAction(QLatin1String("format_align_left"), m_alignLeftAction);
     connect(m_alignLeftAction, SIGNAL(triggered()), this,
             SLOT(setAlignLeft()));
     alignmentGroup->addAction(m_alignLeftAction);
 
      //   Align center
     m_alignCenterAction = new KToggleAction(QIcon::fromTheme(QLatin1String("format-justify-center")),
                                             i18nc("@action", "Align &Center"),
                                             collection);
     m_alignCenterAction->setPriority(QAction::LowPriority);
     m_alignCenterAction->setIconText(i18nc("@label center justify", "Center"));
     m_richTextActionList.append(m_alignCenterAction);
     collection->addAction(QLatin1String("format_align_center"), m_alignCenterAction);
     connect(m_alignCenterAction, SIGNAL(triggered()), this,
             SLOT(setAlignCenter()));
     alignmentGroup->addAction(m_alignCenterAction);
 
     //   Align right
     m_alignRightAction = new KToggleAction(QIcon::fromTheme(QLatin1String("format-justify-right")),
                                            i18nc("@action", "Align &Right"),
                                            collection);
     m_alignRightAction->setPriority(QAction::LowPriority);
     m_alignRightAction->setIconText(i18nc("@label right justify", "Right"));
     m_richTextActionList.append(m_alignRightAction);
     collection->addAction(QLatin1String("format_align_right"), m_alignRightAction);
     connect(m_alignRightAction, SIGNAL(triggered()), this,
             SLOT(setAlignRight()));
     alignmentGroup->addAction(m_alignRightAction);
 
     //   Align justify
     m_alignJustifyAction = new KToggleAction(QIcon::fromTheme(QLatin1String("format-justify-fill")),
                                              i18nc("@action", "&Justify"),
                                              collection);
     m_alignJustifyAction->setPriority(QAction::LowPriority);
     m_alignJustifyAction->setIconText(i18nc("@label justify fill", "Justify"));
     m_richTextActionList.append(m_alignJustifyAction);
     collection->addAction(QLatin1String("format_align_justify"), m_alignJustifyAction);
     connect(m_alignJustifyAction, SIGNAL(triggered()), this,
             SLOT(setAlignJustify()));
     alignmentGroup->addAction(m_alignJustifyAction);
 
      /*
      // List style
      KSelectAction* selAction;
      selAction = new KSelectAction(QIcon::fromTheme("format-list-unordered"),
                                    i18nc("@title:menu", "List Style"),
                                    collection);
      QStringList listStyles;
      listStyles      << i18nc("@item:inmenu no list style", "None")
                      << i18nc("@item:inmenu disc list style", "Disc")
                      << i18nc("@item:inmenu circle list style", "Circle")
                      << i18nc("@item:inmenu square list style", "Square")
                      << i18nc("@item:inmenu numbered lists", "123")
                      << i18nc("@item:inmenu lowercase abc lists", "abc")
                      << i18nc("@item:inmenu uppercase abc lists", "ABC");
      selAction->setItems(listStyles);
      selAction->setCurrentItem(0);
      action = selAction;
      m_richTextActionList.append(action);
      collection->addAction("format_list_style", action);
      connect(action, SIGNAL(triggered(int)),
              this, SLOT(_k_setListStyle(int)));
      connect(action, SIGNAL(triggered()),
              this, SLOT(_k_updateMiscActions()));
 
      // Indent
      action = new QAction(QIcon::fromTheme("format-indent-more"),
                           i18nc("@action", "Increase Indent"), collection);
      action->setPriority(QAction::LowPriority);
      m_richTextActionList.append(action);
      collection->addAction("format_list_indent_more", action);
      connect(action, SIGNAL(triggered()),
              this, SLOT(indentListMore()));
      connect(action, SIGNAL(triggered()),
              this, SLOT(_k_updateMiscActions()));
 
      // Dedent
      action = new QAction(QIcon::fromTheme("format-indent-less"),
                           i18nc("@action", "Decrease Indent"), collection);
      action->setPriority(QAction::LowPriority);
      m_richTextActionList.append(action);
      collection->addAction("format_list_indent_less", action);
      connect(action, SIGNAL(triggered()), this, SLOT(indentListLess()));
      connect(action, SIGNAL(triggered()), this, SLOT(_k_updateMiscActions()));
      */
 }
 
 WorksheetTextItem* Worksheet::lastFocusedTextItem()
 {
     return m_lastFocusedTextItem;
 }
 
 void Worksheet::updateFocusedTextItem(WorksheetTextItem* newItem)
 {
     if (m_lastFocusedTextItem && m_lastFocusedTextItem != newItem) {
         disconnect(m_lastFocusedTextItem, SIGNAL(undoAvailable(bool)),
                    this, SIGNAL(undoAvailable(bool)));
         disconnect(m_lastFocusedTextItem, SIGNAL(redoAvailable(bool)),
                    this, SIGNAL(redoAvailable(bool)));
         disconnect(this, SIGNAL(undo()), m_lastFocusedTextItem, SLOT(undo()));
         disconnect(this, SIGNAL(redo()), m_lastFocusedTextItem, SLOT(redo()));
         disconnect(m_lastFocusedTextItem, SIGNAL(cutAvailable(bool)),
                    this, SIGNAL(cutAvailable(bool)));
         disconnect(m_lastFocusedTextItem, SIGNAL(copyAvailable(bool)),
                    this, SIGNAL(copyAvailable(bool)));
         disconnect(m_lastFocusedTextItem, SIGNAL(pasteAvailable(bool)),
                    this, SIGNAL(pasteAvailable(bool)));
         disconnect(this, SIGNAL(cut()), m_lastFocusedTextItem, SLOT(cut()));
         disconnect(this, SIGNAL(copy()), m_lastFocusedTextItem, SLOT(copy()));
         disconnect(this, SIGNAL(paste()), m_lastFocusedTextItem, SLOT(paste()));
 
         m_lastFocusedTextItem->clearSelection();
     }
 
     if (newItem && m_lastFocusedTextItem != newItem) {
         setAcceptRichText(newItem->richTextEnabled());
         emit undoAvailable(newItem->isUndoAvailable());
         emit redoAvailable(newItem->isRedoAvailable());
         connect(newItem, SIGNAL(undoAvailable(bool)),
                 this, SIGNAL(undoAvailable(bool)));
         connect(newItem, SIGNAL(redoAvailable(bool)),
                 this, SIGNAL(redoAvailable(bool)));
         connect(this, SIGNAL(undo()), newItem, SLOT(undo()));
         connect(this, SIGNAL(redo()), newItem, SLOT(redo()));
         emit cutAvailable(newItem->isCutAvailable());
         emit copyAvailable(newItem->isCopyAvailable());
         emit pasteAvailable(newItem->isPasteAvailable());
         connect(newItem, SIGNAL(cutAvailable(bool)),
                 this, SIGNAL(cutAvailable(bool)));
         connect(newItem, SIGNAL(copyAvailable(bool)),
                 this, SIGNAL(copyAvailable(bool)));
         connect(newItem, SIGNAL(pasteAvailable(bool)),
                 this, SIGNAL(pasteAvailable(bool)));
         connect(this, SIGNAL(cut()), newItem, SLOT(cut()));
         connect(this, SIGNAL(copy()), newItem, SLOT(copy()));
         connect(this, SIGNAL(paste()), newItem, SLOT(paste()));
     } else if (!newItem) {
         emit undoAvailable(false);
         emit redoAvailable(false);
         emit cutAvailable(false);
         emit copyAvailable(false);
         emit pasteAvailable(false);
     }
     m_lastFocusedTextItem = newItem;
 }
 
 void Worksheet::setRichTextInformation(const RichTextInfo& info)
 {
     m_boldAction->setChecked(info.bold);
     m_italicAction->setChecked(info.italic);
     m_underlineAction->setChecked(info.underline);
     m_strikeOutAction->setChecked(info.strikeOut);
     m_fontAction->setFont(info.font);
     if (info.fontSize > 0)
         m_fontSizeAction->setFontSize(info.fontSize);
 
     if (info.align & Qt::AlignLeft)
         m_alignLeftAction->setChecked(true);
     else if (info.align & Qt::AlignCenter)
         m_alignCenterAction->setChecked(true);
     else if (info.align & Qt::AlignRight)
         m_alignRightAction->setChecked(true);
     else if (info.align & Qt::AlignJustify)
         m_alignJustifyAction->setChecked(true);
 }
 
 void Worksheet::setAcceptRichText(bool b)
 {
     foreach(QAction * action, m_richTextActionList) {
         action->setEnabled(b);
     }
 
     /*
     foreach(QWidget* widget, m_fontAction->createdWidgets()) {
         widget->setEnabled(b);
     }
 
     foreach(QWidget* widget, m_fontSizeAction->createdWidgets()) {
         widget->setEnabled(b);
     }
     */
 }
 
 WorksheetTextItem* Worksheet::currentTextItem()
 {
     QGraphicsItem* item = focusItem();
     if (!item)
         item = m_lastFocusedTextItem;
     while (item && item->type() != WorksheetTextItem::Type)
         item = item->parentItem();
 
     return qgraphicsitem_cast<WorksheetTextItem*>(item);
 }
 
 void Worksheet::setTextForegroundColor()
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setTextForegroundColor();
 }
 
 void Worksheet::setTextBackgroundColor()
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setTextBackgroundColor();
 }
 
 void Worksheet::setTextBold(bool b)
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setTextBold(b);
 }
 
 void Worksheet::setTextItalic(bool b)
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setTextItalic(b);
 }
 
 void Worksheet::setTextUnderline(bool b)
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setTextUnderline(b);
 }
 
 void Worksheet::setTextStrikeOut(bool b)
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setTextStrikeOut(b);
 }
 
 void Worksheet::setAlignLeft()
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setAlignment(Qt::AlignLeft);
 }
 
 void Worksheet::setAlignRight()
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setAlignment(Qt::AlignRight);
 }
 
 void Worksheet::setAlignCenter()
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setAlignment(Qt::AlignCenter);
 }
 
 void Worksheet::setAlignJustify()
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setAlignment(Qt::AlignJustify);
 }
 
 void Worksheet::setFontFamily(QString font)
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setFontFamily(font);
 }
 
 void Worksheet::setFontSize(int size)
 {
     WorksheetTextItem* item = currentTextItem();
     if (item)
         item->setFontSize(size);
 }
 
 bool Worksheet::isShortcut(QKeySequence sequence)
 {
     return m_shortcuts.contains(sequence);
 }
 
 void Worksheet::registerShortcut(QAction* action)
 {
     foreach(QKeySequence shortcut, action->shortcuts()) {
         m_shortcuts.insert(shortcut, action);
     }
     connect(action, SIGNAL(changed()), this, SLOT(updateShortcut()));
 }
 
 void Worksheet::updateShortcut()
 {
     QAction* action = qobject_cast<QAction*>(sender());
     if (!action)
         return;
 
     // delete the old shortcuts of this action
     QList<QKeySequence> shortcuts = m_shortcuts.keys(action);
     foreach(QKeySequence shortcut, shortcuts) {
         m_shortcuts.remove(shortcut);
     }
     // add the new shortcuts
     foreach(QKeySequence shortcut, action->shortcuts()) {
         m_shortcuts.insert(shortcut, action);
     }
 }
 
 void Worksheet::dragEnterEvent(QGraphicsSceneDragDropEvent* event)
 {
     qDebug() << "enter";
     if (m_dragEntry)
         event->accept();
     else
         QGraphicsScene::dragEnterEvent(event);
 }
 
 void Worksheet::dragLeaveEvent(QGraphicsSceneDragDropEvent* event)
 {
     if (!m_dragEntry) {
         QGraphicsScene::dragLeaveEvent(event);
         return;
     }
 
     qDebug() << "leave";
     event->accept();
     if (m_placeholderEntry) {
         m_placeholderEntry->startRemoving();
         m_placeholderEntry = nullptr;
     }
 }
 
 void Worksheet::dragMoveEvent(QGraphicsSceneDragDropEvent* event)
 {
     if (!m_dragEntry) {
         QGraphicsScene::dragMoveEvent(event);
         return;
     }
 
     QPointF pos = event->scenePos();
     WorksheetEntry* entry = entryAt(pos);
     WorksheetEntry* prev = nullptr;
     WorksheetEntry* next = nullptr;
     if (entry) {
         if (pos.y() < entry->y() + entry->size().height()/2) {
             prev = entry->previous();
             next = entry;
         } else if (pos.y() >= entry->y() + entry->size().height()/2) {
             prev = entry;
             next = entry->next();
         }
     } else {
         WorksheetEntry* last = lastEntry();
         if (last && pos.y() > last->y() + last->size().height()) {
             prev = last;
             next = nullptr;
         }
     }
 
     if (prev || next) {
         PlaceHolderEntry* oldPlaceHolder = m_placeholderEntry;
         if (prev && prev->type() == PlaceHolderEntry::Type &&
             (!prev->aboutToBeRemoved() || prev->stopRemoving())) {
             m_placeholderEntry = qgraphicsitem_cast<PlaceHolderEntry*>(prev);
             m_placeholderEntry->changeSize(m_dragEntry->size());
         } else if (next && next->type() == PlaceHolderEntry::Type &&
                    (!next->aboutToBeRemoved() || next->stopRemoving())) {
             m_placeholderEntry = qgraphicsitem_cast<PlaceHolderEntry*>(next);
             m_placeholderEntry->changeSize(m_dragEntry->size());
         } else {
             m_placeholderEntry = new PlaceHolderEntry(this, QSizeF(0,0));
             m_placeholderEntry->setPrevious(prev);
             m_placeholderEntry->setNext(next);
             if (prev)
                 prev->setNext(m_placeholderEntry);
             else
                 setFirstEntry(m_placeholderEntry);
             if (next)
                 next->setPrevious(m_placeholderEntry);
             else
                 setLastEntry(m_placeholderEntry);
             m_placeholderEntry->changeSize(m_dragEntry->size());
         }
         if (oldPlaceHolder && oldPlaceHolder != m_placeholderEntry)
             oldPlaceHolder->startRemoving();
         updateLayout();
     }
 
     const QPoint viewPos = worksheetView()->mapFromScene(pos);
     const int viewHeight = worksheetView()->viewport()->height();
     if ((viewPos.y() < 10 || viewPos.y() > viewHeight - 10) &&
         !m_dragScrollTimer) {
         m_dragScrollTimer = new QTimer(this);
         m_dragScrollTimer->setSingleShot(true);
         m_dragScrollTimer->setInterval(100);
         connect(m_dragScrollTimer, SIGNAL(timeout()), this,
                 SLOT(updateDragScrollTimer()));
         m_dragScrollTimer->start();
     }
 
     event->accept();
 }
 
 void Worksheet::dropEvent(QGraphicsSceneDragDropEvent* event)
 {
     if (!m_dragEntry)
         QGraphicsScene::dropEvent(event);
     event->accept();
 }
 
 void Worksheet::updateDragScrollTimer()
 {
     if (!m_dragScrollTimer)
         return;
 
     const QPoint viewPos = worksheetView()->viewCursorPos();
     const QWidget* viewport = worksheetView()->viewport();
     const int viewHeight = viewport->height();
     if (!m_dragEntry || !(viewport->rect().contains(viewPos)) ||
         (viewPos.y() >= 10 && viewPos.y() <= viewHeight - 10)) {
         delete m_dragScrollTimer;
         m_dragScrollTimer = nullptr;
         return;
     }
 
     if (viewPos.y() < 10)
         worksheetView()->scrollBy(-10*(10 - viewPos.y()));
     else
         worksheetView()->scrollBy(10*(viewHeight - viewPos.y()));
 
     m_dragScrollTimer->start();
 }