mainwindow.cpp

/*
 * This file is part of Bipscript-IDE.
 *
 * Bipscript-IDE 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 3 of the License, or
 * (at your option) any later version.
 *
 * Bipscript-IDE 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 Bipscript-IDE.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "mainwindow.h"

#include "editorwidget.h"
#include "projectsdialog.h"
#include "scriptrun.h"
#include "ui_mainwindow.h"
#include "version.h"

#include <QDebug>
#include <QDesktopServices>
#include <QDir>
#include <QFileDialog>
#include <QInputDialog>
#include <QLabel>
#include <QTime>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), projectList(ProjectList::instance()),
      audioEngine(AudioEngine::instance()), transportPosition(0), ui(new Ui::MainWindow),
      timeWidget(this), bbtWidget(this) {
    ui->setupUi(this);

    // time in MM:SS + BBT + engine config
    QString labelStyle("QLabel {font-family: monospace; color: green }");
    timeWidget.setFrameStyle(QFrame::Panel | QFrame::Sunken);
    timeWidget.setStyleSheet(labelStyle);
    timeWidget.setText("00:00.000");
    ui->transportToolBar->addWidget(&timeWidget);
    bbtWidget.setFrameStyle(QFrame::Panel | QFrame::Sunken);
    bbtWidget.setStyleSheet(labelStyle);
    bbtWidget.setText("--|--|----");
    ui->transportToolBar->addWidget(&bbtWidget);
    engineWidget.setFrameStyle(QFrame::Panel | QFrame::Sunken);
    engineWidget.setStyleSheet("QLabel {font-family: monospace; color: blue }");
    engineWidget.setText("----- Hz");
    ui->transportToolBar->addWidget(&engineWidget);

    // output doc starts hidden
    ui->outputDockWidget->setHidden(true);

    ui->folderTree->setColumnCount(1);
    //
    searchWidget = new SearchWidget();
    ui->leftTabWidget->addTab(searchWidget, "Search");
    connect(searchWidget, SIGNAL(searchCurrent(QString)), this, SLOT(searchCurrent(QString)));
    connect(searchWidget, SIGNAL(searchNext(QString)), this, SLOT(searchNext(QString)));
    connect(searchWidget, SIGNAL(searchProject(QString)), this, SLOT(searchProject(QString)));
    connect(searchWidget, SIGNAL(replaceNext(QString, QString)), this,
            SLOT(replaceNext(QString, QString)));
    connect(searchWidget, SIGNAL(clearSearch()), this, SLOT(clearSearch()));
    connect(searchWidget, SIGNAL(navigateResult(EditorLocation &)), this,
            SLOT(handleLink(EditorLocation &)));

    projectList.load();
    if (projectList.currentExists()) {
        loadProject();
    } else {
        on_actionOpenProject_triggered();
    }

    connect(ui->folderTree, SIGNAL(itemClicked(QTreeWidgetItem *, int)), this,
            SLOT(folderTreeClicked(QTreeWidgetItem *, int)));

    connect(ui->tabWidget, SIGNAL(currentChanged(int)), this, SLOT(tabChanged(int)));

    connect(ui->tabWidget, SIGNAL(tabCloseRequested(int)), this, SLOT(closeEditorTab(int)));
    connect(ui->outputTabWidget, SIGNAL(tabCloseRequested(int)), this, SLOT(closeOutputTab(int)));
}

MainWindow::~MainWindow() { delete ui; }

// ------------ superclass methods

void MainWindow::closeEvent(QCloseEvent *event) {
    // save settings
    projectList.save();
    // close tabs
    if (!saveAllTabs()) {
        event->ignore();
    }
    // kill running scripts
    if (!killAllScripts()) {
        event->ignore();
    }
}

// ------------ slots

void MainWindow::changeProject() {
    ui->folderTree->clear();
    loadProject();
    // close all edit tabs not still applicable
    for (int i = ui->tabWidget->count() - 1; i >= 0; i--) {
        QWidget *widget = ui->tabWidget->widget(i);
        EditorWidget *editor = static_cast<EditorWidget *>(widget);
        if (findTreeItem(editor->path()) == nullptr) {
            ui->tabWidget->removeTab(i);
        }
    }
    selectedFolder = nullptr;
}

void MainWindow::closeEditorTab(int index) {
    EditorWidget *editor = qobject_cast<EditorWidget *>(ui->tabWidget->widget(index));
    if (saveOrAbandon(editor)) {
        projectList.currentProject().closeFile(editor->path());
        delete editor;
    }
}

void MainWindow::closeOutputTab(int index) {
    OutputWidget *output = qobject_cast<OutputWidget *>(ui->outputTabWidget->widget(index));
    QString name = ui->outputTabWidget->tabText(index);
    if (killOrDetach(output, name)) {
        delete output;
    }
}

void MainWindow::codeError(const QString &path, int line) {
    EditorWidget *editor = findEditor(path);
    if (editor) {
        editor->addError(line);
    }
}
void MainWindow::engineDisconnect() {
    ui->actionStartStopTransport->setChecked(false);
    enableTransportControls(false);
    audioEngine.disconnect();
    timeWidget.setText("00:00.000");
    bbtWidget.setText("--|--|----");
    ui->actionJackConnect->setChecked(false);
    ui->actionJackConnect->setEnabled(true);
}

bool MainWindow::createOrOpenEditor(NamedFile &file) {
    EditorWidget *editor = findEditor(file.path);
    if (editor) {
        ui->tabWidget->setCurrentWidget(editor);
    } else {
        // new editor for this file
        editor = new EditorWidget(file);
        if (editor->load()) {
            ui->tabWidget->addTab(editor, file.name);
            ui->tabWidget->setCurrentWidget(editor);
            connect(editor->document(), SIGNAL(modificationChanged(bool)), this,
                    SLOT(markDirty(bool)));
            connect(editor, SIGNAL(undoAvailable(bool)), ui->actionUndo, SLOT(setEnabled(bool)));
            connect(editor, SIGNAL(redoAvailable(bool)), ui->actionRedo, SLOT(setEnabled(bool)));
            connect(editor, SIGNAL(copyAvailable(bool)), ui->actionCut, SLOT(setEnabled(bool)));
            connect(editor, SIGNAL(copyAvailable(bool)), ui->actionCopy, SLOT(setEnabled(bool)));
            // add to project list as open file
            projectList.currentProject().openFile(file.path);
        } else {
            return false;
        }
    }
    selectedFolder = nullptr;
    enableFileActions(editor);
    return true;
}

bool MainWindow::createOrOpenEditor(const QString &path) {
    QFileInfo fileInfo(path);
    NamedFile file(fileInfo.fileName(), fileInfo.filePath());
    return createOrOpenEditor(file);
}

EditorWidget *MainWindow::currentEditor() {
    return static_cast<EditorWidget *>(ui->tabWidget->currentWidget());
}

void MainWindow::folderTreeClicked(QTreeWidgetItem *item, int) {
    NamedFile &file = static_cast<FolderTreeItem *>(item)->file();
    QFileInfo fileInfo(file.path);
    if (fileInfo.isDir()) {
        selectedFolder = &(file.path);
        enableFileActions(nullptr);
    } else if (fileInfo.isFile()) {
        createOrOpenEditor(file);
    } else {
        QMessageBox::information(this, "Unknown Entry", file.path);
    }
}

void MainWindow::handleLink(const QUrl &url) {
    QString path(url.path());
    createOrOpenEditor(path);
    if (url.hasQuery()) {
        int column = QString(url.query()).toInt();
        currentEditor()->focusLine(url.port(), column);
    } else {
        currentEditor()->focusLine(url.port());
    }
}

void MainWindow::handleLink(EditorLocation &loc) {
    createOrOpenEditor(loc.file().path);
    currentEditor()->focusLocation(loc);
}

void MainWindow::markDirty(bool value) {
    QString tabText(currentEditor()->name());
    if (value) {
        tabText.append("*");
    }
    int index = ui->tabWidget->currentIndex();
    ui->tabWidget->setTabText(index, tabText);
    ui->actionSaveFile->setEnabled(value);
    setWindowModified(value);
}

void MainWindow::searchCurrent(const QString &term) {
    EditorWidget *editor = currentEditor();
    if (editor) {
        searchWidget->addResults(editor->name(), editor->findAll(term, true), true);
    }
}

void MainWindow::searchNext(const QString &term) {
    if (currentEditor()) {
        currentEditor()->findNext(term);
    }
}

void MainWindow::replaceNext(const QString &term, const QString &replace) {
    if (currentEditor()) {
        currentEditor()->replaceNext(term, replace);
    }
}

void MainWindow::searchFolder(const QString &term, NamedFile &folder) {
    QDir dir(folder.path);
    dir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot);

    foreach (QFileInfo fileInfo, dir.entryInfoList()) {
        if (fileInfo.isFile()) {
            EditorWidget *editor = findEditor(fileInfo.filePath());
            if (editor) {
                QList<EditorLink> results = editor->findAll(term, false);
                if (results.size()) {
                    searchWidget->addResults(editor->name(), results, true);
                }
            } else {
                QList<EditorLink> results = searchFile(term, fileInfo.filePath());
                if (results.size()) {
                    searchWidget->addResults(fileInfo.fileName(), results, false);
                }
            }
        } else if (fileInfo.isDir()) {
            NamedFile childFolder(fileInfo.baseName(), fileInfo.filePath());
            searchFolder(term, childFolder);
        }
    }
}

void MainWindow::searchProject(const QString &term) {
    Project &project = projectList.currentProject();
    for (int i = 0; i < project.folderCount(); ++i) {
        NamedFile &folder = project.folder(i);
        searchFolder(term, folder);
    }
}

void MainWindow::clearSearch() {
    for (int i = 0; i < ui->tabWidget->count(); i++) {
        EditorWidget *editor = qobject_cast<EditorWidget *>(ui->tabWidget->widget(i));
        QList<QTextEdit::ExtraSelection> empty;
        editor->setExtraSelections(empty);
    }
}

void MainWindow::showTime(Position pos) {
    QTime qtime(0, 0, 0);
    qtime = qtime.addMSecs(pos.msec);
    timeWidget.setText(qtime.toString("mm:ss.zzz"));
    bbtWidget.setText(QString("%1|%2|%3").arg(pos.bar, 2).arg(pos.beat, 2).arg(pos.tick, 4));
    transportPosition = pos.frame;
}

void MainWindow::tabChanged(int i) {
    EditorWidget *editor = qobject_cast<EditorWidget *>(ui->tabWidget->widget(i));
    Project &project = projectList.currentProject();
    if (editor == nullptr) { // all tabs closed
        ui->folderTree->clearSelection();
        setWindowTitle(QCoreApplication::applicationName());
        enableFileActions(nullptr);
        project.activeFile(nullptr);
    } else {
        QTreeWidgetItem *item = findTreeItem(editor->path());
        if (item) {
            ui->folderTree->setCurrentItem(item);
        } else {
            ui->folderTree->clearSelection();
        }
        setWindowTitle(QString("%1[*]").arg(editor->name()));
        setWindowModified(editor->isDirty());
        enableFileActions(editor);
        project.activeFile(editor->path());
    }
}

void MainWindow::closeOtherEditors() {
    if (QAction *action = qobject_cast<QAction *>(sender())) {
        int index = action->data().toInt();
        for (int i = ui->tabWidget->count() - 1; i >= 0; i--) {
            if (i != index) {
                closeEditorTab(i);
            }
        }
    }
}

// ------------ auto slots

void MainWindow::on_actionAbout_triggered() {
    QString lang = QLocale::languageToString(QLocale().language());
    QString message =
        tr("Bipscript IDE %1\n%2\nQT %3").arg(BIPSCRIPT_IDE_VERSION).arg(lang).arg(QT_VERSION_STR);
    QMessageBox::about(this, "Bipscript-IDE", message);
}

void MainWindow::on_actionAPIDocumentation_triggered() {
    QStringList supported = {"en", "es"};
    QString lang = QLocale().name().left(2);
    if (supported.contains(lang)) {
        lang = supported[0];
    }
    QString link = QString("http://www.bipscript.org/%1/api/").arg(lang);
    QDesktopServices::openUrl(QUrl(link));
}

void MainWindow::on_actionCloseFile_triggered() { closeEditorTab(ui->tabWidget->currentIndex()); }

void MainWindow::on_actionComment_triggered() { currentEditor()->commentSelection(); }

void MainWindow::on_actionCopy_triggered() { currentEditor()->copy(); }

void MainWindow::on_actionCut_triggered() { currentEditor()->cut(); }

void MainWindow::on_actionNewFile_triggered() {
    QString message("New file in ");
    message.append(*selectedFolder);
    bool ok;
    QString name = QInputDialog::getText(this, "New File", message, QLineEdit::Normal, "", &ok);
    if (name.length() > 0) {
        // create file
        QFileInfo fileInfo(*selectedFolder + "/" + name);
        QString path(fileInfo.filePath());
        QFile file(path);
        if (file.exists()) {
            QMessageBox::warning(this, "File Exists", path + " already exists");
        } else {
            file.open(QIODevice::WriteOnly);
            file.close();
            // open in tree
            ui->folderTree->clear();
            loadProject();
        }
        QTreeWidgetItem *item = findTreeItem(path);
        ui->folderTree->setCurrentItem(item);
        createOrOpenEditor(path);
    }
}

void MainWindow::on_actionDeleteFile_triggered() {
    QMessageBox msgBox;
    QString path(currentEditor()->path());
    msgBox.setText("Delete " + path);
    msgBox.setInformativeText("Do you want to delete " + currentEditor()->name() + "?");
    msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
    msgBox.setDefaultButton(QMessageBox::Cancel);
    int choice = msgBox.exec();
    if (choice == QMessageBox::Ok) {
        // remove from tree
        FolderTreeItem *item = static_cast<FolderTreeItem *>(findTreeItem(path));
        item->parent()->removeChild(item);
        // remove from project
        projectList.currentProject().closeFile(path);
        // remove editor if any
        delete findEditor(path);
        // remove file from filesystem
        QFile::remove(path);
    }
}

void MainWindow::on_actionExamples_triggered() {
    QRegExp versionExp = QRegExp("v([0-9\\.]+)");
    QString versionString = QString(BIPSCRIPT_IDE_VERSION);
    if (versionExp.indexIn(versionString) == 0) {
        QString version = versionExp.cap(1);
        QString link("https://github.com/bipscript/examples/releases/tag/v");
        link.append(version);
        QDesktopServices::openUrl(QUrl(link));
    } else {
        QString message = tr("No examples for version %1").arg(versionString);
        QMessageBox::warning(this, tr("Unknown Version"), message, QMessageBox::Ok);
    }
}

void MainWindow::on_actionExit_triggered() { QApplication::closeAllWindows(); }

void MainWindow::on_actionFastForward_triggered() {
    transportPosition = transportPosition + audioConfig.framesPerSecond;
    audioEngine.reposition(transportPosition);
}

void MainWindow::on_actionFind_in_Project_triggered() {
    searchWidget->newProjectSearch();
    ui->leftTabWidget->setCurrentWidget(searchWidget);
}

/**
 * @brief MainWindow::on_actionRun_triggered
 *
 * action to run script
 */
void MainWindow::on_actionRun_triggered() {
    // check if possible
    if (!ScriptRun::possible()) {
        QMessageBox::warning(this, "Executable", "Cannot launch bipscript executable");
        return;
    }
    ScriptRun *run = new ScriptRun(currentEditor()->path());
    // add output widget for this run
    OutputWidget *out = new OutputWidget();
    ui->outputTabWidget->addTab(out, currentEditor()->name());
    ui->outputTabWidget->setCurrentWidget(out);
    connect(run, SIGNAL(started(int)), out, SLOT(running(int)));
    connect(run, SIGNAL(readStdout(QString)), out, SLOT(write(QString)));
    connect(run, SIGNAL(readStderr(QString)), out, SLOT(writeError(QString)));
    connect(run, SIGNAL(error(QString)), out, SLOT(writeError(QString)));
    connect(run, SIGNAL(exited(int)), out, SLOT(completed(int)));
    connect(out, SIGNAL(codeError(const QString &, int)), this,
            SLOT(codeError(const QString &, int)));
    connect(out, SIGNAL(linkClicked(const QUrl &)), this, SLOT(handleLink(const QUrl &)));
    // show output area if hidden
    ui->outputDockWidget->show();
    run->start();
}

void MainWindow::enableTransportControls(bool enabled) {
    ui->actionStartStopTransport->setEnabled(enabled);
    ui->actionRewind->setEnabled(enabled);
    ui->actionRestart->setEnabled(enabled);
    ui->actionFastForward->setEnabled(enabled);
}

void MainWindow::on_actionJackConnect_toggled(bool connected) {
    if (connected) {
        audioConfig = audioEngine.connect();
        atimer = audioEngine.timerService();
        connect(atimer, SIGNAL(transport(Position)), this, SLOT(showTime(Position)));
        connect(atimer, SIGNAL(rolling(bool)), ui->actionStartStopTransport,
                SLOT(setChecked(bool)));
        connect(atimer, SIGNAL(finished()), this, SLOT(engineDisconnect()));
        engineWidget.setText(QString("%1 Hz").arg(audioConfig.framesPerSecond));
    } else {
        ui->actionJackConnect->setEnabled(false);
        atimer->stop();
        engineWidget.setText("----- Hz");
    }
    enableTransportControls(connected && !ui->actionTransportLock->isChecked());
}

void MainWindow::on_actionOpenFile_triggered() {
    QFileDialog fileDialog(this);
    fileDialog.setFileMode(QFileDialog::AnyFile);
    fileDialog.setDirectory(projectList.commonRoot());
    if (fileDialog.exec()) {
        QString path = fileDialog.selectedFiles()[0];
        createOrOpenEditor(path);
    }
}

void MainWindow::on_actionOpenProject_triggered() {
    if (saveAllTabs()) {
        ProjectsDialog projectsDialog(this);
        connect(&projectsDialog, SIGNAL(projectChanged()), this, SLOT(changeProject()));
        projectsDialog.exec();
    }
}

void MainWindow::on_actionPaste_triggered() { currentEditor()->paste(); }

void MainWindow::on_actionProjectOptions_triggered() {
    Project &project = projectList.currentProject();
    QString value = project.executable();
    QString message("Executable Path");
    bool ok;
    QString name = QInputDialog::getText(this, "Options", message, QLineEdit::Normal, value, &ok);
    if (name.length() > 0) {
        // TODO: test existance etc.
        project.executable(name);
        ScriptRun::setExecutable(project.executable());
    }
}

void MainWindow::on_actionRedo_triggered() { currentEditor()->redo(); }

void MainWindow::on_actionRenameFile_triggered() {
    if (saveOrAbandon(currentEditor())) {
        QString message("New name");
        QString oldPath = currentEditor()->path();
        bool ok;
        QString path =
            QInputDialog::getText(this, "Rename", message, QLineEdit::Normal, oldPath, &ok);
        if (path.length() > 0) {
            QFileInfo fileInfo(path);
            if (fileInfo.exists()) {
                QString message = QString("Cannot move file, target exists:\n%1").arg(path);
                QMessageBox::warning(this, "File exists", message);
                return;
            }
            QFile oldFile(oldPath);
            if (!oldFile.rename(fileInfo.filePath())) {
                QString message = QString("Error on move\n %1 ->\n %2").arg(oldPath).arg(path);
                QMessageBox::warning(this, "File Move Error", message);
                return;
            }
            // success
            NamedFile file;
            file.name = fileInfo.fileName();
            file.path = fileInfo.filePath();
            // remove old from tree
            QTreeWidgetItem *item = findTreeItem(oldPath);
            if (item) {
                item->parent()->removeChild(item);
            }
            ui->folderTree->clearSelection();
            // update project
            Project &project = projectList.currentProject();
            project.closeFile(oldPath);
            project.openFile(path);
            // add new to tree if possible
            QTreeWidgetItem *parent = findTreeItem(fileInfo.path());
            if (parent) {
                FolderTreeItem *newItem =
                    new FolderTreeItem(parent, fileInfo.fileName(), fileInfo.filePath());
                ui->folderTree->setCurrentItem(newItem);
            }
            // update editor + tab
            currentEditor()->moveFile(file);
            int index = ui->tabWidget->currentIndex();
            QString tabText(currentEditor()->name());
            if (currentEditor()->isDirty()) {
                tabText.append("*");
            }
            ui->tabWidget->setTabText(index, tabText);
            // update main window title
            setWindowTitle(QString("%1[*]").arg(file.name));
        }
    }
}

void MainWindow::on_actionRestart_triggered() { audioEngine.reposition(0); }

void MainWindow::on_actionRewind_triggered() {
    int newpos = static_cast<int>(transportPosition - audioConfig.framesPerSecond);
    transportPosition = static_cast<uint>(qMax(newpos, 0));
    audioEngine.reposition(transportPosition);
}

void MainWindow::on_actionSaveFile_triggered() { currentEditor()->save(); }

void MainWindow::on_actionFocusFind_triggered() {
    searchWidget->newFileSearch();
    ui->leftTabWidget->setCurrentWidget(searchWidget);
}

void MainWindow::on_actionStartStopTransport_toggled(bool start) {
    if (start) {
        audioEngine.transportStart();
    } else {
        audioEngine.transportStop();
    }
    ui->actionJackConnect->setEnabled(!start);
}

void MainWindow::on_actionTransportLock_toggled(bool locked) {
    bool enabled = !locked && ui->actionJackConnect->isChecked();
    ui->actionStartStopTransport->setEnabled(enabled);
    ui->actionRewind->setEnabled(enabled);
    ui->actionRestart->setEnabled(enabled);
    ui->actionFastForward->setEnabled(enabled);
}

void MainWindow::on_actionUndo_triggered() { currentEditor()->undo(); }

void MainWindow::on_tabWidget_customContextMenuRequested(const QPoint &pos) {
    QMenu menu;
    QAction *action = menu.addAction(tr("Close Other Tabs"), this, SLOT(closeOtherEditors()));
    action->setData(ui->tabWidget->tabBar()->tabAt(pos));
    action->setEnabled(ui->tabWidget->count() > 1);
    menu.exec(QCursor::pos());
}

// ------------ private methods

void MainWindow::enableFileActions(EditorWidget *editor) {
    // requires file selected
    ui->actionDeleteFile->setEnabled(editor);
    ui->actionRun->setEnabled(editor);
    ui->actionPaste->setEnabled(editor);
    ui->actionCloseFile->setEnabled(editor);
    ui->actionComment->setEnabled(editor);
    ui->actionRenameFile->setEnabled(editor);
    // requires directory selected
    ui->actionNewFile->setEnabled(selectedFolder);
    // requires state from the editor
    ui->actionSaveFile->setEnabled(editor && editor->isDirty());
    ui->actionUndo->setEnabled(editor && editor->isUndoAvailable());
    ui->actionRedo->setEnabled(editor && editor->isRedoAvailable());
    ui->actionCut->setEnabled(editor && editor->hasSelection());
    ui->actionCopy->setEnabled(editor && editor->hasSelection());
}

EditorWidget *MainWindow::findEditor(const QString &path) {
    for (int i = 0; i < ui->tabWidget->count(); i++) {
        EditorWidget *editor = qobject_cast<EditorWidget *>(ui->tabWidget->widget(i));
        if (editor->path() == path) {
            return editor;
        }
    }
    return nullptr;
}

QTreeWidgetItem *MainWindow::findTreeItem(const QString &path) {
    QTreeWidgetItemIterator it(ui->folderTree);
    while (*it) {
        FolderTreeItem *item = static_cast<FolderTreeItem *>(*it);
        if (item->file().path == path) {
            return item;
        }
        ++it;
    }
    return nullptr;
}

void MainWindow::loadProject() {
    Project &project = projectList.currentProject();
    ScriptRun::setExecutable(project.executable());
    for (int i = 0; i < project.folderCount(); ++i) {
        NamedFile &folder = project.folder(i);
        ui->folderTree->addTopLevelItem(toTreeFolder(folder));
    }
    foreach (const QString &path, project.openFiles()) {
        if (!createOrOpenEditor(path)) {
            project.closeFile(path);
        }
    }
    EditorWidget *editor = findEditor(project.activeFile());
    if (editor) {
        ui->tabWidget->setCurrentWidget(editor);
    }
    searchWidget->clear();
    ui->leftTabWidget->setCurrentWidget(ui->folderTree);
}

bool MainWindow::saveAllTabs() {
    for (int i = 0; i < ui->tabWidget->count(); i++) {
        EditorWidget *editor = static_cast<EditorWidget *>(ui->tabWidget->widget(i));
        if (editor->isDirty()) {
            QMessageBox::StandardButton choice = unsavedChangesDialog(editor->path());
            if (choice == QMessageBox::Cancel) {
                return false;
            } else if (choice == QMessageBox::Save) {
                editor->save();
            }
        }
    }
    return true;
}

bool MainWindow::saveOrAbandon(EditorWidget *editor) {
    if (editor->isDirty()) {
        QMessageBox::StandardButton choice = unsavedChangesDialog(editor->path());
        if (choice == QMessageBox::Cancel) {
            return false;
        } else if (choice == QMessageBox::Save) {
            if (!editor->save()) {
                return false;
            }
        }
    }
    return true;
}

QList<EditorLink> MainWindow::searchFile(const QString &term, const QString &path) {
    QList<EditorLink> ret;
    QFile file(path);
    if (file.open(QFile::ReadOnly | QFile::Text)) {
        QTextStream in(&file);
        int lineindex = 0;
        while (!in.atEnd()) {
            QString line = in.readLine();
            int index = line.indexOf(term, 0, Qt::CaseInsensitive);
            while (index != -1) {
                NamedFile nfile(file.fileName(), path);
                int anchor = lineindex + index;
                // find snippet
                int space = line.indexOf(QRegExp("\\s+"), index);
                int end = (space == -1 ? line.size() : space);
                QString text = line.mid(index, end - index);
                // create and add editor link
                EditorLink link(text, nfile, anchor, anchor + term.size());
                ret.append(link);
                index = line.indexOf(term, index + 1, Qt::CaseInsensitive);
            }
            lineindex += line.length() + 1;
        }
    }
    return ret;
}

bool MainWindow::killAllScripts() {
    for (int i = 0; i < ui->outputTabWidget->count(); i++) {
        OutputWidget *output = qobject_cast<OutputWidget *>(ui->outputTabWidget->widget(i));
        QString name = ui->outputTabWidget->tabText(i);
        if (!killOrDetach(output, name)) {
            return false;
        }
    }
    return true;
}

bool MainWindow::killOrDetach(OutputWidget *output, const QString &name) {
    if (output->pid() != 0) {
        QString id = QString("%1 pid %2").arg(name).arg(output->pid());
        QString mesg = "%1 is still running.\nDo you wish to kill the process?";
        QMessageBox::StandardButton choice =
            QMessageBox::warning(this, tr("Running Process"), mesg.arg(id),
                                 QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
        if (choice == QMessageBox::Cancel) {
            return false;
        } else if (choice == QMessageBox::Yes) {
            output->killScript(true);
        }
    }
    return true;
}

FolderTreeItem *MainWindow::toTreeFolder(NamedFile &folder) {
    FolderTreeItem *folderItem = new FolderTreeItem(nullptr, folder.name, folder.path);
    QDir dir(folder.path);
    dir.setFilter(QDir::AllEntries | QDir::NoDotAndDotDot);
    foreach (QFileInfo fileInfo, dir.entryInfoList()) {
        if (fileInfo.isFile()) {
            folderItem->addChild(
                new FolderTreeItem(folderItem, fileInfo.fileName(), fileInfo.filePath()));
        } else if (fileInfo.isDir()) {
            NamedFile childFolder(fileInfo.baseName(), fileInfo.filePath());
            folderItem->addChild(toTreeFolder(childFolder));
        }
    }
    return folderItem;
}

QMessageBox::StandardButton MainWindow::unsavedChangesDialog(const QString &path) {
    return QMessageBox::warning(this, tr("Unsaved Changes"),
                                tr("%1 has unsaved changes.\nDo you wish to save?").arg(path),
                                QMessageBox::Save | QMessageBox::No | QMessageBox::Cancel);
}

void MainWindow::on_actionWebsite_triggered() {
    QString link = "http://www.bipscript.org";
    QDesktopServices::openUrl(QUrl(link));
}