ApplicationWindow.cpp

  //plotTools->addAction(btnRemovePoints); disabled until fixed (#2783)

  if (mantidUI->fitFunctionBrowser())
  {
    btnMultiPeakPick = new QAction(tr("Select Multiple Peaks..."), this);
    btnMultiPeakPick->setActionGroup(dataTools);
    btnMultiPeakPick->setCheckable( true );
    btnMultiPeakPick->setIcon(QIcon(getQPixmap("Fit_xpm")));
    plotTools->addAction(btnMultiPeakPick);
  }
  else
  {
    btnMultiPeakPick = NULL;
  }

  connect( dataTools, SIGNAL( triggered( QAction* ) ), this, SLOT( pickDataTool( QAction* ) ) );
  plotTools->addSeparator ();

  btnArrow = new QAction(tr("Draw &Arrow"), this);
  btnArrow->setShortcut( tr("CTRL+ALT+A") );
  btnArrow->setActionGroup(dataTools);
  btnArrow->setCheckable( true );
  btnArrow->setIcon(QIcon(getQPixmap("arrow_xpm")) );
  plotTools->addAction(btnArrow);

  btnLine = new QAction(tr("Draw &Line"), this);
  btnLine->setShortcut( tr("CTRL+ALT+L") );
  btnLine->setActionGroup(dataTools);
  btnLine->setCheckable( true );
  btnLine->setIcon(QIcon(getQPixmap("lPlot_xpm")) );
  plotTools->addAction(btnLine);

  plotTools->hide();

  displayBar = new QToolBar( tr( "Data Display" ), this );
  displayBar->setAllowedAreas( Qt::TopToolBarArea | Qt::BottomToolBarArea );
  displayBar->setObjectName("displayBar"); // this is needed for QMainWindow::restoreState()
  info = new QLineEdit( this );
  displayBar->addWidget( info );
  info->setReadOnly(true);
  QPalette palette;
  palette.setColor(QPalette::Text, QColor(Qt::green));
  palette.setColor(QPalette::HighlightedText, QColor(Qt::darkGreen));
  palette.setColor(QPalette::Base, QColor(Qt::black));
  info->setPalette(palette);

  addToolBar( Qt::TopToolBarArea, displayBar );
  displayBar->hide();

  insertToolBarBreak (displayBar);

  formatToolBar = new QToolBar(tr( "Format" ), this);
  formatToolBar->setObjectName("formatToolBar");
  addToolBar(Qt::TopToolBarArea, formatToolBar);

  QFontComboBox *fb = new QFontComboBox();
  connect(fb, SIGNAL(currentFontChanged(const QFont &)), this, SLOT(setFontFamily(const QFont &)));
  actionFontBox = formatToolBar->addWidget(fb);

  QSpinBox *sb = new QSpinBox();
  connect(sb, SIGNAL(valueChanged(int)), this, SLOT(setFontSize(int)));
  actionFontSize = formatToolBar->addWidget(sb);

  actionFontBold->addTo(formatToolBar);
  actionFontItalic->addTo(formatToolBar);

  actionUnderline->addTo(formatToolBar);
  actionSuperscript->addTo(formatToolBar);
  actionSubscript->addTo(formatToolBar);
  actionGreekSymbol->addTo(formatToolBar);
  actionGreekMajSymbol->addTo(formatToolBar);
  actionMathSymbol->addTo(formatToolBar);

  formatToolBar->setEnabled(false);
  formatToolBar->hide();



}

void ApplicationWindow::insertTranslatedStrings()
{
  if (projectname == "untitled")
    setWindowTitle(tr("MantidPlot - untitled"));//Mantid

  lv->setColumnText (0, tr("Name"));
  lv->setColumnText (1, tr("Type"));
  lv->setColumnText (2, tr("View"));
  lv->setColumnText (3, tr("Size"));
  lv->setColumnText (4, tr("Created"));
  lv->setColumnText (5, tr("Label"));

  explorerWindow->setWindowTitle(tr("Project Explorer"));
  logWindow->setWindowTitle(tr("Results Log"));
  undoStackWindow->setWindowTitle(tr("Undo Stack"));
  consoleWindow->setWindowTitle(tr("Scripting Console"));
  displayBar->setWindowTitle(tr("Data Display"));
  plotTools->setWindowTitle(tr("Plot"));
  fileTools->setWindowTitle(tr("File"));
  editTools->setWindowTitle(tr("Edit"));
  plot3DTools->setWindowTitle(tr("3D Surface"));
  formatToolBar->setWindowTitle(tr("Format"));

  fileMenu->changeItem(recentMenuID, tr("&Recent Projects"));

  translateActionsStrings();
  customMenu(activeWindow());
}

void ApplicationWindow::initMainMenu()
{
  fileMenu = new QMenu(this);
  fileMenu->setObjectName("fileMenu");
  connect(fileMenu, SIGNAL(aboutToShow()), this, SLOT(fileMenuAboutToShow()));

  recent = new QMenu(this);
  newMenu = new QMenu(this);
  newMenu->setObjectName("newMenu");
  exportPlotMenu = new QMenu(this);
  exportPlotMenu->setObjectName("exportPlotMenu");

  edit = new QMenu(this);
  edit->setObjectName("editMenu");

  edit->insertSeparator();
  edit->addAction(actionCopySelection);
  edit->addAction(actionPasteSelection);
  edit->insertSeparator();
  edit->addAction(actionDeleteFitTables);

  connect(edit, SIGNAL(aboutToShow()), this, SLOT(editMenuAboutToShow()));

  view = new QMenu(this);
  view->setObjectName("viewMenu");

  view->setCheckable(true);

  //view->addAction(actionShowPlotWizard);
  view->addAction(actionShowExplorer);
  view->addAction(actionShowLog);
  //view->addAction(actionShowUndoStack);
  view->addAction(actionShowConsole);

  view->insertSeparator();
  view->addAction(actionShowScriptWindow);//Mantid
  view->addAction(actionShowScriptInterpreter);
  view->addAction(actionIPythonConsole);
  view->insertSeparator();

  mantidUI->addMenuItems(view);

  view->insertSeparator();
  view->addAction(actionToolBars);
  view->addAction(actionShowConfigureDialog);
  view->insertSeparator();
  view->addAction(actionCustomActionDialog);

  graph = new QMenu(this);
  graph->setObjectName("graphMenu");
  graph->setCheckable(true);
  graph->addAction(actionAddErrorBars);
  graph->addAction(actionRemoveErrorBars);
  graph->addAction(actionShowCurvesDialog);
  graph->addAction(actionAddFunctionCurve);
  graph->addAction(actionNewLegend);
  graph->insertSeparator();
  graph->addAction(btnLabel);
  graph->addAction(btnArrow);
  graph->addAction(btnLine);
  graph->addAction(actionTimeStamp);
  graph->addAction(actionAddImage);
  graph->insertSeparator();//layers section
  graph->addAction(actionAddLayer);
  graph->addAction(actionDeleteLayer);
  graph->addAction(actionShowLayerDialog);

  plot3DMenu = new QMenu(this);
  plot3DMenu->setObjectName("plot3DMenu");
  plot3DMenu->addAction(actionPlot3DWireFrame);
  plot3DMenu->addAction(actionPlot3DHiddenLine);
  plot3DMenu->addAction(actionPlot3DPolygons);
  plot3DMenu->addAction(actionPlot3DWireSurface);
  plot3DMenu->insertSeparator();
  plot3DMenu->addAction(actionPlot3DBars);
  plot3DMenu->addAction(actionPlot3DScatter);
  plot3DMenu->insertSeparator();
  plot3DMenu->addAction(actionImagePlot);
  plot3DMenu->addAction(actionColorMap);
  plot3DMenu->addAction(actionNoContourColorMap);
  plot3DMenu->addAction(actionContourMap);
  plot3DMenu->addAction(actionGrayMap);
  plot3DMenu->insertSeparator();
  //plot3DMenu->addAction(actionPlotHistogram);

  matrixMenu = new QMenu(this);
  matrixMenu->setObjectName("matrixMenu");
  connect(matrixMenu, SIGNAL(aboutToShow()), this, SLOT(matrixMenuAboutToShow()));

  plot2DMenu = new QMenu(this);
  plot2DMenu->setObjectName("plot2DMenu");
  connect(plot2DMenu, SIGNAL(aboutToShow()), this, SLOT(plotMenuAboutToShow()));

  plotDataMenu = new QMenu(this);
  plotDataMenu->setObjectName("plotDataMenu");
  plotDataMenu->setCheckable(true);
  connect(plotDataMenu, SIGNAL(aboutToShow()), this, SLOT(plotDataMenuAboutToShow()));

  normMenu = new QMenu(this);
  normMenu->setObjectName("normMenu");

  fillMenu = new QMenu(this);
  fillMenu->setObjectName("fillMenu");

  tableMenu = new QMenu(this);
  tableMenu->setObjectName("tableMenu");
  connect(tableMenu, SIGNAL(aboutToShow()), this, SLOT(tableMenuAboutToShow()));

  smoothMenu = new QMenu(this);
  smoothMenu->setObjectName("smoothMenu");

  filterMenu = new QMenu(this);
  filterMenu->setObjectName("filterMenu");

  decayMenu = new QMenu(this);
  decayMenu->setObjectName("decayMenu");

  multiPeakMenu = new QMenu(this);
  multiPeakMenu->setObjectName("multiPeakMenu");

  analysisMenu = new QMenu(this);
  analysisMenu->setObjectName("analysisMenu");
  connect(analysisMenu, SIGNAL(aboutToShow()), this, SLOT(analysisMenuAboutToShow()));

  format = new QMenu(this);
  format->setObjectName("formatMenu");

  windowsMenu = new QMenu(this);
  windowsMenu->setObjectName("windowsMenu");
  windowsMenu->setCheckable(true);
  connect(windowsMenu, SIGNAL(aboutToShow()), this, SLOT(windowsMenuAboutToShow()));

  foldersMenu = new QMenu(this);
  foldersMenu->setCheckable(true);

  help = new QMenu(this);
  help->setObjectName("helpMenu");

  help->addAction(actionHomePage);
  help->addAction(actionMantidConcepts);
  help->addAction(actionMantidAlgorithms);
  help->addAction(actionmantidplotHelp);
  help->insertSeparator();
  help->addAction(actionHelpBugReports);
  help->insertSeparator();
  help->addAction(actionFirstTimeSetup);
  help->insertSeparator();

  ///The paraview action should only be available on windows
#ifdef _WIN32
  help->addAction(actionSetupParaview);
  help->insertSeparator(); 
#endif

  help->addAction(actionAbout);

  icat = new QMenu(this);
  icat->setObjectName("CatalogMenu");
  icat->addAction(actionICatLogin);//Login menu item
  icat->addAction(actionMydataSearch);// my data search menu item
  icat->addAction(actionICatSearch);//search menu item
  icat->addAction(actionAdvancedSearch); //advanced search menu item
  icat->addAction(actionICatLogout);//logout menu item
  disableActions();
}

void ApplicationWindow::tableMenuAboutToShow()
{
  tableMenu->clear();
  fillMenu->clear();

  MdiSubWindow* t = activeWindow();

  QMenu *setAsMenu = tableMenu->addMenu(tr("Set Columns &As"));
  setAsMenu->addAction(actionSetXCol);
  setAsMenu->addAction(actionSetYCol);
  setAsMenu->addAction(actionSetZCol);
  setAsMenu->insertSeparator();
  setAsMenu->addAction(actionSetLabelCol);
  setAsMenu->addAction(actionDisregardCol);
  setAsMenu->insertSeparator();
  setAsMenu->addAction(actionSetXErrCol);
  setAsMenu->addAction(actionSetYErrCol);
  setAsMenu->insertSeparator();
  setAsMenu->addAction(tr("&Read-only"), this, SLOT(setReadOnlyColumns()));
  setAsMenu->addAction(tr("Read/&Write"), this, SLOT(setReadWriteColumns()));

  tableMenu->addAction(actionShowColumnOptionsDialog);
  tableMenu->insertSeparator();

  tableMenu->addAction(actionShowColumnValuesDialog);
  tableMenu->addAction(actionTableRecalculate);

  fillMenu = tableMenu->addMenu (tr("&Fill Columns With"));
  fillMenu->addAction(actionSetAscValues);
  fillMenu->addAction(actionSetRandomValues);

  tableMenu->addAction(actionClearTable);
  tableMenu->insertSeparator();
  tableMenu->addAction(actionAddColToTable);
  tableMenu->addAction(actionShowColsDialog);
  tableMenu->insertSeparator();
  tableMenu->addAction(actionHideSelectedColumns);
  tableMenu->addAction(actionShowAllColumns);
  tableMenu->insertSeparator();
  tableMenu->addAction(actionMoveColFirst);
  tableMenu->addAction(actionMoveColLeft);
  tableMenu->addAction(actionMoveColRight);
  tableMenu->addAction(actionMoveColLast);
  tableMenu->addAction(actionSwapColumns);
  tableMenu->insertSeparator();
  tableMenu->addAction(actionShowRowsDialog);
  tableMenu->addAction(actionDeleteRows);
  tableMenu->insertSeparator();
  tableMenu->addAction(actionGoToRow);
  tableMenu->addAction(actionGoToColumn);
  tableMenu->insertSeparator();
  tableMenu->addAction(actionConvertTable);
  if (t->isA("Table")) // but not MantidTable
  {
    tableMenu->addAction(actionConvertTableToWorkspace);
  }
  tableMenu->addAction(actionConvertTableToMatrixWorkspace);

  tableMenu->insertSeparator();
  tableMenu->addAction(actionShowPlotWizard);

  reloadCustomActions();
}

void ApplicationWindow::plotDataMenuAboutToShow()
{
  plotDataMenu->clear();
  plotDataMenu->addAction(btnPointer);
  plotDataMenu->addAction(btnZoomIn);
  plotDataMenu->addAction(btnZoomOut);
  plotDataMenu->addAction(actionMagnify);
  plotDataMenu->addAction(actionUnzoom);
  plotDataMenu->insertSeparator();
  plotDataMenu->addAction(btnCursor);
  plotDataMenu->addAction(btnSelect);
  plotDataMenu->addAction(btnPicker);
  plotDataMenu->insertSeparator();
  plotDataMenu->addAction(actionDrawPoints);
  plotDataMenu->addAction(btnMovePoints);
  plotDataMenu->addAction(btnRemovePoints);


  reloadCustomActions();
}

void ApplicationWindow::plotMenuAboutToShow()
{
  plot2DMenu->clear();

  plot2DMenu->addAction(actionPlotL);
  plot2DMenu->addAction(actionPlotP);
  plot2DMenu->addAction(actionPlotLP);

  QMenu *specialPlotMenu = plot2DMenu->addMenu (tr("Special Line/Symb&ol"));
  specialPlotMenu->addAction(actionWaterfallPlot);
  specialPlotMenu->addAction(actionPlotVerticalDropLines);
  specialPlotMenu->addAction(actionPlotSpline);
  specialPlotMenu->addAction(actionPlotVertSteps);
  specialPlotMenu->addAction(actionPlotHorSteps);
  plot2DMenu->insertSeparator();
  plot2DMenu->addAction(actionPlotVerticalBars);
  plot2DMenu->addAction(actionPlotHorizontalBars);
  plot2DMenu->addAction(actionPlotArea);
  plot2DMenu->addAction(actionPlotPie);
  plot2DMenu->addAction(actionPlotVectXYXY);
  plot2DMenu->addAction(actionPlotVectXYAM);
  plot2DMenu->insertSeparator();

  QMenu *statMenu = plot2DMenu->addMenu (tr("Statistical &Graphs"));
  statMenu->addAction(actionBoxPlot);
  statMenu->addAction(actionPlotHistogram);
  statMenu->addAction(actionPlotStackedHistograms);
  statMenu->insertSeparator();
  statMenu->addAction(actionStemPlot);

  QMenu *panelsMenu = plot2DMenu->addMenu (tr("Pa&nel"));
  panelsMenu->addAction(actionPlot2VerticalLayers);
  panelsMenu->addAction(actionPlot2HorizontalLayers);
  panelsMenu->addAction(actionPlot4Layers);
  panelsMenu->addAction(actionPlotStackedLayers);

  QMenu *plot3D = plot2DMenu->addMenu (tr("3&D Plot"));
  plot3D->addAction(actionPlot3DRibbon);
  plot3D->addAction(actionPlot3DBars);
  plot3D->addAction(actionPlot3DScatter);
  plot3D->addAction(actionPlot3DTrajectory);

  reloadCustomActions();
}

void ApplicationWindow::customMenu(MdiSubWindow* w)
{
  myMenuBar()->clear();
  myMenuBar()->insertItem(tr("&File"), fileMenu);
  fileMenuAboutToShow();
  myMenuBar()->insertItem(tr("&Edit"), edit);
  editMenuAboutToShow();
  myMenuBar()->insertItem(tr("&View"), view);

  // these use the same keyboard shortcut (Ctrl+Return) and should not be enabled at the same time
  actionTableRecalculate->setEnabled(false);

  // clear undo stack view (in case window is not a matrix)
  d_undo_view->setStack(0);
  actionUndo->setEnabled(false);
  actionRedo->setEnabled(false);

  if(w){
    actionPrintAllPlots->setEnabled(projectHas2DPlots());
    actionPrint->setEnabled(true);
    actionCutSelection->setEnabled(true);
    actionCopySelection->setEnabled(true);
    actionPasteSelection->setEnabled(true);
    actionClearSelection->setEnabled(true);
    actionSaveTemplate->setEnabled(true);
    QStringList tables = tableNames() + matrixNames();
    if (!tables.isEmpty())
      actionShowExportASCIIDialog->setEnabled(true);
    else
      actionShowExportASCIIDialog->setEnabled(false);

    if (w->isA("MultiLayer")) {
      myMenuBar()->insertItem(tr("&Graph"), graph);
      myMenuBar()->insertItem(tr("&Data"), plotDataMenu);
      plotDataMenuAboutToShow();
      if (m_enableQtiPlotFitting)
      {
        myMenuBar()->insertItem(tr("&Analysis"), analysisMenu);
        analysisMenuAboutToShow();
      }
      myMenuBar()->insertItem(tr("For&mat"), format);

      format->clear();
      format->addAction(actionShowPlotDialog);
      format->insertSeparator();
      format->addAction(actionShowScaleDialog);
      format->addAction(actionShowAxisDialog);
      actionShowAxisDialog->setEnabled(true);
      format->insertSeparator();
      format->addAction(actionShowGridDialog);
      format->addAction(actionShowTitleDialog);
  
    } else if (w->isA("Graph3D")) {
      disableActions();

      myMenuBar()->insertItem(tr("For&mat"), format);

      actionPrint->setEnabled(true);
      actionSaveTemplate->setEnabled(true);

      format->clear();
      format->addAction(actionShowPlotDialog);
      format->addAction(actionShowScaleDialog);
      format->addAction(actionShowAxisDialog);
      format->addAction(actionShowTitleDialog);
      if (dynamic_cast<Graph3D*>(w)->coordStyle() == Qwt3D::NOCOORD)
        actionShowAxisDialog->setEnabled(false);
    } else if (w->inherits("Table")) {
      myMenuBar()->insertItem(tr("&Plot"), plot2DMenu);
      myMenuBar()->insertItem(tr("&Analysis"), analysisMenu);
      analysisMenuAboutToShow();
      myMenuBar()->insertItem(tr("&Table"), tableMenu);
      tableMenuAboutToShow();
      actionTableRecalculate->setEnabled(true);

    } else if (w->isA("Matrix")){
      actionTableRecalculate->setEnabled(true);
      myMenuBar()->insertItem(tr("3D &Plot"), plot3DMenu);
      myMenuBar()->insertItem(tr("&Matrix"), matrixMenu);
      matrixMenuAboutToShow();
      myMenuBar()->insertItem(tr("&Analysis"), analysisMenu);
      analysisMenuAboutToShow();
      d_undo_view->setEmptyLabel(w->objectName() + ": " + tr("Empty Stack"));
      QUndoStack *stack = dynamic_cast<Matrix *>(w)->undoStack();
      d_undo_view->setStack(stack);

    } else if (w->isA("Note")) {
      actionSaveTemplate->setEnabled(false);

    } else if (!mantidUI->menuAboutToShow(w)) // Note that this call has a side-effect (it enables menus)
        disableActions();
   
  } else
    disableActions();

  myMenuBar()->insertItem(tr("&Windows"), windowsMenu);
  windowsMenuAboutToShow();
  // -- Mantid: add script actions, if any exist --
  QListIterator<QMenu*> mIter(d_user_menus);
  while( mIter.hasNext() )
  {
    QMenu* item = mIter.next();
    myMenuBar()->insertItem(tr(item->title()), item);

  }

  myMenuBar()->insertItem(tr("&Catalog"),icat);

  // Interface menu. Build the interface from the user sub windows list.
  // Modifications will be done through the ManageCustomMenus dialog and
  // remembered through QSettings.
  QStringList user_windows = MantidQt::API::InterfaceManager::Instance().getUserSubWindowKeys();
  QStringListIterator itr(user_windows);
  QString menuName = "&Interfaces";
  addUserMenu(menuName);
  while( itr.hasNext() )
  {
      QString itemName = itr.next();
      // Check whether the menu item was flagged in the QSettings.
      if (getMenuSettingsFlag(itemName))
          addUserMenuAction( menuName, itemName, itemName);
  }

  // Go through PyQt interfaces
  QString scriptsDir = QString::fromStdString(Mantid::Kernel::ConfigService::Instance().getString("mantidqt.python_interfaces_directory"));
  QStringListIterator pyqt_itr(pyqt_interfaces);
  while( pyqt_itr.hasNext() )
  {
    QString itemName = pyqt_itr.next();
    QString scriptPath = scriptsDir + '/' + itemName;

    if( QFileInfo(scriptPath).exists() ) {
      QString baseName = QFileInfo(scriptPath).baseName();
      // Need to use "nice" name to check if scripts has been removed by user.
      QString niceName = baseName.replace("_", " ");
      if (getMenuSettingsFlag(niceName))
        addUserMenuAction(menuName, baseName, scriptPath);
    }
    else
    {
      Mantid::Kernel::Logger& g_log = Mantid::Kernel::Logger::get("ConfigService");
      g_log.warning() << "Could not find interface script: " << scriptPath.ascii() << "\n";
    }
  }

  myMenuBar()->insertItem(tr("&Help"), help );

  reloadCustomActions();
}

/**
 * Returns whether a custom interface should be added to the Interfaces menu.
 * @param menu_item: name of the custom interface
 */
bool ApplicationWindow::getMenuSettingsFlag(const QString & menu_item)
{
  // Look for the interface in the user menu list
  // If we found the item in the user menu list, return true
  QMenu *menu = NULL;
  foreach(menu, d_user_menus)
  {
    if( menu->title() == menu_item ) return true;
  }

  // If we didn't find it, check whether is was manually removed
  if( removed_interfaces.contains(menu_item) ) return false;
  return true;
}

void ApplicationWindow::disableActions()
{
  actionSaveTemplate->setEnabled(false);
  actionPrintAllPlots->setEnabled(false);
  actionPrint->setEnabled(false);

  actionCutSelection->setEnabled(false);
  actionCopySelection->setEnabled(false);
  actionPasteSelection->setEnabled(false);
  actionClearSelection->setEnabled(false);
}

void ApplicationWindow::customColumnActions()
{
  actionMoveColFirst->setEnabled(false);
  actionMoveColLeft->setEnabled(false);
  actionMoveColRight->setEnabled(false);
  actionMoveColLast->setEnabled(false);
  actionSetXCol->setEnabled(false);
  actionSetYCol->setEnabled(false);
  actionSetZCol->setEnabled(false);
  actionSetLabelCol->setEnabled(false);
  actionSetYErrCol->setEnabled(false);
  actionDisregardCol->setEnabled(false);
  actionSwapColumns->setEnabled(false);
  actionSetAscValues->setEnabled(false);
  actionSetRandomValues->setEnabled(false);

  Table *t = dynamic_cast<Table*>(activeWindow(TableWindow));
  if (!t)
    return;

  int selectedCols = t->selectedColsNumber();
  if (selectedCols == 1){
    int col = t->selectedColumn();
    if (col > 0){
      actionMoveColFirst->setEnabled(true);
      actionMoveColLeft->setEnabled(true);
    }

    if (col < t->numCols() - 1){
      actionMoveColRight->setEnabled(true);
      actionMoveColLast->setEnabled(true);
    }
  }

  if (selectedCols >= 1){
    actionSetAscValues->setEnabled(true);
    actionSetRandomValues->setEnabled(true);
    actionSetXCol->setEnabled(true);
    actionSetYCol->setEnabled(true);
    actionSetZCol->setEnabled(true);
    actionSetYErrCol->setEnabled(true);
    actionSetLabelCol->setEnabled(true);
    actionDisregardCol->setEnabled(true);
  }

  if (selectedCols == 2)
    actionSwapColumns->setEnabled(true);
}


/** Set the exit code to be returned by the application at
 * exit. Used by MantidPlot unit tests to signal failure.
 *
 * @param code :: int code, non-zero for failure
 */
void ApplicationWindow::setExitCode(int code)
{
  m_exitCode = code;
}

/** Get the exit code to be returned by the application at
 * exit. Used by MantidPlot unit tests to signal failure.
 *
 * @return code :: int code, non-zero for failure
 */
int ApplicationWindow::getExitCode()
{
  return m_exitCode;
}


void ApplicationWindow::customToolBars(MdiSubWindow* w)
{
  disableToolbars();
  if (!w)
    return;

  if (w->isA("MultiLayer") && d_plot_tool_bar){
    if(!plotTools->isVisible())
      plotTools->show();
    plotTools->setEnabled (true);
    customMultilayerToolButtons(dynamic_cast<MultiLayer*>(w));
    if(d_format_tool_bar && !formatToolBar->isVisible()){
      formatToolBar->setEnabled (true);
      formatToolBar->show();
    }
  } else if (w->isA("Graph3D") && d_plot3D_tool_bar){
    if(!plot3DTools->isVisible())
      plot3DTools->show();

    if (dynamic_cast<Graph3D*>(w)->plotStyle() == Qwt3D::NOPLOT)
      plot3DTools->setEnabled(false);
    else
      plot3DTools->setEnabled(true);
    custom3DActions(w);
  }
}

void ApplicationWindow::disableToolbars()
{
  plotTools->setEnabled(false);
  plot3DTools->setEnabled(false);
}

void ApplicationWindow::hideToolbars()
{
  fileTools->setVisible(false);
  displayBar->setVisible(false);
  editTools->setVisible(false);
  plotTools->setVisible(false);
  plot3DTools->setVisible(false);
  formatToolBar->setVisible(false);
}

void ApplicationWindow::showToolbars()
{
  fileTools->setVisible(true);
  displayBar->setVisible(true);
  editTools->setVisible(true);
  plotTools->setVisible(true);
  //plot3DTools->setVisible(true);
  formatToolBar->setVisible(true);
}

void ApplicationWindow::plot3DRibbon()
{
  MdiSubWindow *w = activeWindow(TableWindow);
  if (!w)
    return;

  Table *table = static_cast<Table*>(w);
  if(table->selectedColumns().count() == 1){
    if (!validFor3DPlot(table))
      return;
    plotXYZ(table, table->colName(table->selectedColumn()), Graph3D::Ribbon);
  } else
    QMessageBox::warning(this, tr("MantidPLot - Plot error"), tr("You must select exactly one column for plotting!"));
}

void ApplicationWindow::plot3DWireframe()
{
  plot3DMatrix (0, Qwt3D::WIREFRAME);
}

void ApplicationWindow::plot3DHiddenLine()
{
  plot3DMatrix (0, Qwt3D::HIDDENLINE);
}

void ApplicationWindow::plot3DPolygons()
{
  plot3DMatrix (0, Qwt3D::FILLED);
}

void ApplicationWindow::plot3DWireSurface()
{
  plot3DMatrix (0, Qwt3D::FILLEDMESH);
}

void ApplicationWindow::plot3DBars()
{
  MdiSubWindow *w = activeWindow();
  if (!w)
    return;

  if (w->inherits("Table")){
    Table *table = static_cast<Table *>(w);
    if (!validFor3DPlot(table))
      return;

    if(table->selectedColumns().count() == 1)
      plotXYZ(table, table->colName(table->selectedColumn()), Graph3D::Bars);
    else
      QMessageBox::warning(this, tr("MantidPlot - Plot error"),tr("You must select exactly one column for plotting!"));//Mantid
  }
  else if(w->inherits("Matrix"))
    plot3DMatrix(0, Qwt3D::USER);
}

void ApplicationWindow::plot3DScatter()
{
  MdiSubWindow *w = activeWindow();
  if (!w)
    return;

  if (w->inherits("Table"))
  {
    Table *table = static_cast<Table *>(w);
    if (!validFor3DPlot(table))
      return;

    if(table->selectedColumns().count() == 1)
      plotXYZ(table, table->colName(table->selectedColumn()), Graph3D::Scatter);
    else
      QMessageBox::warning(this, tr("MantidPlot - Plot error"),tr("You must select exactly one column for plotting!"));//Mantid
  }
  else if(w->inherits("Matrix"))
    plot3DMatrix (0, Qwt3D::POINTS);
}

void ApplicationWindow::plot3DTrajectory()
{
  Table *table = dynamic_cast<Table *>(activeWindow(TableWindow));
  if (!table)
    return;
  if (!validFor3DPlot(table))
    return;

  if(table->selectedColumns().count() == 1)
    plotXYZ(table, table->colName(table->selectedColumn()), Graph3D::Trajectory);
  else
    QMessageBox::warning(this, tr("MantidPlot - Plot error"), tr("You must select exactly one column for plotting!"));//Mantid
}

void ApplicationWindow::plotBoxDiagram()
{
  generate2DGraph(Graph::Box);
}

void ApplicationWindow::plotVerticalBars()
{
  generate2DGraph(Graph::VerticalBars);
}

void ApplicationWindow::plotHorizontalBars()
{
  generate2DGraph(Graph::HorizontalBars);
}

MultiLayer* ApplicationWindow::plotHistogram()
{
  return generate2DGraph(Graph::Histogram);
}

MultiLayer* ApplicationWindow::plotHistogram(Matrix *m)
{
  if (!m) {
    m = dynamic_cast<Matrix*>(activeWindow(MatrixWindow));
    if (!m)
      return 0;
  }

  QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

  MultiLayer* g = new MultiLayer(this);
  initMultilayerPlot(g, generateUniqueName(tr("Graph")));

  Graph* plot = g->activeGraph();
  setPreferences(plot);
  plot->addHistogram(m);

  QApplication::restoreOverrideCursor();
  return g;
}

void ApplicationWindow::plotArea()
{
  generate2DGraph(Graph::Area);
}

void ApplicationWindow::plotPie()
{
  Table *table = dynamic_cast<Table *>(activeWindow(TableWindow));
  if (!table)
    return;

  if(table->selectedColumns().count() != 1){
    QMessageBox::warning(this, tr("MantidPlot - Plot error"),//Mantid
        tr("You must select exactly one column for plotting!"));
    return;
  }

  QStringList s = table->selectedColumns();
  if (s.count()>0){
    Q3TableSelection sel = table->getSelection();
    multilayerPlot(table, s, Graph::Pie, sel.topRow(), sel.bottomRow());
  } else
    QMessageBox::warning(this, tr("MantidPlot - Error"), tr("Please select a column to plot!"));//Mantid
}

void ApplicationWindow::plotL()
{
  generate2DGraph(Graph::Line);
}

void ApplicationWindow::plotP()
{
  generate2DGraph(Graph::Scatter);
}

void ApplicationWindow::plotLP()
{
  generate2DGraph(Graph::LineSymbols);
}

void ApplicationWindow::plotVerticalDropLines()
{
  generate2DGraph(Graph::VerticalDropLines);
}

void ApplicationWindow::plotSpline()
{
  generate2DGraph(Graph::Spline);
}

void ApplicationWindow::plotVertSteps()
{
  generate2DGraph(Graph::VerticalSteps);
}

void ApplicationWindow::plotHorSteps()
{
  generate2DGraph(Graph::HorizontalSteps);
}

void ApplicationWindow::plotVectXYXY()
{
  Table *table = dynamic_cast<Table *>(activeWindow(TableWindow));
  if (!table)
    return;
  if (!validFor2DPlot(table))
    return;

  QStringList s = table->selectedColumns();
  if (s.count() == 4) {
    Q3TableSelection sel = table->getSelection();
    multilayerPlot(table, s, Graph::VectXYXY, sel.topRow(), sel.bottomRow());
  } else
    QMessageBox::warning(this, tr("MantidPlot - Error"), tr("Please select four columns for this operation!"));//Mantid
}

void ApplicationWindow::plotVectXYAM()
{
  Table *table = dynamic_cast<Table *>(activeWindow(TableWindow));
  if (!table)
    return;
  if (!validFor2DPlot(table))
    return;

  QStringList s = table->selectedColumns();
  if (s.count() == 4){
    Q3TableSelection sel = table->getSelection();
    multilayerPlot(table, s, Graph::VectXYAM, sel.topRow(), sel.bottomRow());
  } else
    QMessageBox::warning(this, tr("MantidPlot - Error"), tr("Please select four columns for this operation!"));//Mantid
}

QString ApplicationWindow::stemPlot(Table *t, const QString& colName, int power, int startRow, int endRow)
{
  if (!t)
    return QString();

  int col = t->colIndex(colName);
  if (col < 0){
    QMessageBox::critical(this, tr("MantidPlot - Error"),
    tr("Data set: %1 doesn't exist!").arg(colName));
    return QString();
  }

  startRow--;
  endRow--;
  if (startRow < 0 || startRow >= t->numRows())
    startRow = 0;
  if (endRow < 0 || endRow >= t->numRows())
    endRow = t->numRows() - 1;

  QString result = tr("Stem and leaf plot of dataset") + ": " + colName + " ";
  result += tr("from row") + ": " + QString::number(startRow + 1) + " ";
  result += tr("to row") + ": " + QString::number(endRow + 1) + "\n";

  int rows = 0;
  for (int j = startRow; j <= endRow; j++){
    if (!t->text(j, col).isEmpty())
       rows++;
  }

  if (rows >= 1){
    double *data = (double *)malloc(rows * sizeof (double));
    if (!data){
      result += tr("Not enough memory for this dataset!") + "\n";
      return result;
    }

    result += "\n" + tr("Stem") + " | " + tr("Leaf");
    result += "\n---------------------\n";

    int row = 0;
    for (int j = startRow; j <= endRow; j++){
      if (!t->text(j, col).isEmpty()){
        data[row] = t->cell(j, col);
        row++;
      }
    }
    gsl_sort (data, 1, rows);

    if (power > 1e3){
      power = static_cast<int>(std::ceil(log10(data[rows - 1] - data[0]) - log10(rows - 1.0)));
      bool ok;
      int input = QInputDialog::getInteger(this, tr("Please confirm the stem unit!"),
                                      tr("Data set") + ": " + colName + ", " + tr("stem unit") + " = 10<sup>n</sup>, n = ",
                                      power, -1000, 1000, 1, &ok);
      if (ok)
        power = input;
    }

    double stem_unit = pow(10.0, power);
    double leaf_unit = stem_unit/10.0;

    int prev_stem = int(data[0]/stem_unit);
    result += "      " + QString::number(prev_stem) + " | ";

    for (int j = 0; j <rows; j++){
      double val = data[j];
      int stem = int(val/stem_unit);