editors/sc-ide/widgets/multi_editor.cpp

   1 /*
   2     SuperCollider Qt IDE
   3     Copyright (c) 2012 Jakob Leben & Tim Blechmann
   4     http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21 #include "multi_editor.hpp"
  22 #include "editor_box.hpp"
  23 #include "main_window.hpp"
  24 #include "lookup_dialog.hpp"
  25 #include "code_editor/editor.hpp"
  26 #include "util/multi_splitter.hpp"
  27 #include "../core/doc_manager.hpp"
  28 #include "../core/sig_mux.hpp"
  29 #include "../core/main.hpp"
  30 #include "../core/sc_process.hpp"
  31 #include "../core/session_manager.hpp"
  32
  33 #include "yaml-cpp/node.h"
  34 #include "yaml-cpp/parser.h"
  35
  36 #include <QApplication>
  37 #include <QStyle>
  38 #include <QHBoxLayout>
  39 #include <QVBoxLayout>
  40 #include <QShortcut>
  41 #include <QMenu>
  42 #include <QDebug>
  43
  44 #include <QDialog>
  45 #include <QFileInfo>
  46 #include <QHeaderView>
  47 #include <QListView>
  48 #include <QTreeWidget>
  49 #include <QStandardItemModel>
  50
  51
  52 namespace ScIDE {
  53
  54 class DocumentSelectPopUp : public QDialog
  55 {
  56 public:
  57     explicit DocumentSelectPopUp(const CodeEditorBox::History & history, QWidget * parent):
  58         QDialog(parent, Qt::Popup)
  59     {
  60         mModel = new QStandardItemModel(this);
  61         populateModel(history);
  62
  63         mListView = new QListView();
  64         mListView->setModel(mModel);
  65         mListView->setFrameShape(QFrame::NoFrame);
  66
  67         QHBoxLayout *layout = new QHBoxLayout(this);
  68         layout->addWidget(mListView);
  69         layout->setContentsMargins(1,1,1,1);
  70
  71         connect(mListView, SIGNAL(activated(QModelIndex)), this, SLOT(accept()));
  72
  73         mListView->setFocus(Qt::OtherFocusReason);
  74
  75         QModelIndex nextIndex = mModel->index(1, 0);
  76         mListView->setCurrentIndex(nextIndex);
  77
  78         mListView->setEditTriggers(QAbstractItemView::NoEditTriggers);
  79     }
  80
  81     Document * exec( const QPoint & pos )
  82     {
  83         move(pos);
  84         if (QDialog::exec())
  85             return currentDocument();
  86         else
  87             return 0;
  88     }
  89
  90 private:
  91     void keyReleaseEvent (QKeyEvent * ke)
  92     {
  93         // adapted from qtcreator
  94         if (ke->modifiers() == 0
  95             /*HACK this is to overcome some event inconsistencies between platforms*/
  96             || (ke->modifiers() == Qt::AltModifier
  97                 && (ke->key() == Qt::Key_Alt || ke->key() == -1))) {
  98             ke->accept();
  99             accept();
 100         }
 101         QDialog::keyPressEvent(ke);
 102     }
 103
 104     void keyPressEvent(QKeyEvent * ke)
 105     {
 106         switch (ke->key()) {
 107         case Qt::Key_Tab: {
 108             int row = mListView->currentIndex().row() + 1;
 109             if (!mModel->hasIndex(row, 0))
 110                 row = 0;
 111
 112             QModelIndex nextIndex = mModel->index(row, 0);
 113             mListView->setCurrentIndex(nextIndex);
 114             ke->accept();
 115             return;
 116         }
 117
 118         case Qt::Key_Backtab: {
 119             int row = mListView->currentIndex().row() - 1;
 120             if (!mModel->hasIndex(row, 0))
 121                 row = mModel->rowCount() - 1;
 122
 123             QModelIndex nextIndex = mModel->index(row, 0);
 124             mListView->setCurrentIndex(nextIndex);
 125             ke->accept();
 126             return;
 127         }
 128
 129         case Qt::Key_Escape:
 130             reject();
 131             return;
 132
 133         default:
 134             ;
 135         }
 136
 137         QDialog::keyPressEvent(ke);
 138     }
 139
 140     Document * currentDocument()
 141     {
 142         QStandardItem * currentItem = mModel->itemFromIndex(mListView->currentIndex());
 143
 144         return currentItem ? currentItem->data().value<Document*>()
 145                            : NULL;
 146     }
 147
 148     void populateModel( const CodeEditorBox::History & history )
 149     {
 150         QList<Document*> displayDocuments;
 151         foreach(CodeEditor *editor, history)
 152             displayDocuments << editor->document();
 153
 154         QList<Document*> managerDocuments =  Main::instance()->documentManager()->documents();
 155         foreach(Document *document, managerDocuments)
 156             if (!displayDocuments.contains(document))
 157                 displayDocuments << document;
 158
 159         foreach (Document * document, displayDocuments) {
 160             QStandardItem * item = new QStandardItem(document->title());
 161             item->setData(QVariant::fromValue(document));
 162             mModel->appendRow(item);
 163         }
 164     }
 165
 166     QListView *mListView;
 167     QStandardItemModel *mModel;
 168 };
 169
 170 MultiEditor::MultiEditor( Main *main, QWidget * parent ) :
 171     QWidget(parent),
 172     mDocManager(main->documentManager()),
 173     mSigMux(new SignalMultiplexer(this)),
 174     mBoxSigMux(new SignalMultiplexer(this)),
 175     mDocModifiedIcon( QApplication::style()->standardIcon(QStyle::SP_DialogSaveButton) )
 176 {
 177     mTabs = new QTabBar;
 178     mTabs->setDocumentMode(true);
 179     mTabs->setTabsClosable(true);
 180     mTabs->setMovable(true);
 181     mTabs->setUsesScrollButtons(true);
 182     mTabs->setDrawBase(false);
 183
 184     CodeEditorBox *defaultBox = newBox();
 185
 186     mSplitter = new MultiSplitter();
 187     mSplitter->addWidget(defaultBox);
 188
 189     QVBoxLayout *l = new QVBoxLayout;
 190     l->setContentsMargins(0,0,0,0);
 191     l->setSpacing(0);
 192     l->addWidget(mTabs);
 193     l->addWidget(mSplitter);
 194     setLayout(l);
 195
 196     connect(mDocManager, SIGNAL(opened(Document*, int)),
 197             this, SLOT(onOpen(Document*, int)));
 198     connect(mDocManager, SIGNAL(closed(Document*)),
 199             this, SLOT(onClose(Document*)));
 200     connect(mDocManager, SIGNAL(saved(Document*)),
 201             this, SLOT(update(Document*)));
 202     connect(mDocManager, SIGNAL(showRequest(Document*,int)),
 203             this, SLOT(show(Document*,int))),
 204
 205     connect(mTabs, SIGNAL(currentChanged(int)),
 206             this, SLOT(onCurrentTabChanged(int)));
 207     connect(mTabs, SIGNAL(tabCloseRequested(int)),
 208             this, SLOT(onCloseRequest(int)));
 209
 210     mSigMux->connect(SIGNAL(modificationChanged(bool)),
 211                      this, SLOT(onModificationChanged(bool)));
 212
 213     mBoxSigMux->connect(SIGNAL(currentChanged(CodeEditor*)),
 214                         this, SLOT(onCurrentEditorChanged(CodeEditor*)));
 215
 216     connect(this, SIGNAL(currentDocumentChanged(Document*)), mDocManager, SLOT(activeDocumentChanged(Document*)));
 217
 218     createActions();
 219
 220     setCurrentBox( defaultBox ); // will updateActions();
 221
 222     applySettings(main->settings());
 223 }
 224
 225 void MultiEditor::createActions()
 226 {
 227     Settings::Manager *settings = Main::instance()->settings();
 228     settings->beginGroup("IDE/shortcuts");
 229
 230     QAction * act;
 231
 232     // Edit
 233
 234     mActions[Undo] = act = new QAction(
 235         QIcon::fromTheme("edit-undo"), tr("&Undo"), this);
 236     act->setShortcut(tr("Ctrl+Z", "Undo"));
 237     act->setStatusTip(tr("Undo last editing action"));
 238     mSigMux->connect(act, SIGNAL(triggered()), SLOT(undo()));
 239     mSigMux->connect(SIGNAL(undoAvailable(bool)), act, SLOT(setEnabled(bool)));
 240
 241     mActions[Redo] = act = new QAction(
 242         QIcon::fromTheme("edit-redo"), tr("Re&do"), this);
 243     act->setShortcut(tr("Ctrl+Shift+Z", "Redo"));
 244     act->setStatusTip(tr("Redo next editing action"));
 245     mSigMux->connect(act, SIGNAL(triggered()), SLOT(redo()));
 246     mSigMux->connect(SIGNAL(redoAvailable(bool)), act, SLOT(setEnabled(bool)));
 247
 248     mActions[Cut] = act = new QAction(
 249         QIcon::fromTheme("edit-cut"), tr("Cu&t"), this);
 250     act->setShortcut(tr("Ctrl+X", "Cut"));
 251     act->setStatusTip(tr("Cut text to clipboard"));
 252     mSigMux->connect(act, SIGNAL(triggered()), SLOT(cut()));
 253     mSigMux->connect(SIGNAL(copyAvailable(bool)), act, SLOT(setEnabled(bool)));
 254
 255     mActions[Copy] = act = new QAction(
 256         QIcon::fromTheme("edit-copy"), tr("&Copy"), this);
 257     act->setShortcut(tr("Ctrl+C", "Copy"));
 258     act->setStatusTip(tr("Copy text to clipboard"));
 259     mSigMux->connect(act, SIGNAL(triggered()), SLOT(copy()));
 260     mSigMux->connect(SIGNAL(copyAvailable(bool)), act, SLOT(setEnabled(bool)));
 261
 262     mActions[Paste] = act = new QAction(
 263         QIcon::fromTheme("edit-paste"), tr("&Paste"), this);
 264     act->setShortcut(tr("Ctrl+V", "Paste"));
 265     act->setStatusTip(tr("Paste text from clipboard"));
 266     mSigMux->connect(act, SIGNAL(triggered()), SLOT(paste()));
 267
 268     mActions[IndentLineOrRegion] = act = new QAction(
 269         QIcon::fromTheme("format-indent-line"), tr("Indent Line or Region"), this);
 270     act->setStatusTip(tr("Indent Line or Region"));
 271     mSigMux->connect(act, SIGNAL(triggered()), SLOT(indent()));
 272
 273     mActions[TriggerAutoCompletion] = act = new QAction(tr("Trigger Autocompletion"), this);
 274     act->setStatusTip(tr("Suggest possible completions of text at cursor"));
 275     act->setShortcut(tr("Ctrl+Space", "Trigger Autocompletion"));
 276     mSigMux->connect(act, SIGNAL(triggered()), SLOT(triggerAutoCompletion()));
 277
 278     mActions[TriggerMethodCallAid] = act = new QAction(tr("Trigger Method Call Aid"), this);
 279     act->setStatusTip(tr("Show arguments for currently typed method call"));
 280     act->setShortcut(tr("Alt+Space", "Trigger Method Call Aid"));
 281     mSigMux->connect(act, SIGNAL(triggered()), SLOT(triggerMethodCallAid()));
 282
 283     mActions[ToggleComment] = act = new QAction(
 284         QIcon::fromTheme("edit-comment"), tr("Toggle &Comment"), this);
 285     act->setShortcut(tr("Ctrl+/", "Toggle Comment"));
 286     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 287     act->setStatusTip(tr("Toggle Comment"));
 288     mSigMux->connect(act, SIGNAL(triggered()), SLOT(toggleComment()));
 289
 290     mActions[ToggleOverwriteMode] = act = new QAction(
 291         QIcon::fromTheme("edit-overwrite"), tr("Toggle &Overwrite Mode"), this);
 292     act->setShortcut(tr("Insert", "Toggle Overwrite Mode"));
 293     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 294     mSigMux->connect(act, SIGNAL(triggered()), SLOT(toggleOverwriteMode()));
 295
 296     mActions[CopyLineUp] = act = new QAction(
 297         QIcon::fromTheme("edit-copylineup"), tr("Copy Line Up"), this);
 298     act->setShortcut(tr("Ctrl+Alt+Up", "Copy Line Up"));
 299     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 300     mSigMux->connect(act, SIGNAL(triggered()), SLOT(copyLineUp()));
 301
 302     mActions[CopyLineDown] = act = new QAction(
 303         QIcon::fromTheme("edit-copylinedown"), tr("Copy Line Down"), this);
 304     act->setShortcut(tr("Ctrl+Alt+Down", "Copy Line Up"));
 305     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 306     mSigMux->connect(act, SIGNAL(triggered()), SLOT(copyLineDown()));
 307
 308     mActions[MoveLineUp] = act = new QAction(
 309         QIcon::fromTheme("edit-movelineup"), tr("move Line Up"), this);
 310     act->setShortcut(tr("Ctrl+Shift+Up", "Move Line Up"));
 311     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 312     mSigMux->connect(act, SIGNAL(triggered()), SLOT(moveLineUp()));
 313
 314     mActions[MoveLineDown] = act = new QAction(
 315         QIcon::fromTheme("edit-movelinedown"), tr("Move Line Down"), this);
 316     act->setShortcut(tr("Ctrl+Shift+Down", "Move Line Up"));
 317     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 318     mSigMux->connect(act, SIGNAL(triggered()), SLOT(moveLineDown()));
 319
 320     mActions[GotoPreviousBlock] = act = new QAction(
 321         QIcon::fromTheme("edit-gotopreviousblock"), tr("Go to Previous Block"), this);
 322     act->setShortcut(tr("Ctrl+[", "Go to Previous Block"));
 323     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 324     mSigMux->connect(act, SIGNAL(triggered()), SLOT(gotoPreviousBlock()));
 325
 326     mActions[GotoNextBlock] = act = new QAction(
 327         QIcon::fromTheme("edit-gotonextblock"), tr("Go to Next Block"), this);
 328     act->setShortcut(tr("Ctrl+]", "Go to Next Block"));
 329     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 330     mSigMux->connect(act, SIGNAL(triggered()), SLOT(gotoNextBlock()));
 331
 332     // View
 333
 334     mActions[EnlargeFont] = act = new QAction(
 335         QIcon::fromTheme("zoom-in"), tr("&Enlarge Font"), this);
 336     act->setShortcut(tr("Ctrl++", "Enlarge font"));
 337     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 338     act->setStatusTip(tr("Increase displayed font size"));
 339     mSigMux->connect(act, SIGNAL(triggered()), SLOT(zoomIn()));
 340
 341     mActions[ShrinkFont] = act = new QAction(
 342         QIcon::fromTheme("zoom-out"), tr("&Shrink Font"), this);
 343     act->setShortcut( tr("Ctrl+-", "Shrink font"));
 344     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 345     act->setStatusTip(tr("Decrease displayed font size"));
 346     mSigMux->connect(act, SIGNAL(triggered()), SLOT(zoomOut()));
 347
 348     mActions[ResetFontSize] = act = new QAction(
 349         QIcon::fromTheme("zoom-reset"), tr("&Reset Font Size"), this);
 350     act->setShortcut( tr("Ctrl+0", "Reset font"));
 351     act->setStatusTip(tr("Reset displayed font size"));
 352     mSigMux->connect(act, SIGNAL(triggered()), SLOT(resetFontSize()));
 353
 354     mActions[ShowWhitespace] = act = new QAction(tr("Show Spaces and Tabs"), this);
 355     act->setCheckable(true);
 356     mSigMux->connect(act, SIGNAL(triggered(bool)), SLOT(setShowWhitespace(bool)));
 357
 358     mActions[NextDocument] = act = new QAction(tr("Next Document"), this);
 359     act->setShortcut( tr("Alt+Right", "Next Document"));
 360     connect(act, SIGNAL(triggered()), this, SLOT(showNextDocument()));
 361
 362     mActions[PreviousDocument] = act = new QAction(tr("Previous Document"), this);
 363     act->setShortcut( tr("Alt+Left", "Next Document"));
 364     connect(act, SIGNAL(triggered()), this, SLOT(showPreviousDocument()));
 365
 366     mActions[SwitchDocument] = act = new QAction(tr("Switch Document"), this);
 367     act->setShortcut( tr("Ctrl+Tab", "Switch Document"));
 368     connect(act, SIGNAL(triggered()), this, SLOT(switchDocument()));
 369
 370     mActions[SplitHorizontally] = act = new QAction(tr("Split To Right"), this);
 371     connect(act, SIGNAL(triggered()), this, SLOT(splitHorizontally()));
 372
 373     mActions[SplitVertically] = act = new QAction(tr("Split To Bottom"), this);
 374     connect(act, SIGNAL(triggered()), this, SLOT(splitVertically()));
 375
 376     mActions[RemoveCurrentSplit] = act = new QAction(tr("Remove Current Split"), this);
 377     connect(act, SIGNAL(triggered()), this, SLOT(removeCurrentSplit()));
 378
 379     mActions[RemoveAllSplits] = act = new QAction(tr("Remove All Splits"), this);
 380     connect(act, SIGNAL(triggered()), this, SLOT(removeAllSplits()));
 381
 382     // Language
 383
 384     mActions[EvaluateCurrentDocument] = act = new QAction(
 385         QIcon::fromTheme("media-playback-start"), tr("Evaluate &File"), this);
 386     act->setStatusTip(tr("Evaluate current File"));
 387     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 388     connect(act, SIGNAL(triggered()), this, SLOT(evaluateDocument()));
 389
 390     mActions[EvaluateRegion] = act = new QAction(
 391     QIcon::fromTheme("media-playback-start"), tr("&Evaluate Selection, Line or Region"), this);
 392     act->setShortcut(tr("Ctrl+Return", "Evaluate region"));
 393     act->setStatusTip(tr("Evaluate current region"));
 394     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 395     connect(act, SIGNAL(triggered()), this, SLOT(evaluateRegion()));
 396
 397     mActions[EvaluateLine] = act = new QAction(
 398     QIcon::fromTheme("media-playback-startline"), tr("&Evaluate Line"), this);
 399     act->setShortcut(tr("Shift+Ctrl+Return", "Evaluate line"));
 400     act->setStatusTip(tr("Evaluate current line"));
 401     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 402     connect(act, SIGNAL(triggered()), this, SLOT(evaluateLine()));
 403
 404     mActions[OpenDefinition] = act = new QAction(tr("Open Class/Method Definition"), this);
 405     act->setShortcut(tr("Ctrl+I", "Open definition of selected class or method"));
 406     act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
 407     connect(act, SIGNAL(triggered(bool)), this, SLOT(openDefinition()));
 408
 409     settings->endGroup(); // IDE/shortcuts
 410
 411     for (int i = 0; i < ActionRoleCount; ++i)
 412         settings->addAction( mActions[i] );
 413
 414     // These actions are not added to any menu, so they have to be added
 415     // at least to this widget, in order for the shortcuts to always respond:
 416     addAction(mActions[TriggerAutoCompletion]);
 417     addAction(mActions[TriggerMethodCallAid]);
 418     addAction(mActions[SwitchDocument]);
 419
 420     // These actions have to be added because to the widget because they have
 421     // Qt::WidgetWithChildrenShortcut context:
 422     addAction(mActions[EnlargeFont]);
 423     addAction(mActions[ShrinkFont]);
 424     addAction(mActions[OpenDefinition]);
 425     addAction(mActions[EvaluateCurrentDocument]);
 426     addAction(mActions[EvaluateRegion]);
 427     addAction(mActions[EvaluateLine]);
 428     addAction(mActions[ToggleComment]);
 429     addAction(mActions[ToggleOverwriteMode]);
 430     addAction(mActions[CopyLineUp]);
 431     addAction(mActions[CopyLineDown]);
 432     addAction(mActions[MoveLineUp]);
 433     addAction(mActions[MoveLineDown]);
 434     addAction(mActions[GotoPreviousBlock]);
 435     addAction(mActions[GotoNextBlock]);
 436 }
 437
 438 void MultiEditor::updateActions()
 439 {
 440     CodeEditor *editor = currentEditor();
 441     QTextDocument *doc = editor ? editor->textDocument() : 0;
 442
 443     mActions[Undo]->setEnabled( doc && doc->isUndoAvailable() );
 444     mActions[Redo]->setEnabled( doc && doc->isRedoAvailable() );
 445     mActions[Copy]->setEnabled( editor && editor->textCursor().hasSelection() );
 446     mActions[Cut]->setEnabled( mActions[Copy]->isEnabled() );
 447     mActions[Paste]->setEnabled( editor );
 448     mActions[ToggleComment]->setEnabled( editor );
 449     mActions[ToggleOverwriteMode]->setEnabled( editor );
 450     mActions[CopyLineUp]->setEnabled( editor );
 451     mActions[CopyLineDown]->setEnabled( editor );
 452     mActions[MoveLineUp]->setEnabled( editor );
 453     mActions[MoveLineDown]->setEnabled( editor );
 454     mActions[GotoPreviousBlock]->setEnabled( editor );
 455     mActions[GotoNextBlock]->setEnabled( editor );
 456
 457     mActions[IndentLineOrRegion]->setEnabled( editor );
 458     mActions[EnlargeFont]->setEnabled( editor );
 459     mActions[ShrinkFont]->setEnabled( editor );
 460     mActions[OpenDefinition]->setEnabled( editor );
 461     mActions[EvaluateCurrentDocument]->setEnabled( editor );
 462     mActions[EvaluateRegion]->setEnabled( editor );
 463     mActions[EvaluateLine]->setEnabled( editor );
 464     mActions[ResetFontSize]->setEnabled( editor );
 465     mActions[ShowWhitespace]->setEnabled( editor );
 466     mActions[ShowWhitespace]->setChecked( editor && editor->showWhitespace() );
 467 }
 468
 469 void MultiEditor::applySettings( Settings::Manager *s )
 470 {
 471     s->beginGroup("IDE/editor");
 472     mStepForwardEvaluation = s->value("stepForwardEvaluation").toBool();
 473     s->endGroup();
 474 }
 475
 476 static QVariantList saveBoxState( CodeEditorBox *box )
 477 {
 478     // save editors in reverse order - first one is last shown.
 479     QVariantList boxData;
 480     int idx = box->history().count();
 481     while(idx--) {
 482         CodeEditor *editor = box->history()[idx];
 483         if (!editor->document()->filePath().isEmpty()) {
 484             QVariantMap editorData;
 485             editorData.insert("file", editor->document()->filePath());
 486             editorData.insert("position", editor->textCursor().position());
 487             boxData.append( editorData );
 488         }
 489     }
 490     return boxData;
 491 }
 492
 493 static QVariantMap saveSplitterState( QSplitter *splitter )
 494 {
 495     QVariantMap splitterData;
 496
 497     splitterData.insert( "state", splitter->saveState().toBase64() );
 498
 499     QVariantList childrenData;
 500
 501     int childCount = splitter->count();
 502     for (int idx = 0; idx < childCount; idx++) {
 503         QWidget *child = splitter->widget(idx);
 504
 505         CodeEditorBox *box = qobject_cast<CodeEditorBox*>(child);
 506         if (box) {
 507             QVariantList boxData = saveBoxState(box);
 508             childrenData.append( QVariant(boxData) );
 509             continue;
 510         }
 511
 512         QSplitter *childSplitter = qobject_cast<QSplitter*>(child);
 513         if (childSplitter) {
 514             QVariantMap childSplitterData = saveSplitterState(childSplitter);
 515             childrenData.append( QVariant(childSplitterData) );
 516         }
 517     }
 518
 519     splitterData.insert( "elements", childrenData );
 520
 521     return splitterData;
 522 }
 523
 524 void MultiEditor::saveSession( Session *session )
 525 {
 526     session->remove( "editors" );
 527     session->setValue( "editors", saveSplitterState(mSplitter) );
 528 }
 529
 530 void MultiEditor::loadBoxState( CodeEditorBox *box, const QVariantList & data )
 531 {
 532     mCurrentEditorBox = box;
 533     foreach( QVariant docVar, data )
 534     {
 535         QVariantMap docData = docVar.value<QVariantMap>();
 536         QString docPath = docData.value("file").toString();
 537         int docPos = docData.value("position").toInt();
 538         Main::instance()->documentManager()->open( docPath, docPos );
 539     }
 540 }
 541
 542 void MultiEditor::loadSplitterState( QSplitter *splitter, const QVariantMap & data )
 543 {
 544     QByteArray state = QByteArray::fromBase64( data.value("state").value<QByteArray>() );
 545
 546     QVariantList childrenData = data.value("elements").value<QVariantList>();
 547     foreach (const QVariant & childVar, childrenData) {
 548         if (childVar.type() == QVariant::List) {
 549             CodeEditorBox *childBox = newBox();
 550             splitter->addWidget(childBox);
 551             QVariantList childBoxData = childVar.value<QVariantList>();
 552             loadBoxState( childBox, childBoxData );
 553         }
 554         else if (childVar.type() == QVariant::Map) {
 555             QSplitter *childSplitter = new QSplitter;
 556             splitter->addWidget(childSplitter);
 557             QVariantMap childSplitterData = childVar.value<QVariantMap>();
 558             loadSplitterState( childSplitter, childSplitterData );
 559         }
 560     }
 561
 562     if (!splitter->restoreState(state))
 563         qWarning("MultiEditor: could not restore splitter state!");
 564 }
 565
 566 void MultiEditor::switchSession( Session *session )
 567 {
 568     DocumentManager *docManager = Main::instance()->documentManager();
 569     QList<Document*> docs = docManager->documents();
 570     foreach (Document *doc, docs)
 571         docManager->close(doc);
 572
 573     delete mSplitter;
 574     mSplitter = new MultiSplitter();
 575
 576     if (session && session->contains("editors")) {
 577         QVariantMap splitterData = session->value("editors").value<QVariantMap>();
 578         loadSplitterState( mSplitter, splitterData );
 579     }
 580
 581     CodeEditorBox *firstBox = 0;
 582
 583     if (mSplitter->count()) {
 584         firstBox = mSplitter->findChild<CodeEditorBox>();
 585         if (!firstBox) {
 586             qWarning("Session seems to contain invalid editor split data!");
 587             delete mSplitter;
 588             mSplitter = new MultiSplitter();
 589         }
 590     }
 591
 592     if (!firstBox) {
 593         firstBox = newBox();
 594         mSplitter->addWidget( firstBox );
 595     }
 596
 597     mCurrentEditorBox = 0; // ensure complete update
 598     setCurrentBox( firstBox );
 599
 600     layout()->addWidget(mSplitter);
 601
 602     firstBox->setFocus(Qt::OtherFocusReason); // ensure focus
 603 }
 604
 605 void MultiEditor::setCurrent( Document *doc )
 606 {
 607     int tabIdx = tabForDocument(doc);
 608     if (tabIdx != -1)
 609         mTabs->setCurrentIndex(tabIdx);
 610 }
 611
 612 void MultiEditor::showNextDocument()
 613 {
 614     int currentIndex = mTabs->currentIndex();
 615     mTabs->setCurrentIndex( qMin(currentIndex + 1, mTabs->count() - 1) );
 616 }
 617
 618 void MultiEditor::showPreviousDocument()
 619 {
 620     int currentIndex = mTabs->currentIndex();
 621     mTabs->setCurrentIndex( qMax(0, currentIndex - 1) );
 622 }
 623
 624 void MultiEditor::switchDocument()
 625 {
 626     CodeEditorBox *box = currentBox();
 627
 628     DocumentSelectPopUp * popup = new DocumentSelectPopUp(box->history(), this);
 629
 630     QRect popupRect(0,0,300,200);
 631     popupRect.moveCenter(rect().center());
 632     popup->resize(popupRect.size());
 633     QPoint globalPosition = mapToGlobal(popupRect.topLeft());
 634
 635     Document * selectedDocument = popup->exec(globalPosition);
 636
 637     if (selectedDocument)
 638         box->setDocument(selectedDocument);
 639 }
 640
 641 void MultiEditor::onOpen( Document *doc, int pos )
 642 {
 643     QTextDocument *tdoc = doc->textDocument();
 644
 645     QIcon icon;
 646     if(tdoc->isModified())
 647         icon = mDocModifiedIcon;
 648
 649     int newTabIndex = mTabs->addTab( icon, doc->title() );
 650     mTabs->setTabData( newTabIndex, QVariant::fromValue<Document*>(doc) );
 651
 652     currentBox()->setDocument(doc, pos);
 653     currentBox()->setFocus(Qt::OtherFocusReason);
 654 }
 655
 656 void MultiEditor::onClose( Document *doc )
 657 {
 658     int tabIdx = tabForDocument(doc);
 659     if (tabIdx != -1)
 660         mTabs->removeTab(tabIdx);
 661     // TODO: each box should switch document according to their own history
 662 }
 663
 664 void MultiEditor::show( Document *doc, int pos )
 665 {
 666     currentBox()->setDocument(doc, pos);
 667     currentBox()->setFocus(Qt::OtherFocusReason);
 668 }
 669
 670 void MultiEditor::update( Document *doc )
 671 {
 672     int tabIdx = tabForDocument(doc);
 673     if (tabIdx != -1)
 674         mTabs->setTabText(tabIdx, doc->title());
 675 }
 676
 677 void MultiEditor::onCloseRequest( int index )
 678 {
 679     Document *doc = documentForTab(index);
 680     if (doc)
 681         MainWindow::close(doc);
 682 }
 683
 684 void MultiEditor::onCurrentTabChanged( int index )
 685 {
 686     if (index == -1)
 687         return;
 688
 689     Document *doc = documentForTab(index);
 690     if (!doc)
 691         return;
 692
 693     CodeEditorBox *curBox = currentBox();
 694     curBox->setDocument(doc);
 695     curBox->setFocus(Qt::OtherFocusReason);
 696 }
 697
 698 void MultiEditor::onCurrentEditorChanged(CodeEditor *editor)
 699 {
 700     setCurrentEditor(editor);
 701 }
 702
 703 void MultiEditor::onBoxActivated(CodeEditorBox *box)
 704 {
 705     setCurrentBox(box);
 706 }
 707
 708 void MultiEditor::onModificationChanged( bool modified )
 709 {
 710     Q_ASSERT(currentEditor());
 711
 712     int tabIdx = tabForDocument( currentEditor()->document() );
 713     if (tabIdx == -1)
 714         return;
 715
 716     QIcon icon;
 717     if(modified)
 718         icon = mDocModifiedIcon;
 719     mTabs->setTabIcon( tabIdx, icon );
 720 }
 721
 722 void MultiEditor::evaluateRegion()
 723 {
 724     CodeEditor * editor = currentEditor();
 725     if (!editor)
 726         return;
 727
 728     QString text;
 729
 730     // Try current selection
 731     QTextCursor cursor = editor->textCursor();
 732     if (cursor.hasSelection())
 733         text = cursor.selectedText();
 734     else {
 735         // If no selection, try current region
 736         cursor = editor->currentRegion();
 737         if (!cursor.isNull()) {
 738             // if region is in a single line, evaluate complete line
 739
 740             QTextCursor selectionStart (cursor);
 741             selectionStart.setPosition(cursor.selectionStart());
 742
 743             QTextCursor selectionEnd (cursor);
 744             selectionEnd.setPosition(cursor.selectionEnd());
 745
 746             if (selectionStart.block() == selectionEnd.block())
 747                 cursor.select(QTextCursor::LineUnderCursor);
 748
 749             text = cursor.selectedText();
 750         } else {
 751             // If no current region, try current line
 752             cursor = editor->textCursor();
 753             text = cursor.block().text();
 754             if( mStepForwardEvaluation ) {
 755                 QTextCursor newCursor = cursor;
 756                 newCursor.movePosition(QTextCursor::NextBlock);
 757                 newCursor.movePosition(QTextCursor::EndOfBlock);
 758                 editor->setTextCursor(newCursor);
 759             }
 760             // Adjust cursor for code blinking:
 761             cursor.movePosition(QTextCursor::StartOfBlock);
 762             cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
 763         }
 764     }
 765
 766     if (text.isEmpty())
 767         return;
 768
 769     text.replace( QChar( 0x2029 ), QChar( '\n' ) );
 770
 771     Main::evaluateCode(text);
 772
 773     editor->blinkCode( cursor );
 774 }
 775
 776 void MultiEditor::evaluateLine()
 777 {
 778     CodeEditor * editor = currentEditor();
 779     if (!editor)
 780         return;
 781
 782     QString text;
 783
 784     // Try current selection
 785     QTextCursor cursor = editor->textCursor();
 786     cursor.select(QTextCursor::LineUnderCursor);
 787     text = cursor.selectedText();
 788
 789     if( mStepForwardEvaluation ) {
 790         QTextCursor newCursor = cursor;
 791         newCursor.movePosition(QTextCursor::NextBlock);
 792         newCursor.movePosition(QTextCursor::EndOfBlock);
 793         editor->setTextCursor(newCursor);
 794     }
 795
 796     if (text.isEmpty())
 797         return;
 798
 799     // Adjust cursor for code blinking:
 800     cursor.movePosition(QTextCursor::StartOfBlock);
 801     cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);
 802
 803     text.replace( QChar( 0x2029 ), QChar( '\n' ) );
 804
 805     Main::evaluateCode(text);
 806
 807     editor->blinkCode( cursor );
 808 }
 809
 810 void MultiEditor::evaluateDocument()
 811 {
 812     CodeEditor * editor = currentEditor();
 813     if (!editor)
 814         return;
 815
 816     QString documentText = editor->textDocument()->toPlainText();
 817     Main::evaluateCode(documentText);
 818 }
 819
 820 void MultiEditor::openDefinition(const QString &string)
 821 {
 822     QString definitionString = string.trimmed();
 823     if (definitionString.isEmpty())
 824         return;
 825
 826     LookupDialog dialog(this);
 827     dialog.query(definitionString);
 828     dialog.exec();
 829 }
 830
 831 void MultiEditor::openDefinition()
 832 {
 833     CodeEditor * editor = currentEditor();
 834     QTextCursor textCursor = editor->textCursor();
 835
 836     if (!textCursor.hasSelection())
 837         textCursor.select(QTextCursor::WordUnderCursor);
 838
 839     openDefinition(textCursor.selectedText());
 840 }
 841
 842 bool MultiEditor::openDocumentation(const QString &string)
 843 {
 844     QString symbol = string.trimmed();
 845     if (symbol.isEmpty())
 846         return false;
 847
 848     QString code = QString("HelpBrowser.openHelpFor(\"%1\")").arg(symbol);
 849     Main::evaluateCode(code, true);
 850     return true;
 851 }
 852
 853 bool MultiEditor::openDocumentation()
 854 {
 855     CodeEditor * editor = currentEditor();
 856     if (!editor)
 857         return false;
 858
 859     QTextCursor textCursor = editor->textCursor();
 860
 861     if (!textCursor.hasSelection())
 862         textCursor.select(QTextCursor::WordUnderCursor);
 863
 864     return openDocumentation(textCursor.selectedText());
 865 }
 866
 867 Document * MultiEditor::documentForTab( int index )
 868 {
 869     return mTabs->tabData(index).value<Document*>();
 870 }
 871
 872 int MultiEditor::tabForDocument( Document * doc )
 873 {
 874     int tabCount = mTabs->count();
 875     for (int idx = 0; idx < tabCount; ++idx) {
 876         Document *tabDoc = documentForTab(idx);
 877         if (tabDoc && tabDoc == doc)
 878             return idx;
 879     }
 880     return -1;
 881 }
 882
 883 CodeEditorBox *MultiEditor::newBox()
 884 {
 885     CodeEditorBox *box = new CodeEditorBox();
 886
 887     connect(box, SIGNAL(activated(CodeEditorBox*)),
 888             this, SLOT(onBoxActivated(CodeEditorBox*)));
 889
 890     return box;
 891 }
 892
 893 void MultiEditor::setCurrentBox( CodeEditorBox * box )
 894 {
 895     if (mCurrentEditorBox == box)
 896         return;
 897
 898     mCurrentEditorBox = box;
 899     mBoxSigMux->setCurrentObject(box);
 900     setCurrentEditor( box->currentEditor() );
 901
 902     mCurrentEditorBox->setActive();
 903 }
 904
 905 void MultiEditor::setCurrentEditor( CodeEditor * editor )
 906 {
 907     if (editor) {
 908         int tabIndex = tabForDocument(editor->document());
 909         if (tabIndex != -1)
 910             mTabs->setCurrentIndex(tabIndex);
 911     }
 912
 913     mSigMux->setCurrentObject(editor);
 914     updateActions();
 915
 916     Document *currentDocument = editor ? editor->document() : 0;
 917     Main::scProcess()->setActiveDocument(currentDocument);
 918     emit currentDocumentChanged(currentDocument);
 919 }
 920
 921 CodeEditor *MultiEditor::currentEditor()
 922 {
 923     return currentBox()->currentEditor();
 924 }
 925
 926 void MultiEditor::split( Qt::Orientation splitDirection )
 927 {
 928     CodeEditorBox *box = newBox();
 929     CodeEditorBox *curBox = currentBox();
 930     CodeEditor *curEditor = curBox->currentEditor();
 931
 932     if (curEditor)
 933         box->setDocument(curEditor->document(), curEditor->textCursor().position());
 934
 935     mSplitter->insertWidget(box, curBox, splitDirection);
 936     box->setFocus( Qt::OtherFocusReason );
 937 }
 938
 939 void MultiEditor::removeCurrentSplit()
 940 {
 941     int boxCount = mSplitter->findChildren<CodeEditorBox*>().count();
 942     if (boxCount < 2)
 943         // Do not allow removing the one and only box.
 944         return;
 945
 946     CodeEditorBox *box = currentBox();
 947     mSplitter->removeWidget(box);
 948
 949     // switch current box to first box found:
 950     box = mSplitter->findChild<CodeEditorBox>();
 951     Q_ASSERT(box);
 952     setCurrentBox(box);
 953     box->setFocus( Qt::OtherFocusReason );
 954 }
 955
 956 void MultiEditor::removeAllSplits()
 957 {
 958     CodeEditorBox *box = currentBox();
 959     Q_ASSERT(box);
 960     Q_ASSERT(mSplitter->count());
 961     if (mSplitter->count() == 1 && mSplitter->widget(0) == box)
 962         // Nothing to do.
 963         return;
 964
 965     MultiSplitter *newSplitter = new MultiSplitter;
 966     newSplitter->addWidget(box);
 967
 968     delete mSplitter;
 969     mSplitter = newSplitter;
 970     layout()->addWidget(newSplitter);
 971
 972     box->setFocus( Qt::OtherFocusReason );
 973 }
 974
 975 } // namespace ScIDE