CodeEditorDialog.cpp

Go to the documentation of this file.

/*
  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

  This file is part of the TerraLib - a Framework for building GIS enabled
  applications.

  TerraLib is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License,
  or (at your option) any later version.

  TerraLib 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 Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with TerraLib. See COPYING. If not, write to
  TerraLib Team at <terralib-team@terralib.org>.
*/
// TerraLib
#include "CodeEditorDialog.h"
#include "../Exception.h"
#include "../qt/widgets/ceditor/ScriptWidget.h"
#include "../qt/widgets/ceditor/Utils.h"
#include "../vm/core/VirtualMachineManager.h"
#include "ui_CodeEditorDialogForm.h"

// Qt
#include <QtConcurrent/qtconcurrentrun.h>
#include <QFileDialog>
#include <QFuture>
#include <QFutureWatcher>
#include <QLayout>
#include <QMessageBox>
#include <QPushButton>
#include <QString>
#include <QTimer>

// STL
#include <iostream>

te::ce::CodeEditorDialog::CodeEditorDialog(QWidget* parent, Qt::WindowFlags f)
    : QDialog(parent, f), m_vm(nullptr), m_ui(new Ui::CodeEditorDialogForm)
{
  this->setWindowTitle(tr("TerraLib Code Editor"));
  m_ui->setupUi(this);

  // Setup the buttons
  m_ui->m_newButton->setIcon(QIcon::fromTheme("document-new"));
  m_ui->m_newButton->setShortcut(QKeySequence("Ctrl+N"));
  m_ui->m_newButton->setIconSize(QSize(24, 24));
  m_ui->m_newButton->setToolTip("New script file");

  m_ui->m_openButton->setIcon(QIcon::fromTheme("document-open"));
  m_ui->m_openButton->setShortcut(QKeySequence("Ctrl+O"));
  m_ui->m_openButton->setIconSize(QSize(24, 24));
  m_ui->m_openButton->setToolTip("Open script file");

  m_ui->m_saveButton->setIcon(QIcon::fromTheme("document-save"));
  m_ui->m_saveButton->setShortcut(QKeySequence("Ctrl+S"));
  m_ui->m_saveButton->setIconSize(QSize(24, 24));
  m_ui->m_saveButton->setToolTip("Save script file");

  m_ui->m_saveAsButton->setIcon(QIcon::fromTheme("document-save-as"));
  m_ui->m_saveAsButton->setShortcut(QKeySequence("Ctrl+Shift+S"));
  m_ui->m_saveAsButton->setIconSize(QSize(24, 24));
  m_ui->m_saveAsButton->setToolTip("Save script file as");

  m_ui->m_runButton->setIcon(QIcon::fromTheme("media-playback-start-green"));
  m_ui->m_runButton->setShortcut(QKeySequence("Ctrl+R"));
  m_ui->m_runButton->setIconSize(QSize(32, 32));
  m_ui->m_runButton->setToolTip("Run script file");

  m_ui->m_stopButton->setIcon(QIcon::fromTheme("process-stop"));
  m_ui->m_stopButton->setShortcut(QKeySequence("Ctrl+Shift+R"));
  m_ui->m_stopButton->setIconSize(QSize(24, 24));
  m_ui->m_stopButton->setToolTip("Stop running script");

  m_io = new te::qt::widgets::IOWidget(this);
  m_ui->splitter->addWidget(m_io);

  // connect all the buttons
  connect(m_ui->m_newButton, SIGNAL(clicked()), this,
          SLOT(onNewButtonClicked()));
  connect(m_ui->m_openButton, SIGNAL(clicked()), this,
          SLOT(onOpenButtonClicked()));
  connect(m_ui->m_saveButton, SIGNAL(clicked()), this,
          SLOT(onSaveButtonClicked()));
  connect(m_ui->m_saveAsButton, SIGNAL(clicked()), this,
          SLOT(onSaveAsButtonClicked()));
  connect(m_ui->m_runButton, SIGNAL(clicked()), this,
          SLOT(onRunButtonClicked()));
  connect(m_ui->m_codeTab, SIGNAL(tabCloseRequested(int)), this,
          SLOT(onCloseTabClicked(int)));
  connect(&m_watcher, SIGNAL(finished()), this, SLOT(onRunFinished()));

  // gray out for disabled buttons
  this->setStyleSheet(
      QString::fromUtf8("QPushButton:disabled { color: gray }"));

  // disable stop button
  m_ui->m_stopButton->setEnabled(false);
}

te::ce::CodeEditorDialog::~CodeEditorDialog()
{
  m_ui->m_codeTab->clear();
  m_vm = nullptr;
}

void te::ce::CodeEditorDialog::onNewButtonClicked()
{
  // creates a new ScriptWidget
  te::qt::widgets::ScriptWidget* editor =
      new te::qt::widgets::ScriptWidget(this);

  // insert into the QTabWidget
  m_ui->m_codeTab->insertTab(0, editor, "");

  // set the focus to the new tab
  m_ui->m_codeTab->setCurrentIndex(0);

  connect(editor, SIGNAL(textChanged()), this, SLOT(onTextChanged()));
}

void te::ce::CodeEditorDialog::save(bool saveAs)
{
  // return if tab count is 0
  if(m_ui->m_codeTab->count() == 0)
    return;

  // get the current tab
  te::qt::widgets::ScriptWidget* editor =
      (te::qt::widgets::ScriptWidget*)m_ui->m_codeTab->currentWidget();

  // if the tab has no filename set, calls a file dialog
  if(editor->getFileName().isEmpty() || saveAs)
  {
    QString filter =
        tr("Python (*.py *.PY);;Lua (*.lua *.LUA);;All files(*.*)");
    QString selFilter;
    QString file = QFileDialog::getSaveFileName(this, tr("Save Script File"),
                                                "", filter, &selFilter);
    editor->save(file);
    auto index = m_ui->m_codeTab->currentIndex();
    m_ui->m_codeTab->setTabText(index, QFileInfo(file).fileName());
    m_ui->m_codeTab->setTabIcon(index, te::qt::widgets::CreateLangIcon(file));
  }
  // else saves to the same filename
  else
  {
    auto index = m_ui->m_codeTab->currentIndex();
    m_ui->m_codeTab->setTabText(index,
                                QFileInfo(editor->getFileName()).fileName());
    editor->save(editor->getFileName());
  }
}

void te::ce::CodeEditorDialog::onRunButtonClicked()
{
  // saves before running
  onSaveButtonClicked();

  if(m_ui->m_codeTab->count() == 0)
    return;

  // get the current ScriptWidget
  te::qt::widgets::ScriptWidget* editor =
      (te::qt::widgets::ScriptWidget*)m_ui->m_codeTab->currentWidget();

  // retrieves the VM for the correspondent script type
  try
  {
    m_vm = te::vm::core::VirtualMachineManager::instance().get(
        editor->getScriptType().toUtf8().data());

    // set the script file name in the vm
    m_vm->setFileName(editor->getFileName());

    // VM to UI connects
    connect(m_vm, SIGNAL(output(QString)), m_io, SLOT(append(QString)));
    connect(m_vm, SIGNAL(requestReadline()), m_io, SLOT(addPrompt()));
    connect(m_io, SIGNAL(command(QString)), m_vm, SLOT(readline(QString)));
    connect(m_ui->m_stopButton, SIGNAL(clicked()), m_vm, SLOT(stop()));

    m_io->clear();

    // disable run button and enable stop button
    m_ui->m_runButton->setDisabled(true);
    m_ui->m_stopButton->setDisabled(false);

    // start a elapsed timer
    m_runtime.restart();

    QFuture<void> future =
        QtConcurrent::run(m_vm, &te::vm::core::VirtualMachine::execute);
    m_watcher.setFuture(future);
  }
  catch(te::OutOfRangeException)
  {
    QMessageBox::warning(
        nullptr, this->windowTitle(),
        "Could not find a interpreter to run the following file: " +
            editor->getScriptName());
    return;
  }
}

void te::ce::CodeEditorDialog::onRunFinished()
{
  // get the elapsed time
  int time = m_runtime.elapsed();

  // disconnect the VM from the UI
  disconnect(m_vm, SIGNAL(output(QString)), m_io, SLOT(append(QString)));
  disconnect(m_vm, SIGNAL(requestReadline()), m_io, SLOT(addPrompt()));
  disconnect(m_io, SIGNAL(command(QString)), m_vm, SLOT(readline(QString)));
  disconnect(m_ui->m_stopButton, SIGNAL(clicked()), m_vm, SLOT(stop()));

  // enables run button and disables stop button
  m_ui->m_runButton->setDisabled(false);
  m_ui->m_stopButton->setDisabled(true);

  // appends the elapse time to the output
  std::string elapsed = "[Time elapsed: " + std::to_string(time) + "ms]";
  m_io->append(elapsed.c_str());
}

void te::ce::CodeEditorDialog::onSaveButtonClicked()
{
  save(false);
}

void te::ce::CodeEditorDialog::onSaveAsButtonClicked()
{
  save(true);
}

void te::ce::CodeEditorDialog::onOpenButtonClicked()
{
  QString filter =
      tr("Python (*.py *.PY);;Lua (*.lua *.LUA);;All files  (*.*)");
  QString selFilter;
  // get a script filename
  QString file = QFileDialog::getOpenFileName(this, tr("Open Script File"), "",
                                              filter, &selFilter);

  // if nothing is selected, return
  if(file.isEmpty())
    return;

  // creates a new ScriptWidget
  te::qt::widgets::ScriptWidget* editor =
      new te::qt::widgets::ScriptWidget(this);

  // sets the filename to the ScriptWidget
  editor->open(file);

  QFile f(file);
  // insert the ScriptWidget to QTabWidget
  m_ui->m_codeTab->insertTab(0, editor, te::qt::widgets::CreateLangIcon(file),
                             QFileInfo(f).fileName());
  // set the focus to the opened script
  m_ui->m_codeTab->setCurrentIndex(0);

  connect(editor, SIGNAL(textChanged()), this, SLOT(onTextChanged()));
}
void te::ce::CodeEditorDialog::onCloseTabClicked(int index)
{
  // removes the current tab
  m_ui->m_codeTab->removeTab(index);
}

void te::ce::CodeEditorDialog::onTextChanged()
{
  te::qt::widgets::ScriptWidget* editor =
      qobject_cast<te::qt::widgets::ScriptWidget*>(sender());
  int tabIndex = m_ui->m_codeTab->indexOf(editor);

  QString tabText = m_ui->m_codeTab->tabText(tabIndex);
  if(!tabText.endsWith(" *"))
  {
    tabText += " *";
    m_ui->m_codeTab->setTabText(tabIndex, tabText);
  }
}