diff --git a/src/cantor.cpp b/src/cantor.cpp
index 801ae089..47def5fe 100644
--- a/src/cantor.cpp
+++ b/src/cantor.cpp
@@ -1,640 +1,640 @@
 /*
     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.h"
 
 #include <KActionCollection>
 #include <KConfigDialog>
 #include <KConfigGroup>
 #include <KMessageBox>
 #include <KShortcutsDialog>
 #include <KStandardAction>
 #include <KNS3/DownloadDialog>
 #include <KParts/ReadWritePart>
 
 #include <QApplication>
 #include <QCloseEvent>
 #include <QDebug>
 #include <QDockWidget>
 #include <QDir>
 #include <QFileDialog>
 #include <QPushButton>
 #include <QGraphicsView>
 
 #include "lib/backend.h"
 #include "lib/panelpluginhandler.h"
 #include "lib/panelplugin.h"
 #include "lib/worksheetaccess.h"
 
 #include "settings.h"
 #include "ui_settings.h"
 #include "backendchoosedialog.h"
 
 CantorShell::CantorShell() : KParts::MainWindow(), m_part(nullptr)
 {
     // set the shell's ui resource file
     setXMLFile(QLatin1String("cantor_shell.rc"));
 
     // then, setup our actions
     setupActions();
 
     createGUI(nullptr);
 
     m_tabWidget=new QTabWidget(this);
     m_tabWidget->setTabsClosable(true);
     m_tabWidget->setMovable(true);
     m_tabWidget->setDocumentMode(true);
     setCentralWidget(m_tabWidget);
 
     connect(m_tabWidget, SIGNAL(currentChanged(int)), this, SLOT(activateWorksheet(int)));
     connect(m_tabWidget, SIGNAL(tabCloseRequested(int)), this, SLOT(closeTab(int)));
 
     // apply the saved mainwindow settings, if any, and ask the mainwindow
     // to automatically save settings if changed: window size, toolbar
     // position, icon size, etc.
     setAutoSaveSettings();
 
     setDockOptions(QMainWindow::AnimatedDocks|QMainWindow::AllowTabbedDocks|QMainWindow::VerticalTabs);
 }
 
 void CantorShell::load(const QUrl &url)
 {
     if (!m_part||!m_part->url().isEmpty() || m_part->isModified() )
     {
         addWorksheet(QLatin1String("null"));
         m_tabWidget->setCurrentIndex(m_parts.size()-1);
     }
     m_part->openUrl( url );
 }
 
 bool CantorShell::hasAvailableBackend()
 {
     bool hasBackend=false;
     foreach(Cantor::Backend* b, Cantor::Backend::availableBackends())
     {
         if(b->isEnabled())
             hasBackend=true;
     }
 
     return hasBackend;
 }
 
 void CantorShell::setupActions()
 {
     QAction* openNew = KStandardAction::openNew(this, SLOT(fileNew()), actionCollection());
     openNew->setPriority(QAction::LowPriority);
     QAction* open = KStandardAction::open(this, SLOT(fileOpen()), actionCollection());
     open->setPriority(QAction::LowPriority);
 
     KStandardAction::close (this,  SLOT(closeTab()),  actionCollection());
 
     KStandardAction::quit(qApp, SLOT(closeAllWindows()), actionCollection());
 
     createStandardStatusBarAction();
     //setStandardToolBarMenuEnabled(true);
 
     KStandardAction::keyBindings(this, SLOT(optionsConfigureKeys()), actionCollection());
     KStandardAction::configureToolbars(this, SLOT(configureToolbars()), actionCollection());
 
     KStandardAction::preferences(this, SLOT(showSettings()), actionCollection());
 
     QAction * downloadExamples = new QAction(i18n("Download Example Worksheets"), actionCollection());
     downloadExamples->setIcon(QIcon::fromTheme(QLatin1String("get-hot-new-stuff")));
     actionCollection()->addAction(QLatin1String("file_example_download"),  downloadExamples);
     connect(downloadExamples, SIGNAL(triggered()), this,  SLOT(downloadExamples()));
 
     QAction * openExample =new QAction(i18n("&Open Example"), actionCollection());
     openExample->setIcon(QIcon::fromTheme(QLatin1String("document-open")));
     actionCollection()->addAction(QLatin1String("file_example_open"), openExample);
     connect(openExample, SIGNAL(triggered()), this, SLOT(openExample()));
 
     QAction* toPreviousTab = new QAction(i18n("Go to previous worksheet"), actionCollection());
     actionCollection()->addAction(QLatin1String("go_to_previous_tab"), toPreviousTab);
     actionCollection()->setDefaultShortcut(toPreviousTab, Qt::CTRL+Qt::Key_PageDown);
     connect(toPreviousTab, &QAction::triggered, toPreviousTab, [this](){
         const int index = m_tabWidget->currentIndex()-1;
         if (index >= 0)
             m_tabWidget->setCurrentIndex(index);
         else
             m_tabWidget->setCurrentIndex(m_tabWidget->count()-1);
     });
     addAction(toPreviousTab);
 
     QAction* toNextTab = new QAction(i18n("Go to next worksheet"), actionCollection());
     actionCollection()->addAction(QLatin1String("go_to_next_tab"), toNextTab);
     actionCollection()->setDefaultShortcut(toNextTab, Qt::CTRL+Qt::Key_PageUp);
     connect(toNextTab, &QAction::triggered, toNextTab, [this](){
         const int index = m_tabWidget->currentIndex()+1;
         if (index < m_tabWidget->count())
             m_tabWidget->setCurrentIndex(index);
         else
             m_tabWidget->setCurrentIndex(0);
     });
     addAction(toNextTab);
 }
 
 void CantorShell::saveProperties(KConfigGroup & /*config*/)
 {
     // the 'config' object points to the session managed
     // config file.  anything you write here will be available
     // later when this app is restored
 }
 
 void CantorShell::readProperties(const KConfigGroup & /*config*/)
 {
     // the 'config' object points to the session managed
     // config file.  this function is automatically called whenever
     // the app is being restored.  read in here whatever you wrote
     // in 'saveProperties'
 }
 
 void CantorShell::fileNew()
 {
     if (sender()->inherits("QAction"))
     {
         QAction * a = qobject_cast<QAction*>(sender());
         QString backendName = a->data().toString();
         if (!backendName.isEmpty())
         {
             addWorksheet(backendName);
             return;
         }
     }
     addWorksheet();
 }
 
 void CantorShell::optionsConfigureKeys()
 {
     KShortcutsDialog dlg( KShortcutsEditor::AllActions, KShortcutsEditor::LetterShortcutsDisallowed, this );
     dlg.addCollection( actionCollection(), i18n("Cantor") );
     if (m_part)
         dlg.addCollection( m_part->actionCollection(), i18n("Cantor") );
     dlg.configure( true );
 }
 
 void CantorShell::fileOpen()
 {
     // this slot is called whenever the File->Open menu is selected,
     // the Open shortcut is pressed (usually CTRL+O) or the Open toolbar
     // button is clicked
-    QUrl url = QFileDialog::getOpenFileUrl(this, i18n("Open file"), QUrl(), i18n("Cantor Worksheet (*.cws)"));
+    QUrl url = QFileDialog::getOpenFileUrl(this, i18n("Open file"), QUrl(), i18n("Cantor Worksheet (*.cws);;Jupyter notebook (*.ipynb)"));
 
     if (url.isEmpty() == false)
     {
         // About this function, the style guide (
         // http://developer.kde.org/documentation/standards/kde/style/basics/index.html )
         // says that it should open a new window if the document is _not_
         // in its initial state.  This is what we do here..
         /*if ( m_part->url().isEmpty() && ! m_part->isModified() )
         {
             // we open the file in this window...
             load( url );
         }
         else
         {
             // we open the file in a new window...
             CantorShell* newWin = new CantorShell;
             newWin->load( url );
             newWin->show();
             }*/
         load( url );
     }
 }
 
 void CantorShell::addWorksheet()
 {
     if(hasAvailableBackend()) //There is no point in asking for the backend, if no one is available
     {
         QString backend = Settings::self()->defaultBackend();
         if (backend.isEmpty())
         {
             QPointer<BackendChooseDialog> dlg=new BackendChooseDialog(this);
             if(dlg->exec())
             {
                 backend = dlg->backendName();
                 addWorksheet(backend);
             }
 
             delete dlg;
         }
         else
         {
             addWorksheet(backend);
         }
 
     }else
     {
         QTextBrowser *browser=new QTextBrowser(this);
         QString backendList=QLatin1String("<ul>");
         int backendListSize = 0;
         foreach(Cantor::Backend* b, Cantor::Backend::availableBackends())
         {
             if(!b->requirementsFullfilled()) //It's disabled because of misssing dependencies, not because of some other reason(like eg. nullbackend)
             {
                 backendList+=QString::fromLatin1("<li>%1: <a href=\"%2\">%2</a></li>").arg(b->name(), b->url());
                 ++backendListSize;
             }
         }
         browser->setHtml(i18np("<h1>No Backend Found</h1>\n"             \
                                "<div>You could try:\n"                   \
                                "  <ul>"                                  \
                                "    <li>Changing the settings in the config dialog;</li>" \
                                "    <li>Installing packages for the following program:</li>" \
                                "     %2 "                                \
                                "  </ul> "                                 \
                                "</div> "
                               , "<h1>No Backend Found</h1>\n"             \
                                "<div>You could try:\n"                   \
                                "  <ul>"                                  \
                                "    <li>Changing the settings in the config dialog;</li>" \
                                "    <li>Installing packages for one of the following programs:</li>" \
                                "     %2 "                                \
                                "  </ul> "                                 \
                                "</div> "
                               , backendListSize, backendList
                               ));
 
         browser->setObjectName(QLatin1String("ErrorMessage"));
         m_tabWidget->addTab(browser, i18n("Error"));
     }
 }
 
 void CantorShell::addWorksheet(const QString& backendName)
 {
     static int sessionCount=1;
 
     // this routine will find and load our Part.  it finds the Part by
     // name which is a bad idea usually.. but it's alright in this
     // case since our Part is made for this Shell
     KPluginFactory* factory = KPluginLoader(QLatin1String("cantorpart")).factory();
     if (factory)
     {
         Cantor::Backend* backend = Cantor::Backend::getBackend(backendName);
 
         if (backend)
         {
             if (backend->isEnabled() || backendName == QLatin1String("null"))
             {
                 // now that the Part is loaded, we cast it to a Part to get our hands on it
                 KParts::ReadWritePart* part = factory->create<KParts::ReadWritePart>(m_tabWidget, QVariantList()<<backendName);
                 if (part)
                 {
                     connect(part, SIGNAL(setCaption(QString,QIcon)), this, SLOT(setTabCaption(QString,QIcon)));
                     m_parts.append(part);
 
                     int tab = m_tabWidget->addTab(part->widget(), QIcon::fromTheme(backend->icon()), i18n("Session %1", sessionCount++));
                     m_tabWidget->setCurrentIndex(tab);
                     // Setting focus on worksheet view, because Qt clear focus of added widget inside addTab
                     // This fix https://bugs.kde.org/show_bug.cgi?id=395976
                     part->widget()->findChild<QGraphicsView*>()->setFocus();
                 }
                 else
                 {
                     qDebug()<<"error creating part ";
                 }
             }
             else
             {
                 KMessageBox::error(this, i18n("%1 backend installed, but inactive. Please check installation and Cantor settings", backendName), i18n("Cantor"));
             }
         }
         else
             KMessageBox::error(this, i18n("Backend %1 is not installed", backendName), i18n("Cantor"));
     }
     else
     {
         // if we couldn't find our Part, we exit since the Shell by
         // itself can't do anything useful
         KMessageBox::error(this, i18n("Could not find the Cantor Part."));
         qApp->quit();
         // we return here, cause qApp->quit() only means "exit the
         // next time we enter the event loop...
         return;
     }
 
 }
 
 void CantorShell::activateWorksheet(int index)
 {
     QObject* pluginHandler=m_part->findChild<QObject*>(QLatin1String("PanelPluginHandler"));
     if (pluginHandler)
         disconnect(pluginHandler,SIGNAL(pluginsChanged()), this, SLOT(updatePanel()));
 
     // Save part state before change worksheet
     if (m_part)
     {
         QStringList visiblePanelNames;
         foreach (QDockWidget* doc, m_panels)
         {
             if (doc->widget() && doc->widget()->isVisible())
                 visiblePanelNames << doc->objectName();
         }
         m_pluginsVisibility[m_part] = visiblePanelNames;
     }
 
     m_part=findPart(m_tabWidget->widget(index));
     if(m_part)
     {
         createGUI(m_part);
 
         QObject* pluginHandler=m_part->findChild<QObject*>(QLatin1String("PanelPluginHandler"));
         connect(pluginHandler, SIGNAL(pluginsChanged()), this, SLOT(updatePanel()));
         updatePanel();
     }
     else
         qDebug()<<"selected part doesn't exist";
 
     m_tabWidget->setCurrentIndex(index);
 }
 
 void CantorShell::setTabCaption(const QString& caption, const QIcon& icon)
 {
     if (caption.isEmpty()) return;
 
     KParts::ReadWritePart* part=dynamic_cast<KParts::ReadWritePart*>(sender());
     m_tabWidget->setTabText(m_tabWidget->indexOf(part->widget()), caption);
     m_tabWidget->setTabIcon(m_tabWidget->indexOf(part->widget()), icon);
 }
 
 void CantorShell::closeTab(int index)
 {
     if (!reallyClose(false))
     {
         return;
     }
 
     QWidget* widget = nullptr;
     if (index >= 0)
     {
         widget = m_tabWidget->widget(index);
     }
     else if (m_part)
     {
         widget = m_part->widget();
     }
 
     if (!widget)
     {
         qWarning() << "Could not find widget by tab index" << index;
         return;
     }
 
 
     m_tabWidget->removeTab(index);
 
     if(widget->objectName()==QLatin1String("ErrorMessage"))
     {
         widget->deleteLater();
     }else
     {
         KParts::ReadWritePart* part= findPart(widget);
         if(part)
         {
             m_parts.removeAll(part);
             m_pluginsVisibility.remove(part);
             delete part;
         }
     }
     updatePanel();
 }
 
 bool CantorShell::reallyClose(bool checkAllParts) {
     if(checkAllParts && m_parts.count() > 1) {
         bool modified = false;
         foreach( KParts::ReadWritePart* const part, m_parts)
         {
             if(part->isModified()) {
                 modified = true;
                 break;
             }
         }
         if(!modified) return true;
         int want_save = KMessageBox::warningYesNo( this,
             i18n("Multiple unsaved Worksheets are opened. Do you want to close them?"),
             i18n("Close Cantor"));
         switch (want_save) {
             case KMessageBox::Yes:
                 return true;
             case KMessageBox::No:
                 return false;
         }
     }
     if (m_part && m_part->isModified() ) {
         int want_save = KMessageBox::warningYesNoCancel( this,
             i18n("The current project has been modified. Do you want to save it?"),
             i18n("Save Project"));
         switch (want_save) {
             case KMessageBox::Yes:
                 m_part->save();
                 if(m_part->waitSaveComplete()) {
                     return true;
                 } else {
                     m_part->setModified(true);
                     return false;
                 }
             case KMessageBox::Cancel:
                 return false;
             case KMessageBox::No:
                 return true;
         }
     }
     return true;
 }
 
 void CantorShell::closeEvent(QCloseEvent* event) {
     if(!reallyClose()) {
         event->ignore();
     } else {
         KParts::MainWindow::closeEvent(event);
     }
 }
 
 void CantorShell::showSettings()
 {
     KConfigDialog *dialog = new KConfigDialog(this,  QLatin1String("settings"), Settings::self());
     QWidget *generalSettings = new QWidget;
     Ui::SettingsBase base;
     base.setupUi(generalSettings);
     base.kcfg_DefaultBackend->addItems(Cantor::Backend::listAvailableBackends());
 
     dialog->addPage(generalSettings, i18n("General"), QLatin1String("preferences-other"));
     foreach(Cantor::Backend* backend, Cantor::Backend::availableBackends())
     {
         if (backend->config()) //It has something to configure, so add it to the dialog
             dialog->addPage(backend->settingsWidget(dialog), backend->config(), backend->name(),  backend->icon());
     }
 
     dialog->show();
 }
 
 void CantorShell::downloadExamples()
 {
     KNS3::DownloadDialog dialog;
     dialog.exec();
     foreach (const KNS3::Entry& e,  dialog.changedEntries())
     {
         qDebug() << "Changed Entry: " << e.name();
     }
 }
 
 void CantorShell::openExample()
 {
     QString dir = QStandardPaths::writableLocation(QStandardPaths::DataLocation) + QLatin1String("/examples");
     if (dir.isEmpty()) return;
     QDir().mkpath(dir);
 
     QStringList files=QDir(dir).entryList(QDir::Files);
     QPointer<QDialog> dlg=new QDialog(this);
     QListWidget* list=new QListWidget(dlg);
     foreach(const QString& file, files)
     {
         QString name=file;
         name.remove(QRegExp(QLatin1String("-.*\\.hotstuff-access$")));
         list->addItem(name);
     }
 
     QVBoxLayout *mainLayout = new QVBoxLayout;
     dlg->setLayout(mainLayout);
     mainLayout->addWidget(list);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 
     mainLayout->addWidget(buttonBox);
 
     buttonBox->button(QDialogButtonBox::Ok)->setIcon(QApplication::style()->standardIcon(QStyle::SP_DialogOkButton));
     buttonBox->button(QDialogButtonBox::Cancel)->setIcon(QApplication::style()->standardIcon(QStyle::SP_DialogCancelButton));
 
     connect(buttonBox, SIGNAL(accepted()), dlg, SLOT(accept()) );
     connect(buttonBox, SIGNAL(rejected()), dlg, SLOT(reject()) );
 
     if (dlg->exec()==QDialog::Accepted&&list->currentRow()>=0)
     {
         const QString& selectedFile=files[list->currentRow()];
         QUrl url = QUrl::fromLocalFile(QDir(dir).absoluteFilePath(selectedFile));
 
         qDebug()<<"loading file "<<url;
         load(url);
     }
 
     delete dlg;
 }
 
 KParts::ReadWritePart* CantorShell::findPart(QWidget* widget)
 {
     foreach( KParts::ReadWritePart* const part, m_parts)
     {
         if(part->widget()==widget)
             return part;
     }
     return nullptr;
 }
 
 void CantorShell::updatePanel()
 {
     unplugActionList(QLatin1String("view_show_panel_list"));
 
     //remove all of the previous panels (but do not delete the widgets)
     foreach(QDockWidget* dock, m_panels)
     {
         QWidget* widget=dock->widget();
         if(widget!=nullptr)
         {
             widget->setParent(this);
             widget->hide();
         }
         dock->deleteLater();
     }
     m_panels.clear();
 
     QList<QAction*> panelActions;
 
     Cantor::PanelPluginHandler* handler=m_part->findChild<Cantor::PanelPluginHandler*>(QLatin1String("PanelPluginHandler"));
     if(!handler)
     {
         qDebug()<<"no PanelPluginHandle found for this part";
         return;
     }
 
     QDockWidget* last=nullptr;
 
     QList<Cantor::PanelPlugin*> plugins=handler->plugins();
     const bool isNewWorksheet = !m_pluginsVisibility.contains(m_part);
     foreach(Cantor::PanelPlugin* plugin, plugins)
     {
         if(plugin==nullptr)
         {
             qDebug()<<"somethings wrong";
             continue;
         }
 
         qDebug()<<"adding panel for "<<plugin->name();
         plugin->setParentWidget(this);
 
         QDockWidget* docker=new QDockWidget(plugin->name(), this);
         docker->setObjectName(plugin->name());
         docker->setWidget(plugin->widget());
         addDockWidget ( Qt::RightDockWidgetArea,  docker );
 
         // Set visibility for dock from saved info
         if (!isNewWorksheet)
             if (m_pluginsVisibility[m_part].contains(plugin->name()))
                 docker->show();
             else
                 docker->hide();
         else
             docker->show();
 
         if(last!=nullptr)
             tabifyDockWidget(last, docker);
         last=docker;
 
         connect(plugin, SIGNAL(visibilityRequested()), docker, SLOT(raise()));
 
         m_panels.append(docker);
 
         //Create the action to show/hide this panel
         panelActions<<docker->toggleViewAction();
 
     }
 
     plugActionList(QLatin1String("view_show_panel_list"), panelActions);
 
     unplugActionList(QLatin1String("new_worksheet_with_backend_list"));
     QList<QAction*> newBackendActions;
     foreach (Cantor::Backend* backend, Cantor::Backend::availableBackends())
     {
         if (!backend->isEnabled())
             continue;
         QAction * action = new QAction(QIcon::fromTheme(backend->icon()), backend->name(), nullptr);
         action->setData(backend->name());
         connect(action, SIGNAL(triggered()), this, SLOT(fileNew()));
         newBackendActions << action;
     }
     plugActionList(QLatin1String("new_worksheet_with_backend_list"), newBackendActions);
 }
 
 Cantor::WorksheetAccessInterface* CantorShell::currentWorksheetAccessInterface()
 {
     Cantor::WorksheetAccessInterface* wa=m_part->findChild<Cantor::WorksheetAccessInterface*>(Cantor::WorksheetAccessInterface::Name);
 
     if (!wa)
         qDebug()<<"failed to access worksheet access interface for current part";
 
     return wa;
 }
diff --git a/src/cantor_part.cpp b/src/cantor_part.cpp
index 30d32538..28c1e83e 100644
--- a/src/cantor_part.cpp
+++ b/src/cantor_part.cpp
@@ -1,960 +1,960 @@
 /*
     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 <KXMLGUIFactory>
 
 #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
 {
 
   public:
     WorksheetAccessInterfaceImpl(QObject* parent, Worksheet* worksheet) :   WorksheetAccessInterface(parent),  m_worksheet(worksheet)
     {
         qDebug()<<"new worksheetaccess interface";
         connect(worksheet, SIGNAL(modified()), this, SIGNAL(modified()));
     }
 
     ~WorksheetAccessInterfaceImpl() override = default;
 
     QByteArray saveWorksheetToByteArray() override
     {
         return m_worksheet->saveToByteArray();
     }
 
     void loadWorksheetFromByteArray(QByteArray* data) override
     {
         m_worksheet->load(data);
     }
 
     Cantor::Session* session() override
     {
         return m_worksheet->session();
     }
 
   void evaluate() override
     {
         m_worksheet->evaluate();
     }
 
     void interrupt() 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),
     m_sessionStatusCounter(0)
 {
     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();
 
     for (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::getBackend(backendName);
     qDebug()<<"Backend "<<b->name()<<" offers extensions: "<<b->extensions();
 
 
     auto* collection = actionCollection();
 
     //central widget
     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(QString)), this, SIGNAL(showHelp(QString)));
     connect(m_worksheet, SIGNAL(loaded()), this, SLOT(initialized()));
     connect(collection, SIGNAL(inserted(QAction*)), m_worksheet, SLOT(registerShortcut(QAction*)));
     layout->addWidget(m_worksheetview);
     setWidget(widget);
 
     //create WorksheetAccessInterface, used at the moment by LabPlot only to access Worksheet's API
     Cantor::WorksheetAccessInterface* iface = new WorksheetAccessInterfaceImpl(this, m_worksheet);
     Q_UNUSED(iface);
 
     //initialize actions
     m_worksheet->createActions(collection);
 
     KStandardAction::saveAs(this, SLOT(fileSaveAs()), collection);
     m_save = KStandardAction::save(this, SLOT(save()), collection);
     m_save->setPriority(QAction::LowPriority);
 
     QAction* savePlain = new QAction(i18n("Save Plain Text"), collection);
     collection->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()), collection);
     undo->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(undoAvailable(bool)), undo, SLOT(setEnabled(bool)));
     m_editActions.push_back(undo);
 
     QAction* redo = KStandardAction::redo(m_worksheet, SIGNAL(redo()), collection);
     redo->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(redoAvailable(bool)), redo, SLOT(setEnabled(bool)));
     m_editActions.push_back(redo);
 
     QAction* cut = KStandardAction::cut(m_worksheet, SIGNAL(cut()), collection);
     cut->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(cutAvailable(bool)), cut, SLOT(setEnabled(bool)));
     m_editActions.push_back(cut);
 
     QAction* copy = KStandardAction::copy(m_worksheet, SIGNAL(copy()), collection);
     copy->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(copyAvailable(bool)), copy, SLOT(setEnabled(bool)));
 
     QAction* paste = KStandardAction::paste(m_worksheet, SLOT(paste()), collection);
     paste->setPriority(QAction::LowPriority);
     connect(m_worksheet, SIGNAL(pasteAvailable(bool)), paste, SLOT(setEnabled(bool)));
     m_editActions.push_back(paste);
 
     QAction* find = KStandardAction::find(this, SLOT(showSearchBar()), collection);
     find->setPriority(QAction::LowPriority);
 
     QAction* replace = KStandardAction::replace(this, SLOT(showExtendedSearchBar()), collection);
     replace->setPriority(QAction::LowPriority);
     m_editActions.push_back(replace);
 
     m_findNext = KStandardAction::findNext(this, SLOT(findNext()), collection);
     m_findNext->setEnabled(false);
 
     m_findPrev = KStandardAction::findPrev(this, SLOT(findPrev()), collection);
     m_findPrev->setEnabled(false);
 
     QAction* latexExport = new QAction(i18n("Export to LaTeX"), collection);
     collection->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()), collection);
     print->setPriority(QAction::LowPriority);
 
     QAction* printPreview = KStandardAction::printPreview(this, SLOT(printPreview()), collection);
     printPreview->setPriority(QAction::LowPriority);
 
     KStandardAction::zoomIn(m_worksheetview, SLOT(zoomIn()), collection);
     KStandardAction::zoomOut(m_worksheetview, SLOT(zoomOut()), collection);
     KStandardAction::actualSize(m_worksheetview, SLOT(actualSize()), collection);
 
     m_evaluate = new QAction(i18n("Evaluate Worksheet"), collection);
     collection->addAction(QLatin1String("evaluate_worksheet"), m_evaluate);
     m_evaluate->setIcon(QIcon::fromTheme(QLatin1String("system-run")));
     collection->setDefaultShortcut(m_evaluate, Qt::CTRL+Qt::Key_E);
     connect(m_evaluate, SIGNAL(triggered()), this, SLOT(evaluateOrInterrupt()));
     m_editActions.push_back(m_evaluate);
 
     m_typeset = new KToggleAction(i18n("Typeset using LaTeX"), collection);
     m_typeset->setChecked(Settings::self()->typesetDefault());
     // Disable until login, because we use session command for this action
     m_typeset->setEnabled(false);
     collection->addAction(QLatin1String("enable_typesetting"), m_typeset);
     connect(m_typeset, SIGNAL(toggled(bool)), this, SLOT(enableTypesetting(bool)));
 
     m_highlight = new KToggleAction(i18n("Syntax Highlighting"), collection);
     m_highlight->setChecked(Settings::self()->highlightDefault());
     collection->addAction(QLatin1String("enable_highlighting"), m_highlight);
     connect(m_highlight, SIGNAL(toggled(bool)), m_worksheet, SLOT(enableHighlighting(bool)));
 
     m_completion = new KToggleAction(i18n("Completion"), collection);
     m_completion->setChecked(Settings::self()->completionDefault());
     collection->addAction(QLatin1String("enable_completion"), m_completion);
     connect(m_completion, SIGNAL(toggled(bool)), m_worksheet, SLOT(enableCompletion(bool)));
 
     m_exprNumbering = new KToggleAction(i18n("Line Numbers"), collection);
     m_exprNumbering->setChecked(Settings::self()->expressionNumberingDefault());
     collection->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"), collection);
     m_animateWorksheet->setChecked(Settings::self()->animationDefault());
     collection->addAction(QLatin1String("enable_animations"), m_animateWorksheet);
     connect(m_animateWorksheet, SIGNAL(toggled(bool)), m_worksheet, SLOT(enableAnimations(bool)));
 
     m_restart = new QAction(i18n("Restart Backend"), collection);
     collection->addAction(QLatin1String("restart_backend"), m_restart);
     m_restart->setIcon(QIcon::fromTheme(QLatin1String("system-reboot")));
     connect(m_restart, SIGNAL(triggered()), this, SLOT(restartBackend()));
     m_restart->setEnabled(false); // No need show restart button before login
     m_editActions.push_back(m_restart);
 
     QAction* evaluateCurrent = new QAction(QIcon::fromTheme(QLatin1String("media-playback-start")), i18n("Evaluate Entry"), collection);
     collection->addAction(QLatin1String("evaluate_current"),  evaluateCurrent);
     collection->setDefaultShortcut(evaluateCurrent, Qt::SHIFT + Qt::Key_Return);
     connect(evaluateCurrent, SIGNAL(triggered()), m_worksheet, SLOT(evaluateCurrentEntry()));
     m_editActions.push_back(evaluateCurrent);
 
     QAction* insertCommandEntry = new QAction(QIcon::fromTheme(QLatin1String("run-build")), i18n("Insert Command Entry"), collection);
     collection->addAction(QLatin1String("insert_command_entry"),  insertCommandEntry);
     collection->setDefaultShortcut(insertCommandEntry, Qt::CTRL + Qt::Key_Return);
     connect(insertCommandEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertCommandEntry()));
     m_editActions.push_back(insertCommandEntry);
 
     QAction* insertTextEntry = new QAction(QIcon::fromTheme(QLatin1String("draw-text")), i18n("Insert Text Entry"), collection);
     collection->addAction(QLatin1String("insert_text_entry"),  insertTextEntry);
     connect(insertTextEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertTextEntry()));
     m_editActions.push_back(insertTextEntry);
 
 #ifdef Discount_FOUND
     QAction* insertMarkdownEntry = new QAction(QIcon::fromTheme(QLatin1String("text-x-markdown")), i18n("Insert Markdown Entry"), collection);
     collection->addAction(QLatin1String("insert_markdown_entry"),  insertMarkdownEntry);
     connect(insertMarkdownEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertMarkdownEntry()));
     m_editActions.push_back(insertMarkdownEntry);
 #endif
 
 #ifdef WITH_EPS
     QAction* insertLatexEntry = new QAction(QIcon::fromTheme(QLatin1String("text-x-tex")), i18n("Insert Latex Entry"), collection);
     collection->addAction(QLatin1String("insert_latex_entry"),  insertLatexEntry);
     connect(insertLatexEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertLatexEntry()));
     m_editActions.push_back(insertLatexEntry);
 #endif
 
     QAction* insertPageBreakEntry = new QAction(QIcon::fromTheme(QLatin1String("go-next-view-page")), i18n("Insert Page Break"), collection);
     collection->addAction(QLatin1String("insert_page_break_entry"), insertPageBreakEntry);
     connect(insertPageBreakEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertPageBreakEntry()));
     m_editActions.push_back(insertPageBreakEntry);
 
     QAction* insertImageEntry = new QAction(QIcon::fromTheme(QLatin1String("image-x-generic")), i18n("Insert Image"), collection);
     collection->addAction(QLatin1String("insert_image_entry"), insertImageEntry);
     connect(insertImageEntry, SIGNAL(triggered()), m_worksheet, SLOT(insertImageEntry()));
     m_editActions.push_back(insertImageEntry);
 
     QAction* removeCurrent = new QAction(QIcon::fromTheme(QLatin1String("edit-delete")), i18n("Remove current Entry"), collection);
     collection->addAction(QLatin1String("remove_current"), removeCurrent);
     collection->setDefaultShortcut(removeCurrent, Qt::ShiftModifier + Qt::Key_Delete);
     connect(removeCurrent, SIGNAL(triggered()), m_worksheet, SLOT(removeCurrentEntry()));
     m_editActions.push_back(removeCurrent);
 
     m_showBackendHelp = new QAction(i18n("Show %1 Help", b->name()) , collection);
     m_showBackendHelp->setIcon(QIcon::fromTheme(QLatin1String("help-contents")));
     collection->addAction(QLatin1String("backend_help"), m_showBackendHelp);
     connect(m_showBackendHelp, SIGNAL(triggered()), this, SLOT(showBackendHelp()));
 
     // Disabled, because uploading to kde store from program don't work
     // See https://phabricator.kde.org/T9980 for details
     // If this situation will changed, then uncomment this action
     /*
     QAction* publishWorksheet = new QAction(i18n("Publish Worksheet"), collection);
     publishWorksheet->setIcon(QIcon::fromTheme(QLatin1String("get-hot-new-stuff")));
     collection->addAction(QLatin1String("file_publish_worksheet"), publishWorksheet);
     connect(publishWorksheet, SIGNAL(triggered()), this, SLOT(publishWorksheet()));
     */
 
     KToggleAction* showEditor = new KToggleAction(i18n("Show Script Editor"), collection);
     showEditor->setChecked(false);
     collection->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"), collection);
     collection->addAction(QLatin1String("show_completion"), showCompletion);
     QList<QKeySequence> showCompletionShortcuts;
     showCompletionShortcuts << Qt::Key_Tab << Qt::CTRL + Qt::Key_Space;
     collection->setDefaultShortcuts(showCompletion, showCompletionShortcuts);
     connect(showCompletion, SIGNAL(triggered()), m_worksheet, SLOT(showCompletion()));
     m_editActions.push_back(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);
 
     initialized();
 }
 
 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::setReadOnly()
 {
     for (QAction* action : m_editActions)
         action->setEnabled(false);
 
     if (m_showBackendHelp)
     {
         m_showBackendHelp->setEnabled(false);
         m_showBackendHelp->setVisible(false);
     }
 }
 
 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
     m_save->setEnabled(modified);
 
     // 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).";
+        qDebug()<< "Worksheet successfully loaded in " <<  (float)timer.elapsed()/1000 << " seconds";
         updateCaption();
         // We modified, but it we load file now, so no need in save option
         setModified(false);
     }
 
     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 (!m_worksheet->isReadOnly())
     {
         //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+=QLatin1String(";;")+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()
 {
     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()
 {
     bool restart = false;
     if (Settings::self()->warnAboutSessionRestart())
     {
         KMessageBox::ButtonCode tmp;
 
         // If we want the question box, but it is disable, then enable it
         if (!KMessageBox::shouldBeShownYesNo(QLatin1String("WarnAboutSessionRestart"), tmp))
             KMessageBox::enableMessage(QLatin1String("WarnAboutSessionRestart"));
 
         const QString& name = m_worksheet->session()->backend()->name();
         KMessageBox::ButtonCode rc = KMessageBox::questionYesNo(widget(),
             i18n("All the available calculation results will be lost. Do you really want to restart %1?", name),
             i18n("Restart %1?", name),
             KStandardGuiItem::yes(),
             KStandardGuiItem::no(),
             QLatin1String("WarnAboutSessionRestart")
         );
 
         // Update setting's value
         Settings::self()->setWarnAboutSessionRestart(
             KMessageBox::shouldBeShownYesNo(QLatin1String("WarnAboutSessionRestart"), tmp));
         Settings::self()->save();
 
         restart = rc == KMessageBox::ButtonCode::Yes;
     }
     else
     {
         KMessageBox::ButtonCode rc;
         KMessageBox::shouldBeShownYesNo(QLatin1String("WarnAboutSessionRestart"), rc);
         restart = rc == KMessageBox::ButtonCode::Yes;
     }
 
     if (restart)
     {
         m_worksheet->session()->logout();
         m_worksheet->loginToSession();
     }
 }
 
 void CantorPart::worksheetStatusChanged(Cantor::Session::Status status)
 {
     qDebug()<<"wsStatusChange"<<status;
     unsigned int count = ++m_sessionStatusCounter;
     if(status==Cantor::Session::Running)
     {
         // Useless add a interrupt action without delay, because user physically can't interrupt fast commands
         QTimer::singleShot(100, this, [this, count] () {
             if(m_worksheet->session()->status() == Cantor::Session::Running && m_sessionStatusCounter == count)
             {
                 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 if (status==Cantor::Session::Done)
     {
         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::initialized()
 {
     if (!m_worksheet->isReadOnly())
     {
         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(QString)), this, SLOT(showSessionError(QString)));
 
         loadAssistants();
         m_panelHandler->setSession(m_worksheet->session());
         adjustGuiToSession();
 
         // Don't set modification flag, if we add command entry in empty worksheet
         const bool modified = this->isModified();
         if (m_worksheet->isEmpty())
             m_worksheet->appendCommandEntry();
         setModified(modified);
     }
     else
     {
         setReadOnly();
         // Clear assistants
         for (KXMLGUIClient* client: childClients())
         {
             Cantor::Assistant* assistant = dynamic_cast<Cantor::Assistant*>(client);
             if (assistant)
             {
                 factory()->removeClient(client);
                 removeChildClient(client);
                 assistant->deleteLater();
             }
         }
     }
 
     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"));
 
     m_typeset->setEnabled(true);
     m_restart->setEnabled(true);
 
     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");
 
     if (!m_worksheet->isReadOnly())
         emit setCaption(filename, QIcon::fromTheme(m_worksheet->session()->backend()->icon()));
     else
         emit setCaption(filename+QLatin1Char(' ')+i18n("[read-only]"), QIcon());
 }
 
 void CantorPart::pluginsChanged()
 {
     for (auto* plugin : m_panelHandler->plugins())
         connect(plugin, SIGNAL(requestRunCommand(QString)), this, SLOT(runCommand(QString)));
 }
 
 void CantorPart::loadAssistants()
 {
     qDebug()<<"loading assistants...";
 
     QStringList assistantDirs;
     for (const QString& dir : QCoreApplication::libraryPaths())
         assistantDirs << dir + QDir::separator() + QLatin1String("cantor/assistants");
 
     QPluginLoader loader;
     for (const QString& dir : assistantDirs) {
 
         qDebug() << "dir: " << dir;
         QStringList assistants;
         QDir assistantDir = QDir(dir);
 
         assistants = assistantDir.entryList();
 
         for (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);
 
             bool supported=true;
             for (const QString& req : plugin->requiredExtensions())
                 supported=supported && backend->extensions().contains(req);
 
             if(supported)
             {
                 qDebug() << "plugin " << info.name() << " is supported by " << backend->name() << ", requires extensions " << plugin->requiredExtensions();
                 plugin->initActions();
                 connect(plugin, SIGNAL(requested()), this, SLOT(runAssistant()));
             }else
             {
                 qDebug() << "plugin " << info.name() << " is not supported by "<<backend->name();
                 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()
 {
     Cantor::Backend::Capabilities capabilities = m_worksheet->session()->backend()->capabilities();
 #ifdef WITH_EPS
     m_typeset->setVisible(capabilities.testFlag(Cantor::Backend::LaTexOutput));
 #else
     m_typeset->setVisible(false);
 #endif
     m_completion->setVisible(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(QString)), this, SLOT(runScript(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/commandentry.cpp b/src/commandentry.cpp
index 4c28e045..a109420f 100644
--- a/src/commandentry.cpp
+++ b/src/commandentry.cpp
@@ -1,1209 +1,1223 @@
 /*
     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>
     Copyright (C) 2018 Alexander Semke <alexander.semke@web.de>
  */
 
 #include "commandentry.h"
 #include "resultitem.h"
 #include "loadedexpression.h"
 #include "lib/result.h"
 #include "lib/helpresult.h"
 #include "lib/completionobject.h"
 #include "lib/syntaxhelpobject.h"
 #include "lib/session.h"
 
 #include <QApplication>
 #include <QDebug>
 #include <QDesktopWidget>
 #include <QFontDialog>
 #include <QTimer>
 #include <QToolTip>
 #include <QPropertyAnimation>
 #include <QGraphicsWidget>
+#include <QJsonArray>
 
 #include <KLocalizedString>
 #include <KColorScheme>
 
 const QString CommandEntry::Prompt     = QLatin1String(">>> ");
 const QString CommandEntry::MidPrompt  = QLatin1String(">>  ");
 const QString CommandEntry::HidePrompt = QLatin1String(">   ");
 const double CommandEntry::HorizontalSpacing = 4;
 const double CommandEntry::VerticalSpacing = 4;
 
 static const int colorsCount = 26;
 static QColor colors[colorsCount] = {QColor(255,255,255), QColor(0,0,0),
 							QColor(192,0,0), QColor(255,0,0), QColor(255,192,192), //red
 							QColor(0,192,0), QColor(0,255,0), QColor(192,255,192), //green
 							QColor(0,0,192), QColor(0,0,255), QColor(192,192,255), //blue
 							QColor(192,192,0), QColor(255,255,0), QColor(255,255,192), //yellow
 							QColor(0,192,192), QColor(0,255,255), QColor(192,255,255), //cyan
 							QColor(192,0,192), QColor(255,0,255), QColor(255,192,255), //magenta
 							QColor(192,88,0), QColor(255,128,0), QColor(255,168,88), //orange
 							QColor(128,128,128), QColor(160,160,160), QColor(195,195,195) //grey
 							};
 
 
 CommandEntry::CommandEntry(Worksheet* worksheet) : WorksheetEntry(worksheet),
     m_promptItem(new WorksheetTextItem(this, Qt::NoTextInteraction)),
     m_commandItem(new WorksheetTextItem(this, Qt::TextEditorInteraction)),
     m_resultsCollapsed(false),
     m_errorItem(nullptr),
     m_expression(nullptr),
     m_completionObject(nullptr),
     m_syntaxHelpObject(nullptr),
     m_evaluationOption(DoNothing),
     m_menusInitialized(false),
     m_backgroundColorActionGroup(nullptr),
     m_backgroundColorMenu(nullptr),
     m_textColorActionGroup(nullptr),
     m_textColorMenu(nullptr),
     m_fontMenu(nullptr)
 {
 
     m_promptItem->setPlainText(Prompt);
     m_promptItem->setItemDragable(true);
     m_commandItem->enableCompletion(true);
 
     KColorScheme scheme = KColorScheme(QPalette::Normal, KColorScheme::View);
     m_commandItem->setBackgroundColor(scheme.background(KColorScheme::AlternateBackground).color());
 
     m_promptItemAnimation = new QPropertyAnimation(m_promptItem, "opacity");
     m_promptItemAnimation->setDuration(600);
     m_promptItemAnimation->setStartValue(1);
     m_promptItemAnimation->setKeyValueAt(0.5, 0);
     m_promptItemAnimation->setEndValue(1);
     connect(m_promptItemAnimation, &QPropertyAnimation::finished, this, &CommandEntry::animatePromptItem);
 
     connect(m_commandItem, &WorksheetTextItem::tabPressed, this, &CommandEntry::showCompletion);
     connect(m_commandItem, &WorksheetTextItem::backtabPressed, this, &CommandEntry::selectPreviousCompletion);
     connect(m_commandItem, &WorksheetTextItem::applyCompletion, this, &CommandEntry::applySelectedCompletion);
     connect(m_commandItem, SIGNAL(execute()), this, SLOT(evaluate()));
     connect(m_commandItem, &WorksheetTextItem::moveToPrevious, this, &CommandEntry::moveToPreviousItem);
     connect(m_commandItem, &WorksheetTextItem::moveToNext, this, &CommandEntry::moveToNextItem);
     connect(m_commandItem, SIGNAL(receivedFocus(WorksheetTextItem*)), worksheet, SLOT(highlightItem(WorksheetTextItem*)));
     connect(m_promptItem, &WorksheetTextItem::drag, this, &CommandEntry::startDrag);
     connect(worksheet, SIGNAL(updatePrompt()), this, SLOT(updatePrompt()));
 }
 
 CommandEntry::~CommandEntry()
 {
     if (m_completionBox)
         m_completionBox->deleteLater();
 }
 
 int CommandEntry::type() const
 {
     return Type;
 }
 
 void CommandEntry::initMenus() {
     //background color
 	const QString colorNames[colorsCount] = {i18n("White"), i18n("Black"),
 							i18n("Dark Red"), i18n("Red"), i18n("Light Red"),
 							i18n("Dark Green"), i18n("Green"), i18n("Light Green"),
 							i18n("Dark Blue"), i18n("Blue"), i18n("Light Blue"),
 							i18n("Dark Yellow"), i18n("Yellow"), i18n("Light Yellow"),
 							i18n("Dark Cyan"), i18n("Cyan"), i18n("Light Cyan"),
 							i18n("Dark Magenta"), i18n("Magenta"), i18n("Light Magenta"),
 							i18n("Dark Orange"), i18n("Orange"), i18n("Light Orange"),
 							i18n("Dark Grey"), i18n("Grey"), i18n("Light Grey")
 							};
 
     //background color
     m_backgroundColorActionGroup = new QActionGroup(this);
 	m_backgroundColorActionGroup->setExclusive(true);
 	connect(m_backgroundColorActionGroup, &QActionGroup::triggered, this, &CommandEntry::backgroundColorChanged);
 
     m_backgroundColorMenu = new QMenu(i18n("Background Color"));
     m_backgroundColorMenu->setIcon(QIcon::fromTheme(QLatin1String("format-fill-color")));
 
 	QPixmap pix(16,16);
 	QPainter p(&pix);
 	for (int i=0; i<colorsCount; ++i) {
 		p.fillRect(pix.rect(), colors[i]);
 		QAction* action = new QAction(QIcon(pix), colorNames[i], m_backgroundColorActionGroup);
 		action->setCheckable(true);
 		m_backgroundColorMenu->addAction(action);
 	}
 
 	//text color
     m_textColorActionGroup = new QActionGroup(this);
 	m_textColorActionGroup->setExclusive(true);
 	connect(m_textColorActionGroup, &QActionGroup::triggered, this, &CommandEntry::textColorChanged);
 
     m_textColorMenu = new QMenu(i18n("Text Color"));
     m_textColorMenu->setIcon(QIcon::fromTheme(QLatin1String("format-text-color")));
 
 	for (int i=0; i<colorsCount; ++i) {
 		p.fillRect(pix.rect(), colors[i]);
 		QAction* action = new QAction(QIcon(pix), colorNames[i], m_textColorActionGroup);
 		action->setCheckable(true);
 		m_textColorMenu->addAction(action);
 	}
 
 	//font
 	m_fontMenu = new QMenu(i18n("Font"));
     m_fontMenu->setIcon(QIcon::fromTheme(QLatin1String("preferences-desktop-font")));
 
     QAction* action = new QAction(QIcon::fromTheme(QLatin1String("format-text-bold")), i18n("Bold"));
     action->setCheckable(true);
     connect(action, &QAction::triggered, this, &CommandEntry::fontBoldTriggered);
     m_fontMenu->addAction(action);
 
     action = new QAction(QIcon::fromTheme(QLatin1String("format-text-italic")), i18n("Italic"));
     action->setCheckable(true);
     connect(action, &QAction::triggered, this, &CommandEntry::fontItalicTriggered);
     m_fontMenu->addAction(action);
     m_fontMenu->addSeparator();
 
     action = new QAction(QIcon::fromTheme(QLatin1String("format-font-size-less")), i18n("Increase Size"));
     connect(action, &QAction::triggered, this, &CommandEntry::fontIncreaseTriggered);
     m_fontMenu->addAction(action);
 
     action = new QAction(QIcon::fromTheme(QLatin1String("format-font-size-more")), i18n("Decrease Size"));
     connect(action, &QAction::triggered, this, &CommandEntry::fontDecreaseTriggered);
     m_fontMenu->addAction(action);
     m_fontMenu->addSeparator();
 
     action = new QAction(QIcon::fromTheme(QLatin1String("preferences-desktop-font")), i18n("Select"));
     connect(action, &QAction::triggered, this, &CommandEntry::fontSelectTriggered);
     m_fontMenu->addAction(action);
 
     m_menusInitialized = true;
 }
 
 void CommandEntry::backgroundColorChanged(QAction* action) {
 	int index = m_backgroundColorActionGroup->actions().indexOf(action);
 	if (index == -1 || index>=colorsCount)
 		index = 0;
 
     m_commandItem->setBackgroundColor(colors[index]);
 }
 
 void CommandEntry::textColorChanged(QAction* action) {
 	int index = m_textColorActionGroup->actions().indexOf(action);
 	if (index == -1 || index>=colorsCount)
 		index = 0;
 
     m_commandItem->setDefaultTextColor(colors[index]);
 }
 
 void CommandEntry::fontBoldTriggered()
 {
     QAction* action = static_cast<QAction*>(QObject::sender());
     QFont font = m_commandItem->font();
     font.setBold(action->isChecked());
     m_commandItem->setFont(font);
 }
 
 void CommandEntry::fontItalicTriggered()
 {
     QAction* action = static_cast<QAction*>(QObject::sender());
     QFont font = m_commandItem->font();
     font.setItalic(action->isChecked());
     m_commandItem->setFont(font);
 }
 
 void CommandEntry::fontIncreaseTriggered()
 {
     QFont font = m_commandItem->font();
     const int currentSize = font.pointSize();
     QFontDatabase fdb;
     QList<int> sizes = fdb.pointSizes(font.family(), font.styleName());
 
     for (int i = 0; i < sizes.size(); ++i)
     {
         const int size = sizes.at(i);
         if (currentSize == size)
         {
             if (i + 1 < sizes.size())
             {
                 font.setPointSize(sizes.at(i+1));
                 m_commandItem->setFont(font);
             }
 
             break;
         }
     }
 }
 
 void CommandEntry::fontDecreaseTriggered()
 {
     QFont font = m_commandItem->font();
     const int currentSize = font.pointSize();
     QFontDatabase fdb;
     QList<int> sizes = fdb.pointSizes(font.family(), font.styleName());
 
     for (int i = 0; i < sizes.size(); ++i)
     {
         const int size = sizes.at(i);
         if (currentSize == size)
         {
             if (i - 1 >= 0)
             {
                 font.setPointSize(sizes.at(i-1));
                 m_commandItem->setFont(font);
             }
 
             break;
         }
     }
 }
 
 void CommandEntry::fontSelectTriggered()
 {
     bool ok;
     QFont font = QFontDialog::getFont(&ok, m_commandItem->font(), nullptr);
 
     if (ok)
         m_commandItem->setFont(font);
 }
 
 void CommandEntry::populateMenu(QMenu* menu, QPointF pos)
 {
     if (!m_menusInitialized)
         initMenus();
 
     if (!m_resultItems.isEmpty()) {
         if (m_resultsCollapsed)
             menu->addAction(i18n("Show Results"), this, &CommandEntry::expandResults);
         else
             menu->addAction(i18n("Hide Results"), this, &CommandEntry::collapseResults);
     }
 
     menu->addMenu(m_backgroundColorMenu);
     menu->addMenu(m_textColorMenu);
     menu->addMenu(m_fontMenu);
     menu->addSeparator();
     WorksheetEntry::populateMenu(menu, pos);
 }
 
 void CommandEntry::moveToNextItem(int pos, qreal x)
 {
     WorksheetTextItem* item = qobject_cast<WorksheetTextItem*>(sender());
 
     if (!item)
         return;
 
     if (item == m_commandItem) {
         if (m_informationItems.isEmpty() ||
             !currentInformationItem()->isEditable())
             moveToNextEntry(pos, x);
         else
             currentInformationItem()->setFocusAt(pos, x);
     } else if (item == currentInformationItem()) {
         moveToNextEntry(pos, x);
     }
 }
 
 void CommandEntry::moveToPreviousItem(int pos, qreal x)
 {
     WorksheetTextItem* item = qobject_cast<WorksheetTextItem*>(sender());
 
     if (!item)
         return;
 
     if (item == m_commandItem || item == nullptr) {
         moveToPreviousEntry(pos, x);
     } else if (item == currentInformationItem()) {
         m_commandItem->setFocusAt(pos, x);
     }
 }
 
 QString CommandEntry::command()
 {
     QString cmd = m_commandItem->toPlainText();
     cmd.replace(QChar::ParagraphSeparator, QLatin1Char('\n')); //Replace the U+2029 paragraph break by a Normal Newline
     cmd.replace(QChar::LineSeparator, QLatin1Char('\n')); //Replace the line break by a Normal Newline
     return cmd;
 }
 
 void CommandEntry::setExpression(Cantor::Expression* expr)
 {
     /*
     if ( m_expression ) {
         if (m_expression->status() == Cantor::Expression::Computing) {
             qDebug() << "OLD EXPRESSION STILL ACTIVE";
             m_expression->interrupt();
         }
         m_expression->deleteLater();
         }*/
 
     // Delete any previous error
     if(m_errorItem)
     {
         m_errorItem->deleteLater();
         m_errorItem = nullptr;
     }
 
     foreach(WorksheetTextItem* item, m_informationItems)
     {
         item->deleteLater();
     }
     m_informationItems.clear();
 
     // Delete any previous result
     clearResultItems();
 
     m_expression = expr;
     m_resultsCollapsed = false;
 
     connect(expr, SIGNAL(gotResult()), this, SLOT(updateEntry()));
     connect(expr, SIGNAL(resultsCleared()), this, SLOT(clearResultItems()));
     connect(expr, SIGNAL(resultRemoved(int)), this, SLOT(removeResultItem(int)));
     connect(expr, SIGNAL(resultReplaced(int)), this, SLOT(replaceResultItem(int)));
     connect(expr, SIGNAL(idChanged()), this, SLOT(updatePrompt()));
     connect(expr, SIGNAL(statusChanged(Cantor::Expression::Status)), this, SLOT(expressionChangedStatus(Cantor::Expression::Status)));
     connect(expr, SIGNAL(needsAdditionalInformation(QString)), this, SLOT(showAdditionalInformationPrompt(QString)));
     connect(expr, SIGNAL(statusChanged(Cantor::Expression::Status)), this, SLOT(updatePrompt()));
 
     updatePrompt();
 
     if(expr->result())
     {
         worksheet()->gotResult(expr);
         updateEntry();
     }
 
     expressionChangedStatus(expr->status());
 }
 
 Cantor::Expression* CommandEntry::expression()
 {
     return m_expression;
 }
 
 bool CommandEntry::acceptRichText()
 {
     return false;
 }
 
 void CommandEntry::setContent(const QString& content)
 {
     m_commandItem->setPlainText(content);
 }
 
 void CommandEntry::setContent(const QDomElement& content, const KZip& file)
 {
     m_commandItem->setPlainText(content.firstChildElement(QLatin1String("Command")).text());
 
     LoadedExpression* expr=new LoadedExpression( worksheet()->session() );
     expr->loadFromXml(content, file);
 
     //background color
     QDomElement backgroundElem = content.firstChildElement(QLatin1String("Background"));
     if (!backgroundElem.isNull())
     {
         QColor color;
         color.setRed(backgroundElem.attribute(QLatin1String("red")).toInt());
         color.setGreen(backgroundElem.attribute(QLatin1String("green")).toInt());
         color.setBlue(backgroundElem.attribute(QLatin1String("blue")).toInt());
         m_commandItem->setBackgroundColor(color);
     }
 
     //text properties
     QDomElement textElem = content.firstChildElement(QLatin1String("Text"));
     if (!textElem.isNull())
     {
         //text color
         QDomElement colorElem = textElem.firstChildElement(QLatin1String("Color"));
         QColor color;
         color.setRed(colorElem.attribute(QLatin1String("red")).toInt());
         color.setGreen(colorElem.attribute(QLatin1String("green")).toInt());
         color.setBlue(colorElem.attribute(QLatin1String("blue")).toInt());
         m_commandItem->setDefaultTextColor(color);
 
         //font properties
         QDomElement fontElem = textElem.firstChildElement(QLatin1String("Font"));
         QFont font;
         font.setFamily(fontElem.attribute(QLatin1String("family")));
         font.setPointSize(fontElem.attribute(QLatin1String("pointSize")).toInt());
         font.setWeight(fontElem.attribute(QLatin1String("weight")).toInt());
         font.setItalic(fontElem.attribute(QLatin1String("italic")).toInt());
         m_commandItem->setFont(font);
     }
 
     setExpression(expr);
 }
 
+void CommandEntry::setContentFromJupyter(const QJsonObject& cell)
+{
+    //Jupyter TODO: handle missing key, like 'source', check that array, and string data inside
+    const QJsonArray& sources = cell.value(QLatin1String("source")).toArray();
+    QString code;
+    for (const QJsonValue& line : sources)
+        code += line.toString();
+    m_commandItem->setPlainText(code);
+
+    //Jupyter TODO: what about 'execution_count', ignore it?
+}
+
+
 void CommandEntry::showCompletion()
 {
     const QString line = currentLine();
 
     if(!worksheet()->completionEnabled() || line.trimmed().isEmpty())
     {
         if (m_commandItem->hasFocus())
             m_commandItem->insertTab();
         return;
     } else if (isShowingCompletionPopup()) {
         QString comp = m_completionObject->completion();
         qDebug() << "command" << m_completionObject->command();
         qDebug() << "completion" << comp;
         if (comp != m_completionObject->command()
             || !m_completionObject->hasMultipleMatches()) {
             if (m_completionObject->hasMultipleMatches()) {
                 completeCommandTo(comp, PreliminaryCompletion);
             } else {
                 completeCommandTo(comp, FinalCompletion);
                 m_completionBox->hide();
             }
         } else {
             m_completionBox->down();
         }
     } else {
         int p = m_commandItem->textCursor().positionInBlock();
         Cantor::CompletionObject* tco=worksheet()->session()->completionFor(line, p);
         if(tco)
             setCompletion(tco);
     }
 }
 
 void CommandEntry::selectPreviousCompletion()
 {
     if (isShowingCompletionPopup())
         m_completionBox->up();
 }
 
 QString CommandEntry::toPlain(const QString& commandSep, const QString& commentStartingSeq, const QString& commentEndingSeq)
 {
     Q_UNUSED(commentStartingSeq);
     Q_UNUSED(commentEndingSeq);
 
     if (command().isEmpty())
         return QString();
     return command() + commandSep;
 }
 
 QDomElement CommandEntry::toXml(QDomDocument& doc, KZip* archive)
 {
     QDomElement exprElem = doc.createElement( QLatin1String("Expression") );
     QDomElement cmdElem = doc.createElement( QLatin1String("Command") );
     cmdElem.appendChild(doc.createTextNode( command() ));
     exprElem.appendChild(cmdElem);
 
     // save results of the expression if they exist
     if (expression())
         for (Cantor::Result * const result: expression()->results())
         {
             const QDomElement& resultElem = result->toXml(doc);
             exprElem.appendChild(resultElem);
 
             if (archive)
                 result->saveAdditionalData(archive);
         }
 
     //save the background color if it differs from the default one
     const QColor& backgroundColor = m_commandItem->backgroundColor();
     KColorScheme scheme = KColorScheme(QPalette::Normal, KColorScheme::View);
     if (backgroundColor != scheme.background(KColorScheme::AlternateBackground).color())
     {
         QDomElement colorElem = doc.createElement( QLatin1String("Background") );
         colorElem.setAttribute(QLatin1String("red"), QString::number(backgroundColor.red()));
         colorElem.setAttribute(QLatin1String("green"), QString::number(backgroundColor.green()));
         colorElem.setAttribute(QLatin1String("blue"), QString::number(backgroundColor.blue()));
         exprElem.appendChild(colorElem);
     }
 
     //save the text properties if they differ from default values
     const QFont& font = m_commandItem->font();
     if (font != QFontDatabase::systemFont(QFontDatabase::FixedFont))
     {
         QDomElement textElem = doc.createElement(QLatin1String("Text"));
 
         //font properties
         QDomElement fontElem = doc.createElement(QLatin1String("Font"));
         fontElem.setAttribute(QLatin1String("family"), font.family());
         fontElem.setAttribute(QLatin1String("pointSize"), QString::number(font.pointSize()));
         fontElem.setAttribute(QLatin1String("weight"), QString::number(font.weight()));
         fontElem.setAttribute(QLatin1String("italic"), QString::number(font.italic()));
         textElem.appendChild(fontElem);
 
         //text color
         const QColor& textColor = m_commandItem->defaultTextColor();
         QDomElement colorElem = doc.createElement( QLatin1String("Color") );
         colorElem.setAttribute(QLatin1String("red"), QString::number(textColor.red()));
         colorElem.setAttribute(QLatin1String("green"), QString::number(textColor.green()));
         colorElem.setAttribute(QLatin1String("blue"), QString::number(textColor.blue()));
         textElem.appendChild(colorElem);
 
         exprElem.appendChild(textElem);
     }
 
     return exprElem;
 }
 
 QString CommandEntry::currentLine()
 {
     if (!m_commandItem->hasFocus())
         return QString();
 
     QTextBlock block = m_commandItem->textCursor().block();
     return block.text();
 }
 
 bool CommandEntry::evaluateCurrentItem()
 {
     // we can't use m_commandItem->hasFocus() here, because
     // that doesn't work when the scene doesn't have the focus,
     // e.g. when an assistant is used.
     if (m_commandItem == worksheet()->focusItem()) {
         return evaluate();
     } else if (informationItemHasFocus()) {
         addInformation();
         return true;
     }
 
     return false;
 }
 
 bool CommandEntry::evaluate(EvaluationOption evalOp)
 {
     removeContextHelp();
     QToolTip::hideText();
 
     QString cmd = command();
     m_evaluationOption = evalOp;
 
     if(cmd.isEmpty()) {
         removeResults();
         foreach(WorksheetTextItem* item, m_informationItems) {
             item->deleteLater();
         }
         m_informationItems.clear();
         recalculateSize();
 
         evaluateNext(m_evaluationOption);
         return false;
     }
 
     Cantor::Expression* expr;
     expr = worksheet()->session()->evaluateExpression(cmd);
     connect(expr, SIGNAL(gotResult()), worksheet(), SLOT(gotResult()));
 
     setExpression(expr);
 
     return true;
 }
 
 void CommandEntry::interruptEvaluation()
 {
     Cantor::Expression *expr = expression();
     if(expr)
         expr->interrupt();
 }
 
 void CommandEntry::updateEntry()
 {
     qDebug() << "update Entry";
     Cantor::Expression* expr = expression();
     if (expr == nullptr || expr->results().isEmpty())
         return;
 
     if (expr->results().last()->type() == Cantor::HelpResult::Type)
         return; // Help is handled elsewhere
 
     //CommandEntry::updateEntry() is only called if the worksheet view is resized
     //or when we got a new result(s).
     //In the second case the number of results and the number of result graphic objects is different
     //and we add a new graphic objects for the new result(s) (new result(s) are located in the end).
     if (m_resultItems.size() < expr->results().size())
     {
         if (m_resultsCollapsed)
             expandResults();
 
         for (int i = m_resultItems.size(); i < expr->results().size(); i++)
             m_resultItems << ResultItem::create(this, expr->results()[i]);
         animateSizeChange();
     }
 }
 
 void CommandEntry::expressionChangedStatus(Cantor::Expression::Status status)
 {
     switch (status)
     {
     case Cantor::Expression::Computing:
     {
         //change the background of the promt item and start animating it (fade in/out).
         //don't start the animation immediately in order to avoid unwanted flickering for "short" commands,
         //start the animation after 1 second passed.
         if (worksheet()->animationsEnabled())
         {
             const int id = m_expression->id();
             QTimer::singleShot(1000, this, [this, id] () {
                 if(m_expression->status() == Cantor::Expression::Computing && m_expression->id() == id)
                     m_promptItemAnimation->start();
             });
         }
         break;
     }
     case Cantor::Expression::Error:
     case Cantor::Expression::Interrupted:
         m_promptItemAnimation->stop();
         m_promptItem->setOpacity(1.);
 
         m_commandItem->setFocusAt(WorksheetTextItem::BottomRight, 0);
 
         if(!m_errorItem)
         {
             m_errorItem = new WorksheetTextItem(this, Qt::TextSelectableByMouse);
         }
 
         if (status == Cantor::Expression::Error)
             m_errorItem->setHtml(m_expression->errorMessage());
         else
             m_errorItem->setHtml(i18n("Interrupted"));
 
         recalculateSize();
         break;
     case Cantor::Expression::Done:
         m_promptItemAnimation->stop();
         m_promptItem->setOpacity(1.);
         evaluateNext(m_evaluationOption);
         m_evaluationOption = DoNothing;
         break;
     default:
         break;
     }
 }
 
 void CommandEntry::animatePromptItem() {
     if(m_expression->status() == Cantor::Expression::Computing)
         m_promptItemAnimation->start();
 }
 
 bool CommandEntry::isEmpty()
 {
     if (m_commandItem->toPlainText().trimmed().isEmpty()) {
         if (!m_resultItems.isEmpty())
             return false;
         return true;
     }
     return false;
 }
 
 bool CommandEntry::focusEntry(int pos, qreal xCoord)
 {
     if (aboutToBeRemoved())
         return false;
     WorksheetTextItem* item;
     if (pos == WorksheetTextItem::TopLeft || pos == WorksheetTextItem::TopCoord)
         item = m_commandItem;
     else if (m_informationItems.size() && currentInformationItem()->isEditable())
         item = currentInformationItem();
     else
         item = m_commandItem;
 
     item->setFocusAt(pos, xCoord);
     return true;
 }
 
 void CommandEntry::setCompletion(Cantor::CompletionObject* tc)
 {
     if (m_completionObject)
         delete m_completionObject;
 
     m_completionObject = tc;
     connect(m_completionObject, &Cantor::CompletionObject::done, this, &CommandEntry::showCompletions);
     connect(m_completionObject, &Cantor::CompletionObject::lineDone, this, &CommandEntry::completeLineTo);
 }
 
 void CommandEntry::showCompletions()
 {
     disconnect(m_completionObject, &Cantor::CompletionObject::done, this, &CommandEntry::showCompletions);
     QString completion = m_completionObject->completion();
     qDebug()<<"completion: "<<completion;
     qDebug()<<"showing "<<m_completionObject->allMatches();
 
     if(m_completionObject->hasMultipleMatches())
     {
         completeCommandTo(completion);
 
         QToolTip::showText(QPoint(), QString(), worksheetView());
         if (!m_completionBox)
                m_completionBox = new KCompletionBox(worksheetView());
 
         m_completionBox->clear();
         m_completionBox->setItems(m_completionObject->allMatches());
         QList<QListWidgetItem*> items = m_completionBox->findItems(m_completionObject->command(), Qt::MatchFixedString|Qt::MatchCaseSensitive);
         if (!items.empty())
             m_completionBox->setCurrentItem(items.first());
         m_completionBox->setTabHandling(false);
         m_completionBox->setActivateOnSelect(true);
         connect(m_completionBox.data(), &KCompletionBox::activated, this, &CommandEntry::applySelectedCompletion);
         connect(m_commandItem->document(), SIGNAL(contentsChanged()), this, SLOT(completedLineChanged()));
         connect(m_completionObject, &Cantor::CompletionObject::done, this, &CommandEntry::updateCompletions);
 
         m_commandItem->activateCompletion(true);
         m_completionBox->popup();
         m_completionBox->move(getPopupPosition());
     } else
     {
         completeCommandTo(completion, FinalCompletion);
     }
 }
 
 bool CommandEntry::isShowingCompletionPopup()
 {
     return m_completionBox && m_completionBox->isVisible();
 }
 
 void CommandEntry::applySelectedCompletion()
 {
     QListWidgetItem* item = m_completionBox->currentItem();
     if(item)
         completeCommandTo(item->text(), FinalCompletion);
     m_completionBox->hide();
 }
 
 void CommandEntry::completedLineChanged()
 {
     if (!isShowingCompletionPopup()) {
         // the completion popup is not visible anymore, so let's clean up
         removeContextHelp();
         return;
     }
     const QString line = currentLine();
     //FIXME: For some reason, this slot constantly triggeres, so I have added checking, is this update really needed
     if (line != m_completionObject->command())
         m_completionObject->updateLine(line, m_commandItem->textCursor().positionInBlock());
 }
 
 void CommandEntry::updateCompletions()
 {
     if (!m_completionObject)
         return;
     QString completion = m_completionObject->completion();
     qDebug()<<"completion: "<<completion;
     qDebug()<<"showing "<<m_completionObject->allMatches();
 
     if(m_completionObject->hasMultipleMatches() || !completion.isEmpty())
     {
         QToolTip::showText(QPoint(), QString(), worksheetView());
         m_completionBox->setItems(m_completionObject->allMatches());
         QList<QListWidgetItem*> items = m_completionBox->findItems(m_completionObject->command(), Qt::MatchFixedString|Qt::MatchCaseSensitive);
         if (!items.empty())
             m_completionBox->setCurrentItem(items.first());
         else if (m_completionBox->items().count() == 1)
             m_completionBox->setCurrentRow(0);
         else
             m_completionBox->clearSelection();
 
         m_completionBox->move(getPopupPosition());
     } else
     {
         removeContextHelp();
     }
 }
 
 void CommandEntry::completeCommandTo(const QString& completion, CompletionMode mode)
 {
     qDebug() << "completion: " << completion;
 
     Cantor::CompletionObject::LineCompletionMode cmode;
     if (mode == FinalCompletion) {
         cmode = Cantor::CompletionObject::FinalCompletion;
         Cantor::SyntaxHelpObject* obj = worksheet()->session()->syntaxHelpFor(completion);
         if(obj)
             setSyntaxHelp(obj);
     } else {
         cmode = Cantor::CompletionObject::PreliminaryCompletion;
         if(m_syntaxHelpObject)
             m_syntaxHelpObject->deleteLater();
         m_syntaxHelpObject=nullptr;
     }
 
     m_completionObject->completeLine(completion, cmode);
 }
 
 void CommandEntry::completeLineTo(const QString& line, int index)
 {
     qDebug() << "line completion: " << line;
     QTextCursor cursor = m_commandItem->textCursor();
     cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::MoveAnchor);
     cursor.movePosition(QTextCursor::StartOfBlock, QTextCursor::KeepAnchor);
     int startPosition = cursor.position();
     cursor.insertText(line);
     cursor.setPosition(startPosition + index);
     m_commandItem->setTextCursor(cursor);
 
     if (m_syntaxHelpObject) {
         m_syntaxHelpObject->fetchSyntaxHelp();
         // If we are about to show syntax help, then this was the final
         // completion, and we should clean up.
         removeContextHelp();
     }
 }
 
 void CommandEntry::setSyntaxHelp(Cantor::SyntaxHelpObject* sh)
 {
     if(m_syntaxHelpObject)
         m_syntaxHelpObject->deleteLater();
 
     m_syntaxHelpObject=sh;
     connect(sh, SIGNAL(done()), this, SLOT(showSyntaxHelp()));
 }
 
 void CommandEntry::showSyntaxHelp()
 {
     QString msg = m_syntaxHelpObject->toHtml();
     const QPointF cursorPos = m_commandItem->cursorPosition();
 
     // QToolTip don't support &nbsp;, but support multiple spaces
     msg.replace(QLatin1String("&nbsp;"), QLatin1String(" "));
     // Don't support &quot too;
     msg.replace(QLatin1String("&quot;"), QLatin1String("\""));
 
     QToolTip::showText(toGlobalPosition(cursorPos), msg, worksheetView());
 }
 
 void CommandEntry::resultDeleted()
 {
     qDebug()<<"result got removed...";
 }
 
 void CommandEntry::addInformation()
 {
     WorksheetTextItem *answerItem = currentInformationItem();
     answerItem->setTextInteractionFlags(Qt::TextSelectableByMouse);
 
     QString inf = answerItem->toPlainText();
     inf.replace(QChar::ParagraphSeparator, QLatin1Char('\n'));
     inf.replace(QChar::LineSeparator, QLatin1Char('\n'));
 
     qDebug()<<"adding information: "<<inf;
     if(m_expression)
         m_expression->addInformation(inf);
 }
 
 void CommandEntry::showAdditionalInformationPrompt(const QString& question)
 {
     WorksheetTextItem* questionItem = new WorksheetTextItem(this, Qt::TextSelectableByMouse);
     WorksheetTextItem* answerItem = new WorksheetTextItem(this, Qt::TextEditorInteraction);
 
     //change the color and the font for when asking for additional information in order to
     //better discriminate from the usual input in the command entry
     KColorScheme scheme = KColorScheme(QPalette::Normal, KColorScheme::View);
     QColor color = scheme.foreground(KColorScheme::PositiveText).color();
 
     QFont font;
     font.setItalic(true);
 
     questionItem->setFont(font);
     questionItem->setDefaultTextColor(color);
     answerItem->setFont(font);
     answerItem->setDefaultTextColor(color);
 
     questionItem->setPlainText(question);
 
     m_informationItems.append(questionItem);
     m_informationItems.append(answerItem);
     connect(answerItem, &WorksheetTextItem::moveToPrevious, this, &CommandEntry::moveToPreviousItem);
     connect(answerItem, &WorksheetTextItem::moveToNext, this, &CommandEntry::moveToNextItem);
 
     connect(answerItem, &WorksheetTextItem::execute, this, &CommandEntry::addInformation);
     answerItem->setFocus();
 
     recalculateSize();
 }
 
 void CommandEntry::removeResults()
 {
     //clear the Result objects
     if(m_expression)
         m_expression->clearResults();
 }
 
 void CommandEntry::removeResult(Cantor::Result* result)
 {
     if (m_expression)
         m_expression->removeResult(result);
 }
 
 void CommandEntry::removeResultItem(int index)
 {
     fadeOutItem(m_resultItems[index]->graphicsObject());
     m_resultItems.remove(index);
     recalculateSize();
 }
 
 void CommandEntry::clearResultItems()
 {
     //fade out all result graphic objects
     for(auto* item : m_resultItems)
         fadeOutItem(item->graphicsObject());
 
     m_resultItems.clear();
     recalculateSize();
 }
 
 void CommandEntry::replaceResultItem(int index)
 {
     ResultItem* previousItem = m_resultItems[index];
     m_resultItems[index] = ResultItem::create(this, m_expression->results()[index]);
     previousItem->deleteLater();
     recalculateSize();
 }
 
 void CommandEntry::removeContextHelp()
 {
     disconnect(m_commandItem->document(), SIGNAL(contentsChanged()), this, SLOT(completedLineChanged()));
 
     m_commandItem->activateCompletion(false);
     if (m_completionBox)
         m_completionBox->hide();
 }
 
 void CommandEntry::updatePrompt(const QString& postfix)
 {
     KColorScheme color = KColorScheme( QPalette::Normal, KColorScheme::View);
 
     m_promptItem->setPlainText(QLatin1String(""));
     QTextCursor c = m_promptItem->textCursor();
     QTextCharFormat cformat = c.charFormat();
 
     cformat.clearForeground();
     c.setCharFormat(cformat);
     cformat.setFontWeight(QFont::Bold);
 
     //insert the session id if available
     if(m_expression && worksheet()->showExpressionIds()&&m_expression->id()!=-1)
         c.insertText(QString::number(m_expression->id()),cformat);
 
     //detect the correct color for the prompt, depending on the
     //Expression state
     if(m_expression)
     {
         if(m_expression ->status() == Cantor::Expression::Computing&&worksheet()->isRunning())
             cformat.setForeground(color.foreground(KColorScheme::PositiveText));
         else if(m_expression ->status() == Cantor::Expression::Queued)
             cformat.setForeground(color.foreground(KColorScheme::InactiveText));
         else if(m_expression ->status() == Cantor::Expression::Error)
             cformat.setForeground(color.foreground(KColorScheme::NegativeText));
         else if(m_expression ->status() == Cantor::Expression::Interrupted)
             cformat.setForeground(color.foreground(KColorScheme::NeutralText));
         else
             cformat.setFontWeight(QFont::Normal);
     }
 
     c.insertText(postfix, cformat);
     recalculateSize();
 }
 
 WorksheetTextItem* CommandEntry::currentInformationItem()
 {
     if (m_informationItems.isEmpty())
         return nullptr;
     return m_informationItems.last();
 }
 
 bool CommandEntry::informationItemHasFocus()
 {
     if (m_informationItems.isEmpty())
         return false;
     return m_informationItems.last()->hasFocus();
 }
 
 bool CommandEntry::focusWithinThisItem()
 {
     return focusItem() != nullptr;
 }
 
 QPoint CommandEntry::getPopupPosition()
 {
     const QPointF cursorPos = m_commandItem->cursorPosition();
     const QPoint globalPos = toGlobalPosition(cursorPos);
     const QDesktopWidget* desktop = QApplication::desktop();
     const QRect screenRect = desktop->screenGeometry(globalPos);
     if (globalPos.y() + m_completionBox->height() < screenRect.bottom()) {
         return (globalPos);
     } else {
         QTextBlock block = m_commandItem->textCursor().block();
         QTextLayout* layout = block.layout();
         int pos = m_commandItem->textCursor().position() - block.position();
         QTextLine line = layout->lineForTextPosition(pos);
         int dy = - m_completionBox->height() - line.height() - line.leading();
         return QPoint(globalPos.x(), globalPos.y() + dy);
     }
 }
 
 void CommandEntry::invalidate()
 {
     qDebug() << "ToDo: Invalidate here";
 }
 
 bool CommandEntry::wantToEvaluate()
 {
     return !isEmpty();
 }
 
 QPoint CommandEntry::toGlobalPosition(QPointF localPos)
 {
     const QPointF scenePos = mapToScene(localPos);
     const QPoint viewportPos = worksheetView()->mapFromScene(scenePos);
     return worksheetView()->viewport()->mapToGlobal(viewportPos);
 }
 
 WorksheetCursor CommandEntry::search(const QString& pattern, unsigned flags,
                                      QTextDocument::FindFlags qt_flags,
                                      const WorksheetCursor& pos)
 {
     if (pos.isValid() && pos.entry() != this)
         return WorksheetCursor();
 
     WorksheetCursor p = pos;
     QTextCursor cursor;
     if (flags & WorksheetEntry::SearchCommand) {
         cursor = m_commandItem->search(pattern, qt_flags, p);
         if (!cursor.isNull())
             return WorksheetCursor(this, m_commandItem, cursor);
     }
 
     if (p.textItem() == m_commandItem)
         p = WorksheetCursor();
 
     if (m_errorItem && flags & WorksheetEntry::SearchError) {
         cursor = m_errorItem->search(pattern, qt_flags, p);
         if (!cursor.isNull())
             return WorksheetCursor(this, m_errorItem, cursor);
     }
 
     if (p.textItem() == m_errorItem)
         p = WorksheetCursor();
 
     for (auto* resultItem : m_resultItems)
     {
         WorksheetTextItem* textResult = dynamic_cast<WorksheetTextItem*>
             (resultItem);
         if (textResult && flags & WorksheetEntry::SearchResult) {
             cursor = textResult->search(pattern, qt_flags, p);
             if (!cursor.isNull())
                 return WorksheetCursor(this, textResult, cursor);
         }
     }
 
     return WorksheetCursor();
 }
 
 void CommandEntry::layOutForWidth(qreal w, bool force)
 {
     if (w == size().width() && !force)
         return;
 
     m_promptItem->setPos(0,0);
     double x = 0 + m_promptItem->width() + HorizontalSpacing;
     double y = 0;
     double width = 0;
 
     m_commandItem->setGeometry(x,y, w-x);
     width = qMax(width, m_commandItem->width());
 
     y += qMax(m_commandItem->height(), m_promptItem->height());
     foreach(WorksheetTextItem* information, m_informationItems) {
         y += VerticalSpacing;
         y += information->setGeometry(x,y,w-x);
         width = qMax(width, information->width());
     }
 
     if (m_errorItem) {
         y += VerticalSpacing;
         y += m_errorItem->setGeometry(x,y,w-x);
         width = qMax(width, m_errorItem->width());
     }
 
     for (auto* resultItem : m_resultItems)
     {
         if (!resultItem || !resultItem->graphicsObject()->isVisible())
             continue;
         y += VerticalSpacing;
         y += resultItem->setGeometry(x, y, w-x);
         width = qMax(width, resultItem->width());
     }
     y += VerticalMargin;
 
     QSizeF s(x+ width, y);
     if (animationActive()) {
         updateSizeAnimation(s);
     } else {
         setSize(s);
     }
 }
 
 void CommandEntry::startRemoving()
 {
     m_promptItem->setItemDragable(false);
     WorksheetEntry::startRemoving();
 }
 
 WorksheetTextItem* CommandEntry::highlightItem()
 {
     return m_commandItem;
 }
 
 void CommandEntry::collapseResults()
 {
     for(auto* item : m_resultItems) {
         fadeOutItem(item->graphicsObject(), nullptr);
         item->graphicsObject()->hide();
     }
 
     m_resultsCollapsed = true;
 
     if (worksheet()->animationsEnabled())
     {
         QTimer::singleShot(100, this, &CommandEntry::setMidPrompt);
         QTimer::singleShot(200, this, &CommandEntry::setHidePrompt);
     }
     else
         setHidePrompt();
 
     animateSizeChange();
 }
 
 void CommandEntry::expandResults()
 {
     for(auto* item : m_resultItems) {
         fadeInItem(item->graphicsObject(), nullptr);
         item->graphicsObject()->show();
     }
 
     m_resultsCollapsed = false;
 
     if (worksheet()->animationsEnabled())
     {
         QTimer::singleShot(100, this, &CommandEntry::setMidPrompt);
         QTimer::singleShot(200, this, SLOT(updatePrompt()));
     }
     else
         this->updatePrompt();
 
     animateSizeChange();
 }
 
 void CommandEntry::setHidePrompt()
 {
     updatePrompt(HidePrompt);
 }
 
 void CommandEntry::setMidPrompt()
 {
     updatePrompt(MidPrompt);
 }
 
 
diff --git a/src/commandentry.h b/src/commandentry.h
index be2777fe..643cbad3 100644
--- a/src/commandentry.h
+++ b/src/commandentry.h
@@ -1,183 +1,185 @@
 /*
     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>
     Copyright (C) 2018 Alexander Semke <alexander.semke@web.de>
  */
 
 #ifndef COMMANDENTRY_H
 #define COMMANDENTRY_H
 
 #include <QPointer>
+#include <QJsonObject>
 #include <KCompletionBox>
 
 #include "worksheetentry.h"
 #include "lib/expression.h"
 
 class Worksheet;
 class ResultItem;
 class QTimer;
 
 namespace Cantor{
     class Result;
     class CompletionObject;
     class SyntaxHelpObject;
 }
 
 class CommandEntry : public WorksheetEntry
 {
   Q_OBJECT
   public:
     static const QString Prompt;
     static const QString MidPrompt;
     static const QString HidePrompt;
 
     explicit CommandEntry(Worksheet* worksheet);
     ~CommandEntry() override;
 
     enum {Type = UserType + 2};
     int type() const override;
 
     QString command();
     void setExpression(Cantor::Expression* expr);
     Cantor::Expression* expression();
 
     QString currentLine();
 
     bool isEmpty() override;
 
     void setContent(const QString& content) override;
     void setContent(const QDomElement& content, const KZip& file) override;
+    void setContentFromJupyter(const QJsonObject& cell);
 
     QDomElement toXml(QDomDocument& doc, KZip* archive) override;
     QString toPlain(const QString& commandSep, const QString& commentStartingSeq, const QString& commentEndingSeq) override;
 
     void setCompletion(Cantor::CompletionObject* tc);
     void setSyntaxHelp(Cantor::SyntaxHelpObject* sh);
 
     bool acceptRichText() override;
 
     void removeContextHelp();
 
     void interruptEvaluation() override;
     bool isShowingCompletionPopup();
 
     bool focusEntry(int pos = WorksheetTextItem::TopLeft, qreal xCoord = 0) override;
 
     void layOutForWidth(qreal w, bool force = false) override;
 
     WorksheetTextItem* highlightItem() override;
 
     WorksheetCursor search(const QString& pattern, unsigned flags,
                            QTextDocument::FindFlags qt_flags,
                            const WorksheetCursor& pos = WorksheetCursor()) override;
 
   public Q_SLOTS:
     bool evaluateCurrentItem() override;
     bool evaluate(WorksheetEntry::EvaluationOption evalOp = FocusNext) override;
     void addInformation();
     void removeResults();
     void removeResult(Cantor::Result* result);
 
     void showCompletion() override;
     void selectPreviousCompletion();
     void updateEntry() override;
     void updatePrompt(const QString& postfix = CommandEntry::Prompt);
     void expressionChangedStatus(Cantor::Expression::Status status);
     void showAdditionalInformationPrompt(const QString& question);
     void showCompletions();
     void applySelectedCompletion();
     void completedLineChanged();
     void showSyntaxHelp();
     void completeLineTo(const QString& line, int index);
 
     void startRemoving() override;
 
     void moveToNextItem(int pos, qreal x);
     void moveToPreviousItem(int pos, qreal x);
 
     void populateMenu(QMenu* menu, QPointF pos) override;
 
   protected:
     bool wantToEvaluate() override;
 
   private:
     WorksheetTextItem* currentInformationItem();
     bool informationItemHasFocus();
     bool focusWithinThisItem();
     QPoint getPopupPosition();
     QPoint toGlobalPosition(QPointF localPos);
     void initMenus();
 
   private:
     enum CompletionMode {
         PreliminaryCompletion,
         FinalCompletion
     };
   private Q_SLOTS:
     void invalidate();
     void resultDeleted();
     void clearResultItems();
     void collapseResults();
     void expandResults();
     void removeResultItem(int index);
     void replaceResultItem(int index);
     void updateCompletions();
     void completeCommandTo(const QString& completion, CommandEntry::CompletionMode mode = PreliminaryCompletion);
 
     void backgroundColorChanged(QAction*);
     void textColorChanged(QAction*);
     void fontBoldTriggered();
     void fontItalicTriggered();
     void fontIncreaseTriggered();
     void fontDecreaseTriggered();
     void fontSelectTriggered();
 
     void animatePromptItem();
     void setMidPrompt();
     void setHidePrompt();
 
   private:
     static const double HorizontalSpacing;
     static const double VerticalSpacing;
 
     WorksheetTextItem* m_promptItem;
     WorksheetTextItem* m_commandItem;
     QVector<ResultItem*> m_resultItems;
     bool m_resultsCollapsed;
     WorksheetTextItem* m_errorItem;
     QList<WorksheetTextItem*> m_informationItems;
     Cantor::Expression* m_expression;
 
     Cantor::CompletionObject* m_completionObject;
     QPointer<KCompletionBox> m_completionBox;
     Cantor::SyntaxHelpObject* m_syntaxHelpObject;
 
     EvaluationOption m_evaluationOption;
     QPropertyAnimation* m_promptItemAnimation;
     bool m_menusInitialized;
 
     //formatting
     QActionGroup* m_backgroundColorActionGroup;
     QMenu* m_backgroundColorMenu;
     QActionGroup* m_textColorActionGroup;
     QMenu* m_textColorMenu;
     QMenu* m_fontMenu;
 };
 
 #endif // COMMANDENTRY_H
diff --git a/src/worksheet.cpp b/src/worksheet.cpp
index adf17fd2..e862de36 100644
--- a/src/worksheet.cpp
+++ b/src/worksheet.cpp
@@ -1,1953 +1,2110 @@
 /*
     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 "worksheet.h"
 
+#include <QtGlobal>
+#include <QApplication>
 #include <QBuffer>
 #include <QDebug>
 #include <QDrag>
 #include <QGraphicsWidget>
 #include <QPrinter>
 #include <QTimer>
 #include <QXmlQuery>
+#include <QJsonArray>
+#include <QJsonDocument>
 
 #include <KMessageBox>
 #include <KActionCollection>
 #include <KFontAction>
 #include <KFontSizeAction>
 #include <KToggleAction>
+#include <KLocalizedString>
 
 #include "settings.h"
 #include "commandentry.h"
 #include "textentry.h"
 #include "markdownentry.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 "lib/backend.h"
 
 #include <config-cantor.h>
 
 const double Worksheet::LeftMargin = 4;
 const double Worksheet::RightMargin = 4;
 const double Worksheet::TopMargin = 12;
 const double Worksheet::EntryCursorLength = 30;
 const double Worksheet::EntryCursorWidth = 2;
 
 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_choosenCursorEntry = nullptr;
     m_isCursorEntryAfterLastEntry = false;
 
     m_entryCursorItem = addLine(0,0,0,0);
     const QColor& color = (palette().color(QPalette::Base).lightness() < 128) ? Qt::white : Qt::black;
     QPen pen(color);
     pen.setWidth(EntryCursorWidth);
     m_entryCursorItem->setPen(pen);
     m_entryCursorItem->hide();
 
     m_cursorItemTimer = new QTimer(this);
     connect(m_cursorItemTimer, &QTimer::timeout, this, &Worksheet::animateEntryCursor);
     m_cursorItemTimer->start(500);
 
     m_isPrinting = false;
     m_loginDone = false;
     m_readOnly = 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();
     if (m_session)
     {
         disconnect(m_session, 0, 0, 0);
         if (m_session->status() != Cantor::Session::Disable)
             m_session->logout();
         m_session->deleteLater();
         m_session = nullptr;
     }
 }
 
 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 = TopMargin;
 
     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();
     drawEntryCursor();
 }
 
 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();
     drawEntryCursor();
 }
 
 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;
             for (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().first());
 }
 
 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();
     // Entry cursor activate
     if (m_choosenCursorEntry || m_isCursorEntryAfterLastEntry)
         return nullptr;
 
     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();
     resetEntryCursor();
     //bool rt = entry->acceptRichText();
     //setActionsEnabled(rt);
     //setAcceptRichText(rt);
     //ensureCursorVisible();
 }
 
 void Worksheet::startDrag(WorksheetEntry* entry, QDrag* drag)
 {
     if (m_readOnly)
         return;
 
     resetEntryCursor();
     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 && !m_readOnly)
         loginToSession();
 
     firstEntry()->evaluate(WorksheetEntry::EvaluateNext);
 
     emit modified();
 }
 
 void Worksheet::evaluateCurrentEntry()
 {
     if (!m_loginDone && !m_readOnly)
         loginToSession();
 
     WorksheetEntry* entry = currentEntry();
     if(!entry)
         return;
     entry->evaluateCurrentItem();
 }
 
 bool Worksheet::completionEnabled()
 {
     return m_completionEnabled;
 }
 
 void Worksheet::showCompletion()
 {
     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);
         emit modified();
     }
     return entry;
 }
 
 WorksheetEntry* Worksheet::appendCommandEntry()
 {
    return appendEntry(CommandEntry::Type);
 }
 
 WorksheetEntry* Worksheet::appendTextEntry()
 {
    return appendEntry(TextEntry::Type);
 }
 
 WorksheetEntry* Worksheet::appendMarkdownEntry()
 {
    return appendEntry(MarkdownEntry::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();
         emit modified();
     } else {
         entry = next;
     }
 
     focusEntry(entry);
     makeVisible(entry);
     return entry;
 }
 
 WorksheetEntry* Worksheet::insertTextEntry(WorksheetEntry* current)
 {
     return insertEntry(TextEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertMarkdownEntry(WorksheetEntry* current)
 {
     return insertEntry(MarkdownEntry::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();
         emit modified();
     }
     else
         entry = prev;
 
     focusEntry(entry);
     return entry;
 }
 
 WorksheetEntry* Worksheet::insertTextEntryBefore(WorksheetEntry* current)
 {
     return insertEntryBefore(TextEntry::Type, current);
 }
 
 WorksheetEntry* Worksheet::insertMarkdownEntryBefore(WorksheetEntry* current)
 {
     return insertEntryBefore(MarkdownEntry::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;
             QTextCursor cursor(item->document());
             cursor.beginEditBlock();
             for (QTextBlock b = item->document()->firstBlock();
                  b.isValid(); b = b.next())
             {
                 b.layout()->clearAdditionalFormats();
             }
             cursor.endEditBlock();
         }
         update();
     }
 }
 
 void Worksheet::enableHighlighting(bool highlight)
 {
     if(highlight)
     {
         if(m_highlighter)
             m_highlighter->deleteLater();
 
         if (!m_readOnly)
             m_highlighter=session()->syntaxHighlighter(this);
         else
             m_highlighter=nullptr;
 
         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 && m_session->status()==Cantor::Session::Running;
 }
 
 bool Worksheet::isReadOnly()
 {
     return m_readOnly;
 }
 
 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 ? m_session->backend()->name(): m_backendName));
     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("");
 
     if (!m_readOnly)
     {
         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();
         }
     }
     else
         KMessageBox::information(worksheetView(), i18n("In read-only mode Cantor couldn't guarantee, that the export will be valid for %1", m_backendName), i18n("Cantor"));
 
     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))
         // 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_readOnly)
         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"));
+    if (!device->isReadable())
+    {
+        KMessageBox::error(worksheetView(), i18n("Couldn't open the selected file for reading"), i18n("Cantor"));
         return false;
     }
 
-    const KArchiveEntry* contentEntry=file.directory()->entry(QLatin1String("content.xml"));
+    KZip archive(device);
+
+    if (archive.open(QIODevice::ReadOnly))
+        return loadCantorWorksheet(archive);
+    else
+    {
+        qDebug() <<"not a zip file";
+        // Go to begin of data, we need read all data in second time
+        device->seek(0);
+
+        QJsonParseError error;
+        const QJsonDocument& doc = QJsonDocument::fromJson(device->readAll(), &error);
+        if (error.error != QJsonParseError::NoError)
+        {
+            qDebug()<<"not a json file, parsing failed with error: " << error.errorString();
+            QApplication::restoreOverrideCursor();
+            KMessageBox::error(worksheetView(), i18n("The selected file is not a valid Cantor or Jupyter project file."), i18n("Cantor"));
+            return false;
+        }
+        else
+            return loadJupyterNotebook(doc);
+    }
+}
+
+bool Worksheet::loadCantorWorksheet(const KZip& archive)
+{
+    const KArchiveEntry* contentEntry=archive.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();
 
     m_backendName=root.attribute(QLatin1String("backend"));
     Cantor::Backend* b=Cantor::Backend::getBackend(m_backendName);
     if (!b)
     {
         QApplication::restoreOverrideCursor();
         KMessageBox::information(worksheetView(), i18n("%1 backend was not found. Editing and executing entries is not possible", m_backendName), i18n("Cantor"));
         m_readOnly = true;
     }
     else
         m_readOnly = false;
 
     if(!m_readOnly && !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.", m_backendName), i18n("Cantor"));
         m_readOnly = true;
     }
 
     if (m_readOnly)
     {
         // TODO: Handle this here?
         for (QAction* action : m_richTextActionList)
             action->setEnabled(false);
     }
 
     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;
     }
 
     resetEntryCursor();
 
     if (!m_readOnly)
         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);
+            entry->setContent(expressionChild, archive);
         } else if (tag == QLatin1String("Text"))
         {
             entry = appendTextEntry();
-            entry->setContent(expressionChild, file);
+            entry->setContent(expressionChild, archive);
         } else if (tag == QLatin1String("Markdown"))
         {
             entry = appendMarkdownEntry();
-            entry->setContent(expressionChild, file);
+            entry->setContent(expressionChild, archive);
         } else if (tag == QLatin1String("Latex"))
         {
             entry = appendLatexEntry();
-            entry->setContent(expressionChild, file);
+            entry->setContent(expressionChild, archive);
         } else if (tag == QLatin1String("PageBreak"))
         {
             entry = appendPageBreakEntry();
-            entry->setContent(expressionChild, file);
+            entry->setContent(expressionChild, archive);
         }
         else if (tag == QLatin1String("Image"))
         {
             entry = appendImageEntry();
-            entry->setContent(expressionChild, file);
+            entry->setContent(expressionChild, archive);
         }
 
         if (m_readOnly && entry)
         {
             entry->setAcceptHoverEvents(false);
             entry = nullptr;
         }
 
         expressionChild = expressionChild.nextSiblingElement();
     }
 
     if (m_readOnly)
         clearFocus();
 
     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 loaded();
     return true;
 }
 
+bool Worksheet::loadJupyterNotebook(const QJsonDocument& doc)
+{
+    static const QLatin1String cellsKey("cells");
+    static const QLatin1String metadataKey("metadata");
+    static const QLatin1String nbformatKey("nbformat");
+    static const QLatin1String nbformatMinorKey("nbformat_minor");
+
+    static const QSet<QString> notebookScheme
+        = QSet<QString>::fromList({cellsKey, metadataKey, nbformatKey, nbformatMinorKey});
+
+    bool isNotebook =
+            doc.isObject()
+        && QSet<QString>::fromList(doc.object().keys()) == notebookScheme
+        && doc.object().value(cellsKey).isArray()
+        && doc.object().value(metadataKey).isObject()
+        && doc.object().value(nbformatKey).isDouble()
+        && doc.object().value(nbformatMinorKey).isDouble();
+
+    if (!isNotebook)
+    {
+        QApplication::restoreOverrideCursor();
+        showInvalidNotebookSchemeError();
+        return false;
+    }
+
+    QJsonObject notebookObject = doc.object();
+    int nbformatMajor = notebookObject.value(nbformatKey).toInt();
+    int nbformatMinor = notebookObject.value(nbformatMinorKey).toInt();
+
+    if (QT_VERSION_CHECK(nbformatMajor, nbformatMinor, 0) < QT_VERSION_CHECK(4,1,0))
+    {
+        QApplication::restoreOverrideCursor();
+        KMessageBox::error(worksheetView(), i18n("Cantor doesn't support import Jupyter notebooks with version lower that 4.1 (detected %1.%2)",nbformatMajor, nbformatMinor), i18n("Cantor"));
+        return false;
+    }
+
+    const QJsonArray& cells = notebookObject.value(cellsKey).toArray();
+    const QJsonObject& metadata = notebookObject.value(metadataKey).toObject();
+
+    const QJsonObject& kernalspec = metadata.value(QLatin1String("kernelspec")).toObject();
+    const QJsonValue& name = kernalspec.value(QLatin1String("name"));
+    qDebug() << kernalspec << name;
+    if (kernalspec.isEmpty() || name.type() == QJsonValue::Undefined)
+    {
+        QApplication::restoreOverrideCursor();
+        showInvalidNotebookSchemeError();
+        return false;
+    }
+
+    const QString& backendName = name.toString();
+    Cantor::Backend* backend = Cantor::Backend::getBackend(backendName);
+    // Jupyter TODO: what about corresponding jupyter and our names
+    // Is them always matches each over?
+    // Investigate.
+    if (!backend)
+    {
+        // Jupyter TODO: what about readonly mode?
+        QApplication::restoreOverrideCursor();
+        KMessageBox::error(worksheetView(), i18n("Cantor doesn't support Jupyter %1 backend, so can't open the project", backendName), i18n("Cantor"));
+        return false;
+    }
+
+    m_isLoadingFromFile = true;
+
+    if (m_session)
+        delete m_session;
+    m_session = backend->createSession();
+    m_loginDone = false;
+
+    if (m_firstEntry) {
+        delete m_firstEntry;
+        m_firstEntry = nullptr;
+    }
+
+    resetEntryCursor();
+
+    qDebug()<<"loading jupyter entries";
+
+    static const QLatin1String cellTypeKey("cell_type");
+    static const QLatin1String sourceKey("source");
+
+    // Jupyter TODO: handle error, like no object, no 'cell_type', etc
+    // Maybe forward back to cantor shell and UI message about failed
+    for (QJsonArray::const_iterator iter = cells.begin(); iter != cells.end(); iter++) {
+        bool isCellObject = iter->isObject();
+        if (!isCellObject)
+            continue;
+
+        const QJsonObject& cell = iter->toObject();
+
+        bool isJupyterCell =
+               cell.contains(cellTypeKey)
+            && cell.contains(metadataKey)
+            && cell.contains(sourceKey);
+
+        if (!isJupyterCell)
+            continue;
+
+        QString cellType = cell.value(cellTypeKey).toString();
+
+        if (cellType == QLatin1String("code"))
+        {
+            // Jupyter TODO output of runned cells
+            CommandEntry* entry = static_cast<CommandEntry*>(appendCommandEntry());
+            entry->importJupyterCell(cell);
+        }
+    }
+
+    if (m_readOnly)
+        clearFocus();
+
+    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 loaded();
+    return true;
+}
+
+void Worksheet::showInvalidNotebookSchemeError()
+{
+    KMessageBox::error(worksheetView(), i18n("The file is not a valid Jupyter notebook file."), i18n("Cantor"));
+}
+
+
 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
     for (auto* result : expr->results())
     {
         if(result && result->type()==Cantor::HelpResult::Type)
         {
             QString help = 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);
 
             //TODO: break after the first help result found, not clear yet how to handle multiple requests for help within one single command (e.g. ??ev;??int).
             break;
         }
     }
 }
 
 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, 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(QIcon::fromTheme(QLatin1String("run-build")), i18n("Command Entry"), entry, SLOT(insertCommandEntry()));
         insert->addAction(QIcon::fromTheme(QLatin1String("draw-text")), i18n("Text Entry"), entry, SLOT(insertTextEntry()));
 #ifdef Discount_FOUND
         insert->addAction(QIcon::fromTheme(QLatin1String("text-x-markdown")), i18n("Markdown Entry"), entry, SLOT(insertMarkdownEntry()));
 #endif
 #ifdef WITH_EPS
         insert->addAction(QIcon::fromTheme(QLatin1String("text-x-tex")), i18n("LaTeX Entry"), entry, SLOT(insertLatexEntry()));
 #endif
         insert->addAction(QIcon::fromTheme(QLatin1String("image-x-generic")), i18n("Image"), entry, SLOT(insertImageEntry()));
         insert->addAction(QIcon::fromTheme(QLatin1String("go-next-view-page")), i18n("Page Break"), entry, SLOT(insertPageBreakEntry()));
 
         insertBefore->addAction(QIcon::fromTheme(QLatin1String("run-build")), i18n("Command Entry"), entry, SLOT(insertCommandEntryBefore()));
         insertBefore->addAction(QIcon::fromTheme(QLatin1String("draw-text")), i18n("Text Entry"), entry, SLOT(insertTextEntryBefore()));
 #ifdef Discount_FOUND
         insertBefore->addAction(QIcon::fromTheme(QLatin1String("text-x-markdown")), i18n("Markdown Entry"), entry, SLOT(insertMarkdownEntryBefore()));
 #endif
 #ifdef WITH_EPS
         insertBefore->addAction(QIcon::fromTheme(QLatin1String("text-x-tex")), i18n("LaTeX Entry"), entry, SLOT(insertLatexEntryBefore()));
 #endif
         insertBefore->addAction(QIcon::fromTheme(QLatin1String("image-x-generic")), i18n("Image"), entry, SLOT(insertImageEntryBefore()));
         insertBefore->addAction(QIcon::fromTheme(QLatin1String("go-next-view-page")), i18n("Page Break"), entry, SLOT(insertPageBreakEntryBefore()));
 
         insert->setTitle(i18n("Insert Entry After"));
         insert->setIcon(QIcon::fromTheme(QLatin1String("edit-table-insert-row-below")));
         insertBefore->setTitle(i18n("Insert Entry Before"));
         insertBefore->setIcon(QIcon::fromTheme(QLatin1String("edit-table-insert-row-above")));
         menu->addMenu(insert);
         menu->addMenu(insertBefore);
     } else {
         menu->addAction(QIcon::fromTheme(QLatin1String("run-build")), i18n("Insert Command Entry"), this, SLOT(appendCommandEntry()));
         menu->addAction(QIcon::fromTheme(QLatin1String("draw-text")), i18n("Insert Text Entry"), this, SLOT(appendTextEntry()));
 #ifdef Discount_FOUND
         menu->addAction(QIcon::fromTheme(QLatin1String("text-x-markdown")), i18n("Insert Markdown Entry"), this, SLOT(appendMarkdownEntry()));
 #endif
 #ifdef WITH_EPS
         menu->addAction(QIcon::fromTheme(QLatin1String("text-x-tex")), i18n("Insert LaTeX Entry"), this, SLOT(appendLatexEntry()));
 #endif
         menu->addAction(QIcon::fromTheme(QLatin1String("image-x-generic")), i18n("Insert Image"), this, SLOT(appendImageEntry()));
         menu->addAction(QIcon::fromTheme(QLatin1String("go-next-view-page")), i18n("Insert Page Break"), this, SLOT(appendPageBreakEntry()));
     }
 }
 
 void Worksheet::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
 {
     if (m_readOnly)
         return;
 
     // 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);
     */
     if (!m_readOnly)
         updateEntryCursor(event);
 }
 
 void Worksheet::keyPressEvent(QKeyEvent *keyEvent)
 {
     if (m_readOnly)
         return;
 
     // If we choose entry by entry cursor and press text button (not modifiers, for example, like Control)
     if ((m_choosenCursorEntry || m_isCursorEntryAfterLastEntry) && !keyEvent->text().isEmpty())
         addEntryFromEntryCursor();
 
     QGraphicsScene::keyPressEvent(keyEvent);
 }
 
 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)
 {
     // No need update and emit signals about editing actions in readonly
     // So support only copy action and reset selection
     if (m_readOnly)
     {
         if (m_lastFocusedTextItem && m_lastFocusedTextItem != newItem)
         {
             disconnect(this, SIGNAL(copy()), m_lastFocusedTextItem, SLOT(copy()));
             m_lastFocusedTextItem->clearSelection();
         }
 
         if (newItem && m_lastFocusedTextItem != newItem)
         {
             connect(this, SIGNAL(copy()), newItem, SLOT(copy()));
             emit copyAvailable(newItem->isCopyAvailable());
         }
         else if (!newItem)
         {
             emit copyAvailable(false);
         }
 
         m_lastFocusedTextItem = newItem;
         return;
     }
 
     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()));
 
         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()));
     } else if (!newItem) {
         emit undoAvailable(false);
         emit redoAvailable(false);
         emit cutAvailable(false);
         emit copyAvailable(false);
         emit pasteAvailable(false);
     }
     m_lastFocusedTextItem = newItem;
 }
 
 /*!
  * handles the paste action triggered in cantor_part.
  * Pastes into the last focused text item.
  * In case the "new entry"-cursor is currently shown,
  * a new entry is created first which the content will be pasted into.
  */
 void Worksheet::paste() {
     if (m_choosenCursorEntry || m_isCursorEntryAfterLastEntry)
         addEntryFromEntryCursor();
 
     m_lastFocusedTextItem->paste();
 }
 
 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)
 {
     if (!m_readOnly)
         for(QAction * action : m_richTextActionList)
             action->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(const 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(const QKeySequence& sequence)
 {
     return m_shortcuts.contains(sequence);
 }
 
 void Worksheet::registerShortcut(QAction* action)
 {
     for (auto& 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);
     for (auto& shortcut : shortcuts)
         m_shortcuts.remove(shortcut);
 
     // add the new shortcuts
     for (auto& 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();
 }
 
 void Worksheet::updateEntryCursor(QGraphicsSceneMouseEvent* event)
 {
     // determine the worksheet entry near which the entry cursor will be shown
     resetEntryCursor();
     if (event->button() == Qt::LeftButton && !focusItem())
     {
         const qreal y = event->scenePos().y();
         for (WorksheetEntry* entry = firstEntry(); entry; entry = entry->next())
         {
             if (entry == firstEntry() && y < entry->y() )
             {
                 m_choosenCursorEntry = firstEntry();
                 break;
             }
             else if (entry->y() < y && (entry->next() && y < entry->next()->y()))
             {
                 m_choosenCursorEntry = entry->next();
                 break;
             }
             else if (entry->y() < y && entry == lastEntry())
             {
                 m_isCursorEntryAfterLastEntry = true;
                 break;
             }
         }
     }
 
     if (m_choosenCursorEntry || m_isCursorEntryAfterLastEntry)
         drawEntryCursor();
 }
 
 void Worksheet::addEntryFromEntryCursor()
 {
     qDebug() << "Add new entry from entry cursor";
     if (m_isCursorEntryAfterLastEntry)
         insertCommandEntry(lastEntry());
     else
         insertCommandEntryBefore(m_choosenCursorEntry);
     resetEntryCursor();
 }
 
 void Worksheet::animateEntryCursor()
 {
     if ((m_choosenCursorEntry || m_isCursorEntryAfterLastEntry) && m_entryCursorItem)
         m_entryCursorItem->setVisible(!m_entryCursorItem->isVisible());
 }
 
 void Worksheet::resetEntryCursor()
 {
     m_choosenCursorEntry = nullptr;
     m_isCursorEntryAfterLastEntry = false;
     m_entryCursorItem->hide();
 }
 
 void Worksheet::drawEntryCursor()
 {
     if (m_entryCursorItem && (m_choosenCursorEntry || (m_isCursorEntryAfterLastEntry && lastEntry())))
     {
         qreal x;
         qreal y;
         if (m_isCursorEntryAfterLastEntry)
         {
             x = lastEntry()->x();
             y = lastEntry()->y() + lastEntry()->size().height() - (EntryCursorWidth - 1);
         }
         else
         {
             x = m_choosenCursorEntry->x();
             y = m_choosenCursorEntry->y();
         }
         m_entryCursorItem->setLine(x,y,x+EntryCursorLength,y);
         m_entryCursorItem->show();
     }
 }
diff --git a/src/worksheet.h b/src/worksheet.h
index 182e77be..99d40bca 100644
--- a/src/worksheet.h
+++ b/src/worksheet.h
@@ -1,304 +1,307 @@
 /*
     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>
  */
 
 #ifndef WORKSHEET_H
 #define WORKSHEET_H
 
 #include <QGraphicsScene>
 #include <QDomElement>
 #include <QGraphicsLinearLayout>
 #include <QSyntaxHighlighter>
 #include <QGraphicsRectItem>
 
 #include <KZip>
 #include <QMenu>
 
 #include "worksheetview.h"
 #include "epsrenderer.h"
 #include "worksheetcursor.h"
 
 namespace Cantor {
     class Backend;
     class Session;
     class Expression;
 }
 
 class WorksheetEntry;
 class PlaceHolderEntry;
 class WorksheetTextItem;
 
 class QAction;
 class QDrag;
 class QPrinter;
 class KActionCollection;
 class KToggleAction;
 class KFontAction;
 class KFontSizeAction;
 
 class Worksheet : public QGraphicsScene
 {
   Q_OBJECT
   public:
     Worksheet(Cantor::Backend* backend, QWidget* parent);
     ~Worksheet() override;
 
     Cantor::Session* session();
 
     void loginToSession();
 
     bool isRunning();
     bool isReadOnly();
     bool showExpressionIds();
     bool animationsEnabled();
 
     bool isPrinting();
 
     void setViewSize(qreal w, qreal h, qreal s, bool forceUpdate = false);
 
     WorksheetView* worksheetView();
 
     void makeVisible(WorksheetEntry*);
     void makeVisible(const WorksheetCursor&);
 
     void setModified();
 
     void startDrag(WorksheetEntry* entry, QDrag* drag);
 
     void createActions(KActionCollection*);
     QMenu* createContextMenu();
     void populateMenu(QMenu* menu, QPointF pos);
     EpsRenderer* epsRenderer();
     bool isEmpty();
     bool isLoadingFromFile();
 
     WorksheetEntry* currentEntry();
     WorksheetEntry* firstEntry();
     WorksheetEntry* lastEntry();
     WorksheetTextItem* currentTextItem();
     WorksheetTextItem* lastFocusedTextItem();
 
     WorksheetCursor worksheetCursor();
     void setWorksheetCursor(const WorksheetCursor&);
 
     // For WorksheetEntry::startDrag
     void resetEntryCursor();
 
     void addProtrusion(qreal width);
     void updateProtrusion(qreal oldWidth, qreal newWidth);
     void removeProtrusion(qreal width);
 
     bool isShortcut(const QKeySequence&);
 
     // richtext
     struct RichTextInfo {
         bool bold;
         bool italic;
         bool underline;
         bool strikeOut;
         QString font;
         qreal fontSize;
         Qt::Alignment align;
     };
 
   public Q_SLOTS:
     WorksheetEntry* appendCommandEntry();
     void appendCommandEntry(const QString& text);
     WorksheetEntry* appendTextEntry();
     WorksheetEntry* appendMarkdownEntry();
     WorksheetEntry* appendImageEntry();
     WorksheetEntry* appendPageBreakEntry();
     WorksheetEntry* appendLatexEntry();
     WorksheetEntry* insertCommandEntry(WorksheetEntry* current = nullptr);
     void insertCommandEntry(const QString& text);
     WorksheetEntry* insertTextEntry(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertMarkdownEntry(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertImageEntry(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertPageBreakEntry(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertLatexEntry(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertCommandEntryBefore(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertTextEntryBefore(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertMarkdownEntryBefore(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertImageEntryBefore(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertPageBreakEntryBefore(WorksheetEntry* current = nullptr);
     WorksheetEntry* insertLatexEntryBefore(WorksheetEntry* current = nullptr);
 
     void updateLayout();
     void updateEntrySize(WorksheetEntry*);
 
     void print(QPrinter*);
     void paste();
     void focusEntry(WorksheetEntry*);
 
     void evaluate();
     void evaluateCurrentEntry();
     void interrupt();
     void interruptCurrentEntryEvaluation();
 
     bool completionEnabled();
     //void showCompletion();
 
     void highlightItem(WorksheetTextItem*);
     void rehighlight();
 
     void enableHighlighting(bool);
     void enableCompletion(bool);
     void enableExpressionNumbering(bool);
     void enableAnimations(bool);
 
     QDomDocument toXML(KZip* archive = nullptr);
 
     void save(const QString& filename);
     void save(QIODevice*);
     QByteArray saveToByteArray();
     void savePlain(const QString& filename);
     void saveLatex(const QString& filename);
     bool load(QIODevice*);
     void load(QByteArray* data);
     bool load(const QString& filename);
 
     void gotResult(Cantor::Expression* expr = nullptr);
 
     void removeCurrentEntry();
 
     void setFirstEntry(WorksheetEntry*);
     void setLastEntry(WorksheetEntry*);
     void invalidateFirstEntry();
     void invalidateLastEntry();
 
     void updateFocusedTextItem(WorksheetTextItem*);
 
     void updateDragScrollTimer();
 
     void registerShortcut(QAction*);
     void updateShortcut();
 
     // richtext
     void setRichTextInformation(const Worksheet::RichTextInfo&);
     void setAcceptRichText(bool b);
 
     void setTextForegroundColor();
     void setTextBackgroundColor();
     void setTextBold(bool b);
     void setTextItalic(bool b);
     void setTextUnderline(bool b);
     void setTextStrikeOut(bool b);
     void setAlignLeft();
     void setAlignRight();
     void setAlignCenter();
     void setAlignJustify();
     void setFontFamily(const QString&);
     void setFontSize(int size);
 
   Q_SIGNALS:
     void modified();
     void loaded();
     void showHelp(const QString&);
     void updatePrompt();
     void undoAvailable(bool);
     void redoAvailable(bool);
     void undo();
     void redo();
     void cutAvailable(bool);
     void copyAvailable(bool);
     void pasteAvailable(bool);
     void cut();
     void copy();
 
   protected:
     void contextMenuEvent(QGraphicsSceneContextMenuEvent*) override;
     void mousePressEvent(QGraphicsSceneMouseEvent*) override;
 
     void dragEnterEvent(QGraphicsSceneDragDropEvent*) override;
     void dragLeaveEvent(QGraphicsSceneDragDropEvent*) override;
     void dragMoveEvent(QGraphicsSceneDragDropEvent*) override;
     void dropEvent(QGraphicsSceneDragDropEvent*) override;
 
     void keyPressEvent(QKeyEvent*) override;
 
   private Q_SLOTS:
     void showCompletion();
     //void checkEntriesForSanity();
 
     WorksheetEntry* appendEntry(int type);
     WorksheetEntry* insertEntry(int type, WorksheetEntry* current = nullptr);
     WorksheetEntry* insertEntryBefore(int type, WorksheetEntry* current = nullptr);
 
     void animateEntryCursor();
 
   private:
     WorksheetEntry* entryAt(qreal x, qreal y);
     WorksheetEntry* entryAt(QPointF p);
     WorksheetEntry* entryAt(int row);
     void updateEntryCursor(QGraphicsSceneMouseEvent*);
     void addEntryFromEntryCursor();
     void drawEntryCursor();
     int entryCount();
+    bool loadCantorWorksheet(const KZip& archive);
+    bool loadJupyterNotebook(const QJsonDocument& doc);
+    void showInvalidNotebookSchemeError();
 
   private:
     static const double LeftMargin;
     static const double RightMargin;
     static const double TopMargin;
     static const double EntryCursorLength;
     static const double EntryCursorWidth;
     Cantor::Session *m_session;
     QSyntaxHighlighter* m_highlighter;
     EpsRenderer m_epsRenderer;
     WorksheetEntry* m_firstEntry;
     WorksheetEntry* m_lastEntry;
     WorksheetEntry* m_dragEntry;
     WorksheetEntry* m_choosenCursorEntry;
     bool m_isCursorEntryAfterLastEntry;
     QTimer* m_cursorItemTimer;
     QGraphicsLineItem* m_entryCursorItem;
     PlaceHolderEntry* m_placeholderEntry;
     WorksheetTextItem* m_lastFocusedTextItem;
     QTimer* m_dragScrollTimer;
 
     double m_viewWidth;
     double m_protrusion;
     QMap<qreal, int> m_itemProtrusions;
 
     QMap<QKeySequence, QAction*> m_shortcuts;
 
     QList<QAction *> m_richTextActionList;
     KToggleAction* m_boldAction;
     KToggleAction* m_italicAction;
     KToggleAction* m_underlineAction;
     KToggleAction* m_strikeOutAction;
     KFontAction* m_fontAction;
     KFontSizeAction* m_fontSizeAction;
     KToggleAction* m_alignLeftAction;
     KToggleAction* m_alignCenterAction;
     KToggleAction* m_alignRightAction;
     KToggleAction* m_alignJustifyAction;
 
     bool m_completionEnabled;
     bool m_showExpressionIds;
     bool m_animationsEnabled;
     bool m_loginDone;
     bool m_isPrinting;
     bool m_isLoadingFromFile;
     bool m_readOnly;
 
     QString m_backendName;
 };
 
 #endif // WORKSHEET_H