ApplicationWindow.cpp

      int leaf = int(qRound((val - stem*stem_unit)/leaf_unit));
      for (int k = prev_stem + 1; k < stem + 1; k++)
        result += "\n      " + QString::number(k) + " | ";
      result += QString::number(leaf);
      prev_stem = stem;
    }

    result += "\n---------------------\n";
    result += tr("Stem unit") + ": " + locale().toString(stem_unit) + "\n";
    result += tr("Leaf unit") + ": " + locale().toString(leaf_unit) + "\n";

    QString legend = tr("Key") + ": " + QString::number(prev_stem) + " | ";
    int leaf = int(qRound((data[rows - 1] - prev_stem*stem_unit)/leaf_unit));
    legend += QString::number(leaf);
    legend += " " + tr("means") + ": " + locale().toString(prev_stem*stem_unit + leaf*leaf_unit) + "\n";

    result += legend + "---------------------\n";
    free(data);
  } else
    result += "\t" + tr("Input error: empty data set!") + "\n";
  return result;
}

Note * ApplicationWindow::newStemPlot()
{
  Table *t = dynamic_cast<Table *>(activeWindow(TableWindow));
  if (!t)
    return NULL;

  int ts = t->table()->currentSelection();
  if (ts < 0)
    return NULL;

  Note *n = newNote();
  if (!n)
    return NULL;
  n->hide();

  QStringList lst = t->selectedColumns();
  if (lst.isEmpty()){
    Q3TableSelection sel = t->table()->selection(ts);
    for (int i = sel.leftCol(); i <= sel.rightCol(); i++)
      n->setText(n->text() + stemPlot(t, t->colName(i), 1001, sel.topRow() + 1, sel.bottomRow() + 1) + "\n");
  } else {
    for (int i = 0; i < lst.count(); i++)
      n->setText(n->text() + stemPlot(t, lst[i], 1001) + "\n");
  }

  n->show();
  return n;
}

void ApplicationWindow::renameListViewItem(const QString& oldName,const QString& newName)
{
  Q3ListViewItem *it=lv->findItem (oldName,0, Q3ListView::ExactMatch | Qt::CaseSensitive );
  if (it)
    it->setText(0,newName);
}

void ApplicationWindow::setListViewLabel(const QString& caption,const QString& label)
{
  Q3ListViewItem *it=lv->findItem ( caption, 0, Q3ListView::ExactMatch | Qt::CaseSensitive );
  if (it)
    it->setText(5,label);
}

void ApplicationWindow::setListViewDate(const QString& caption,const QString& date)
{
  Q3ListViewItem *it=lv->findItem ( caption, 0, Q3ListView::ExactMatch | Qt::CaseSensitive );
  if (it)
    it->setText(4,date);
}

void ApplicationWindow::setListView(const QString& caption,const QString& view)
{
  Q3ListViewItem *it=lv->findItem ( caption,0, Q3ListView::ExactMatch | Qt::CaseSensitive );
  if (it)
    it->setText(2,view);
}

void ApplicationWindow::setListViewSize(const QString& caption,const QString& size)
{
  Q3ListViewItem *it=lv->findItem ( caption,0, Q3ListView::ExactMatch | Qt::CaseSensitive );
  if (it)
    it->setText(3,size);
}

QString ApplicationWindow::listViewDate(const QString& caption)
{
  Q3ListViewItem *it=lv->findItem (caption,0, Q3ListView::ExactMatch | Qt::CaseSensitive );
  if (it)
    return it->text(4);
  else
    return "";
}

void ApplicationWindow::updateTableNames(const QString& oldName, const QString& newName)
{
  QList<MdiSubWindow *> windows = windowsList();
  foreach (MdiSubWindow *w, windows) {
    if (w->isA("MultiLayer")) {
      QList<Graph *> layers = dynamic_cast<MultiLayer*>(w)->layersList();
      foreach(Graph *g, layers)
      g->updateCurveNames(oldName, newName);
    } else if (w->isA("Graph3D")) {
      QString name = dynamic_cast<Graph3D*>(w)->formula();
      if (name.contains(oldName, true)) {
        name.replace(oldName,newName);
        dynamic_cast<Graph3D*>(w)->setPlotAssociation(name);
      }
    }
  }
}

void ApplicationWindow::updateColNames(const QString& oldName, const QString& newName)
{
  QList<MdiSubWindow *> windows = windowsList();
  foreach (MdiSubWindow *w, windows){
    if (w->isA("MultiLayer")){
      QList<Graph *> layers = dynamic_cast<MultiLayer*>(w)->layersList();
      foreach(Graph *g, layers)
      g->updateCurveNames(oldName, newName, false);
    }
    else if (w->isA("Graph3D")){
      QString name = dynamic_cast<Graph3D*>(w)->formula();
      if (name.contains(oldName)){
        name.replace(oldName,newName);
        dynamic_cast<Graph3D*>(w)->setPlotAssociation(name);
      }
    }
  }
}

void ApplicationWindow::changeMatrixName(const QString& oldName, const QString& newName)
{
  QList<MdiSubWindow *> windows = windowsList();
  foreach(MdiSubWindow *w, windows){
    if (w->isA("Graph3D"))
    {
      QString s = dynamic_cast<Graph3D*>(w)->formula();
      if (s.contains(oldName))
      {
        s.replace(oldName, newName);
        dynamic_cast<Graph3D*>(w)->setPlotAssociation(s);
      }
    }
    else if (w->isA("MultiLayer"))
    {
      QList<Graph *> layers = dynamic_cast<MultiLayer*>(w)->layersList();
      foreach(Graph *g, layers){
        for (int i=0; i<g->curves(); i++){
          QwtPlotItem *sp = dynamic_cast<QwtPlotItem*>(g->plotItem(i));
          if (sp && sp->rtti() == QwtPlotItem::Rtti_PlotSpectrogram && sp->title().text() == oldName)
            sp->setTitle(newName);
        }
      }
    }
  }
}

void ApplicationWindow::remove3DMatrixPlots(Matrix *m)
{
  if (!m)
    return;

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

  QList<MdiSubWindow *> windows = windowsList();
  foreach(MdiSubWindow *w, windows){
    if (w->isA("Graph3D") && dynamic_cast<Graph3D*>(w)->matrix() == m)
      dynamic_cast<Graph3D*>(w)->clearData();
    else if (w->isA("MultiLayer")){
      QList<Graph *> layers = dynamic_cast<MultiLayer*>(w)->layersList();
      foreach(Graph *g, layers){
        for (int i=0; i<g->curves(); i++){
          if (g->curveType(i) == Graph::Histogram){
            QwtHistogram *h = dynamic_cast<QwtHistogram*>(g->plotItem(i));
            if (h && h->matrix() == m)
              g->removeCurve(i);
          } else {
            Spectrogram *sp = dynamic_cast<Spectrogram*>(g->plotItem(i));
            if (sp && sp->rtti() == QwtPlotItem::Rtti_PlotSpectrogram && sp->matrix() == m)
              g->removeCurve(i);
          }
        }
      }
    }
  }
  QApplication::restoreOverrideCursor();
}

void ApplicationWindow::updateMatrixPlots(MdiSubWindow *window)
{
  Matrix *m = dynamic_cast<Matrix *>(window);
  if (!m)
    return;

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

  QList<MdiSubWindow *> windows = windowsList();
  foreach(MdiSubWindow *w, windows){
    if (w->isA("Graph3D") && dynamic_cast<Graph3D*>(w)->matrix() == m)
      dynamic_cast<Graph3D*>(w)->updateMatrixData(m);
    else if (w->isA("MultiLayer")){
      QList<Graph *> layers = dynamic_cast<MultiLayer*>(w)->layersList();
      foreach(Graph *g, layers){
        for (int i=0; i<g->curves(); i++){
          if (g->curveType(i) == Graph::Histogram){
            QwtHistogram *h = dynamic_cast<QwtHistogram*>(g->plotItem(i));
            if (h && h->matrix() == m)
              h->loadData();
          } else {
            Spectrogram *sp = dynamic_cast<Spectrogram*>(g->plotItem(i));
            if (sp && sp->rtti() == QwtPlotItem::Rtti_PlotSpectrogram && sp->matrix() == m)
              sp->updateData(m);
          }
        }
        g->updatePlot();
      }
    }
  }
  QApplication::restoreOverrideCursor();
}

void ApplicationWindow::add3DData()
{
  if (!hasTable()){
    QMessageBox::warning(this,tr("MantidPlot - Warning"),//Mantid
        tr("<h4>There are no tables available in this project.</h4>"
            "<p><h4>Please create a table and try again!</h4>"));
    return;
  }

  QStringList zColumns = columnsList(Table::Z);
  if ((int)zColumns.count() <= 0)
  {
    QMessageBox::critical(this,tr("MantidPlot - Warning"),//Mantid
        tr("There are no available columns with plot designation set to Z!"));
    return;
  }

  DataSetDialog *ad = new DataSetDialog(tr("Column") + " : ", this);
  ad->setAttribute(Qt::WA_DeleteOnClose);
  connect (ad,SIGNAL(options(const QString&)), this, SLOT(insertNew3DData(const QString&)));
  ad->setWindowTitle(tr("MantidPlot - Choose data set"));//Mantid
  ad->setCurveNames(zColumns);
  ad->exec();
}

void ApplicationWindow::change3DData()
{
  DataSetDialog *ad = new DataSetDialog(tr("Column") + " : ", this);
  ad->setAttribute(Qt::WA_DeleteOnClose);
  connect (ad,SIGNAL(options(const QString&)), this, SLOT(change3DData(const QString&)));

  ad->setWindowTitle(tr("MantidPlot - Choose data set"));//Mantid
  ad->setCurveNames(columnsList(Table::Z));
  ad->exec();
}

void ApplicationWindow::change3DMatrix()
{
  DataSetDialog *ad = new DataSetDialog(tr("Matrix") + " : ", this);
  ad->setAttribute(Qt::WA_DeleteOnClose);
  connect (ad, SIGNAL(options(const QString&)), this, SLOT(change3DMatrix(const QString&)));

  ad->setWindowTitle(tr("MantidPlot - Choose matrix to plot"));//Mantid
  ad->setCurveNames(matrixNames());

  Graph3D* g = dynamic_cast<Graph3D*>(activeWindow(Plot3DWindow));
  if (g && g->matrix())
    ad->setCurentDataSet(g->matrix()->objectName());
  ad->exec();
}

void ApplicationWindow::change3DMatrix(const QString& matrix_name)
{
  MdiSubWindow *w = activeWindow(Plot3DWindow);
  if (!w)
    return;

  Graph3D* g = dynamic_cast<Graph3D*>(w);
  Matrix *m = matrix(matrix_name);
  if (m && g)
    g->addMatrixData(m);

  emit modified();
}

void ApplicationWindow::add3DMatrixPlot()
{
  QStringList matrices = matrixNames();
  if (static_cast<int>(matrices.count()) <= 0)
  {
    QMessageBox::warning(this, tr("MantidPlot - Warning"),//Mantid
        tr("<h4>There are no matrices available in this project.</h4>"
            "<p><h4>Please create a matrix and try again!</h4>"));
    return;
  }

  DataSetDialog *ad = new DataSetDialog(tr("Matrix") + " :", this);
  ad->setAttribute(Qt::WA_DeleteOnClose);
  connect (ad,SIGNAL(options(const QString&)), this, SLOT(insert3DMatrixPlot(const QString&)));

  ad->setWindowTitle(tr("MantidPlot - Choose matrix to plot"));//Mantid
  ad->setCurveNames(matrices);
  ad->exec();
}

void ApplicationWindow::insert3DMatrixPlot(const QString& matrix_name)
{
  MdiSubWindow *w = activeWindow(Plot3DWindow);
  if (!w)
    return;

  dynamic_cast<Graph3D*>(w)->addMatrixData(matrix(matrix_name));
  emit modified();
}

void ApplicationWindow::insertNew3DData(const QString& colName)
{
  MdiSubWindow *w = activeWindow(Plot3DWindow);
  if (!w)
    return;

  dynamic_cast<Graph3D*>(w)->insertNewData(table(colName),colName);
  emit modified();
}

void ApplicationWindow::change3DData(const QString& colName)
{
  MdiSubWindow *w = activeWindow(Plot3DWindow);
  if (!w)
    return;

  dynamic_cast<Graph3D*>(w)->changeDataColumn(table(colName), colName);
  emit modified();
}

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

  Graph3D* g = dynamic_cast<Graph3D*>(w);
  SurfaceDialog* sd = new SurfaceDialog(this);
  sd->setAttribute(Qt::WA_DeleteOnClose);

  if (g->hasData() && g->userFunction())
    sd->setFunction(g);
  else if (g->hasData() && g->parametricSurface())
    sd->setParametricSurface(g);
  sd->exec();
}

void ApplicationWindow::newSurfacePlot()
{
  SurfaceDialog* sd = new SurfaceDialog(this);
  sd->setAttribute(Qt::WA_DeleteOnClose);
  sd->exec();
}

Graph3D* ApplicationWindow::plotSurface(const QString& formula, double xl, double xr,
    double yl, double yr, double zl, double zr, int columns, int rows)
{
  QString label = generateUniqueName(tr("Graph"));

  Graph3D *plot = new Graph3D("", this);
  plot->resize(500,400);
  plot->setWindowTitle(label);
  plot->setName(label);
  customPlot3D(plot);
  plot->addFunction(formula, xl, xr, yl, yr, zl, zr, columns, rows);

  initPlot3D(plot);

  emit modified();
  return plot;
}

Graph3D* ApplicationWindow::plotParametricSurface(const QString& xFormula, const QString& yFormula,
    const QString& zFormula, double ul, double ur, double vl, double vr,
    int columns, int rows, bool uPeriodic, bool vPeriodic)
{
  QString label = generateUniqueName(tr("Graph"));

  Graph3D *plot = new Graph3D("", this);
  plot->resize(500, 400);
  plot->setWindowTitle(label);
  plot->setName(label);
  customPlot3D(plot);
  plot->addParametricSurface(xFormula, yFormula, zFormula, ul, ur, vl, vr,
      columns, rows, uPeriodic, vPeriodic);
  initPlot3D(plot);
  emit modified();
  return plot;
}

void ApplicationWindow::updateSurfaceFuncList(const QString& s)
{
  surfaceFunc.remove(s);
  surfaceFunc.push_front(s);
  while ((int)surfaceFunc.size() > 10)
    surfaceFunc.pop_back();
}

Graph3D* ApplicationWindow::dataPlot3D(const QString& caption,const QString& formula,
    double xl, double xr, double yl, double yr, double zl, double zr)
{
  int pos=formula.find("_",0);
  QString wCaption=formula.left(pos);

  Table* w=table(wCaption);
  if (!w)
    return 0;

  int posX=formula.find("(",pos);
  QString xCol=formula.mid(pos+1,posX-pos-1);

  pos=formula.find(",",posX);
  posX=formula.find("(",pos);
  QString yCol=formula.mid(pos+1,posX-pos-1);

  Graph3D *plot = new Graph3D("", this, 0);
  plot->addData(w, xCol, yCol, xl, xr, yl, yr, zl, zr);
  plot->update();

  QString label=caption;
  while(alreadyUsedName(label))
    label = generateUniqueName(tr("Graph"));

  plot->setWindowTitle(label);
  plot->setName(label);
  initPlot3D(plot);

  return plot;
}

Graph3D* ApplicationWindow::newPlot3D()
{
  QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

  QString label = generateUniqueName(tr("Graph"));

  Graph3D *plot = new Graph3D("", this, 0);
  plot->setWindowTitle(label);
  plot->setName(label);

  customPlot3D(plot);
  initPlot3D(plot);

  emit modified();
  QApplication::restoreOverrideCursor();
  return plot;
}

Graph3D* ApplicationWindow::plotXYZ(Table* table, const QString& zColName, int type)
{
  int zCol = table->colIndex(zColName);
  if (zCol < 0)
    return 0;

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

  Graph3D *plot = new Graph3D("", this, 0);
  QString label = generateUniqueName(tr("Graph"));
  plot->setWindowTitle(label);
  plot->setName(label);

  customPlot3D(plot);
  if (type == Graph3D::Ribbon) {
    int ycol = table->colIndex(zColName);
    plot->addData(table, table->colName(table->colX(ycol)), zColName);
  } else
    plot->addData(table, table->colX(zCol), table->colY(zCol), zCol, type);
  initPlot3D(plot);

  emit modified();
  QApplication::restoreOverrideCursor();
  return plot;
}

Graph3D* ApplicationWindow::openPlotXYZ(const QString& caption,const QString& formula,
    double xl, double xr, double yl, double yr, double zl, double zr)
{
  int pos=formula.find("_",0);
  QString wCaption=formula.left(pos);

  Table* w=table(wCaption);
  if (!w)
    return 0;

  int posX=formula.find("(X)",pos);
  QString xColName=formula.mid(pos+1,posX-pos-1);

  pos=formula.find(",",posX);

  posX=formula.find("(Y)",pos);
  QString yColName=formula.mid(pos+1,posX-pos-1);

  pos=formula.find(",",posX);
  posX=formula.find("(Z)",pos);
  QString zColName=formula.mid(pos+1,posX-pos-1);

  int xCol=w->colIndex(xColName);
  int yCol=w->colIndex(yColName);
  int zCol=w->colIndex(zColName);

  Graph3D *plot=new Graph3D("", this, 0);
  plot->loadData(w, xCol, yCol, zCol, xl, xr, yl, yr, zl, zr);

  QString label = caption;
  if (alreadyUsedName(label))
    label = generateUniqueName(tr("Graph"));

  plot->setWindowTitle(label);
  plot->setName(label);
  initPlot3D(plot);
  return plot;
}

void ApplicationWindow::customPlot3D(Graph3D *plot)
{
  plot->setDataColors(QColor(plot3DColors[4]), QColor(plot3DColors[0]));
  plot->setMeshColor(QColor(plot3DColors[2]));
  plot->setAxesColor(QColor(plot3DColors[6]));
  plot->setNumbersColor(QColor(plot3DColors[5]));
  plot->setLabelsColor(QColor(plot3DColors[1]));
  plot->setBackgroundColor(QColor(plot3DColors[7]));
  plot->setGridColor(QColor(plot3DColors[3]));
  plot->setResolution(plot3DResolution);
  plot->showColorLegend(showPlot3DLegend);
  plot->setAntialiasing(smooth3DMesh);
  plot->setOrthogonal(orthogonal3DPlots);
  if (showPlot3DProjection)
    plot->setFloorData();
  plot->setNumbersFont(plot3DNumbersFont);
  plot->setXAxisLabelFont(plot3DAxesFont);
  plot->setYAxisLabelFont(plot3DAxesFont);
  plot->setZAxisLabelFont(plot3DAxesFont);
  plot->setTitleFont(plot3DTitleFont);
}

void ApplicationWindow::initPlot3D(Graph3D *plot)
{
  addMdiSubWindow(plot);
  connectSurfacePlot(plot);

  plot->setIcon(getQPixmap("trajectory_xpm"));
  plot->show();
  plot->setFocus();

  if (!plot3DTools->isVisible())
    plot3DTools->show();

  if (!plot3DTools->isEnabled())
    plot3DTools->setEnabled(true);

  customMenu(plot);
  customToolBars(plot);
}

void ApplicationWindow::exportMatrix()
{
  Matrix* m = dynamic_cast<Matrix*>(activeWindow(MatrixWindow));
  if (!m)
    return;

  ImageExportDialog *ied = new ImageExportDialog(this, m!=NULL, d_extended_export_dialog);
  ied->setDir(workingDir);
  ied->selectFilter(d_image_export_filter);
  if ( ied->exec() != QDialog::Accepted )
    return;
  workingDir = ied->directory().path();
  if (ied->selectedFiles().isEmpty())
    return;

  QString selected_filter = ied->selectedFilter();
  QString file_name = ied->selectedFiles()[0];
  QFileInfo file_info(file_name);
  if (!file_info.fileName().contains("."))
    file_name.append(selected_filter.remove("*"));

  QFile file(file_name);
  if (!file.open( QIODevice::WriteOnly )){
    QMessageBox::critical(this, tr("MantidPlot - Export error"),//Mantid
        tr("Could not write to file: <br><h4> %1 </h4><p>Please verify that you have the right to write to this location!").arg(file_name));
    return;
  }

  if (selected_filter.contains(".eps") || selected_filter.contains(".pdf") || selected_filter.contains(".ps"))
    m->exportVector(file_name, ied->resolution(), ied->color(), ied->keepAspect(), ied->pageSize());
  else {
    QList<QByteArray> list = QImageWriter::supportedImageFormats();
    for (int i=0; i<(int)list.count(); i++){
      if (selected_filter.contains("." + (list[i]).lower()))
        m->image().save(file_name, list[i], ied->quality());
    }
  }
}

Matrix* ApplicationWindow::importImage(const QString& fileName)
{
  QString fn = fileName;
  if (fn.isEmpty()){
    QList<QByteArray> list = QImageReader::supportedImageFormats();
    QString filter = tr("Images") + " (", aux1, aux2;
    for (int i=0; i<(int)list.count(); i++){
      aux1 = " *."+list[i]+" ";
      aux2 += " *."+list[i]+";;";
      filter += aux1;
    }
    filter+=");;" + aux2;

    fn = QFileDialog::getOpenFileName(this, tr("MantidPlot - Import image from file"), imagesDirPath, filter);//Mantid
    if ( !fn.isEmpty() ){
      QFileInfo fi(fn);
      imagesDirPath = fi.dirPath(true);
    }
  }

  QImage image(fn);
  if (image.isNull())
    return 0;

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

  MdiSubWindow *w = activeWindow(MatrixWindow);
  Matrix* m = NULL;
  if (w){
    m = dynamic_cast<Matrix*>(w);
    m->importImage(fn);
  } else {
    m = new Matrix(scriptingEnv(), image, "", this);
    initMatrix(m, generateUniqueName(tr("Matrix")));
    m->show();
    m->setWindowLabel(fn);
    m->setCaptionPolicy(MdiSubWindow::Both);
  }

  QApplication::restoreOverrideCursor();
  return m;
}

void ApplicationWindow::loadImage()
{
  QList<QByteArray> list = QImageReader::supportedImageFormats();
  QString filter = tr("Images") + " (", aux1, aux2;
  for (int i=0; i<(int)list.count(); i++){
    aux1 = " *."+list[i]+" ";
    aux2 += " *."+list[i]+";;";
    filter += aux1;
  }
  filter+=");;" + aux2;

  QString fn = QFileDialog::getOpenFileName(this, tr("MantidPlot - Load image from file"), imagesDirPath, filter);//Mantid
  if ( !fn.isEmpty() ){
    loadImage(fn);
    QFileInfo fi(fn);
    imagesDirPath = fi.dirPath(true);
  }
}

void ApplicationWindow::loadImage(const QString& fn)
{
  QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

  MultiLayer *plot = multilayerPlot(generateUniqueName(tr("Graph")));
  plot->setWindowLabel(fn);
  plot->setCaptionPolicy(MdiSubWindow::Both);

  Graph *g = plot->activeGraph();
  g->setTitle("");
  for (int i=0; i<4; i++)
    g->enableAxis(i, false);
  g->removeLegend();
  g->addImage(fn);
  QApplication::restoreOverrideCursor();
}

void ApplicationWindow::loadScriptRepo(){
   MantidQt::API::ScriptRepositoryView *ad = new MantidQt::API::ScriptRepositoryView(this);
   connect(ad, SIGNAL(loadScript(const QString)),this,SLOT(loadScript(const QString& )));
  ad->setAttribute(Qt::WA_DeleteOnClose);
  ad->show();
  ad->setFocus();
}

void ApplicationWindow::polishGraph(Graph *g, int style)
{
  if (style == Graph::VerticalBars || style == Graph::HorizontalBars ||style == Graph::Histogram)
  {
    QList<int> ticksList;
    int ticksStyle = ScaleDraw::Out;
    ticksList<<ticksStyle<<ticksStyle<<ticksStyle<<ticksStyle;
    g->setMajorTicksType(ticksList);
    g->setMinorTicksType(ticksList);
  }
  if (style == Graph::HorizontalBars){
    g->setAxisTitle(QwtPlot::xBottom, tr("X Axis Title"));
    g->setAxisTitle(QwtPlot::yLeft, tr("Y Axis Title"));
  }
}

MultiLayer* ApplicationWindow::multilayerPlot(const QString& caption, int layers, int rows, int cols)
{
  MultiLayer* ml = new MultiLayer(this, layers, rows, cols);
  QString label = caption;
  initMultilayerPlot(ml, label.replace(QRegExp("_"), "-"));
  return ml;
}

MultiLayer* ApplicationWindow::newGraph(const QString& caption)
{
  MultiLayer *ml = multilayerPlot(generateUniqueName(caption));
  if (ml){
    Graph *g = ml->activeGraph();
    setPreferences(g);
    g->newLegend();
  }
  return ml;
}

MultiLayer* ApplicationWindow::multilayerPlot(Table* w, const QStringList& colList, int style, int startRow, int endRow)
{//used when plotting selected columns
  QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

  MultiLayer* g = multilayerPlot(generateUniqueName(tr("Graph")));
  Graph *ag = g->activeGraph();
  if (!ag)
    return 0;

  setPreferences(ag);
  ag->addCurves(w, colList, style, defaultCurveLineWidth, defaultSymbolSize, startRow, endRow);

  polishGraph(ag, style);
  ag->newLegend();

  ag->setAutoScale();//Mantid
  /* The 'setAutoScale' above is needed to make sure that the plot initially encompasses all the
   * data points. However, this has the side-effect suggested by its name: all the axes become
   * auto-scaling if the data changes. If, in the plot preferences, autoscaling has been disabled
   * the the next line re-fixes the axes
   */
  if ( ! autoscale2DPlots ) ag->enableAutoscaling(false);

  QApplication::restoreOverrideCursor();
  return g;
}

MultiLayer* ApplicationWindow::multilayerPlot(int c, int r, int style)
{//used when plotting from the panel menu
  Table *t = dynamic_cast<Table *>(activeWindow(TableWindow));
  if (!t)
    return 0;

  if (!validFor2DPlot(t))
    return 0;

  QStringList list = t->selectedYColumns();
  if((int)list.count() < 1) {
    QMessageBox::warning(this, tr("MantidPlot - Plot error"), tr("Please select a Y column to plot!"));//Mantid
    return 0;
  }

  int curves = list.count();
  if (r < 0)
    r = curves;

  int layers = c*r;
  MultiLayer* g = multilayerPlot(generateUniqueName(tr("Graph")), layers, r, c);
  QList<Graph *> layersList = g->layersList();
  int i = 0;
  foreach(Graph *ag, layersList){
    setPreferences(ag);
    if (i < curves)
      ag->addCurves(t, QStringList(list[i]), style, defaultCurveLineWidth, defaultSymbolSize);
    ag->newLegend();
    polishGraph(ag, style);
    i++;
  }
  g->arrangeLayers(false, false);
  return g;
}

MultiLayer* ApplicationWindow::multilayerPlot(const QStringList& colList)
{//used when plotting from wizard
  QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
  MultiLayer* g = multilayerPlot(generateUniqueName(tr("Graph")));
  Graph *ag = g->activeGraph();
  setPreferences(ag);
  polishGraph(ag, defaultCurveStyle);
  int curves = (int)colList.count();
  int errorBars = 0;
  for (int i=0; i<curves; i++) {
    if (colList[i].contains("(yErr)") || colList[i].contains("(xErr)"))
      errorBars++;
  }

  for (int i=0; i<curves; i++){
    QString s = colList[i];
    int pos = s.find(":", 0);
    QString caption = s.left(pos) + "_";
    Table *w = dynamic_cast<Table *>(table(caption));

    int posX = s.find("(X)", pos);
    QString xColName = caption+s.mid(pos+2, posX-pos-2);
    int xCol=w->colIndex(xColName);

    posX = s.find(",", posX);
    int posY = s.find("(Y)", posX);
    QString yColName = caption+s.mid(posX+2, posY-posX-2);

    PlotCurve *c = NULL;
    if (s.contains("(yErr)") || s.contains("(xErr)")){
      posY = s.find(",", posY);
      int posErr, errType;
      if (s.contains("(yErr)")){
        errType = QwtErrorPlotCurve::Vertical;
        posErr = s.find("(yErr)", posY);
      } else {
        errType = QwtErrorPlotCurve::Horizontal;
        posErr = s.find("(xErr)",posY);
      }

      QString errColName = caption+s.mid(posY+2, posErr-posY-2);
      c = dynamic_cast<PlotCurve *>(ag->addErrorBars(xColName, yColName, w, errColName, errType));
    } else
      c = dynamic_cast<PlotCurve *>(ag->insertCurve(w, xCol, yColName, defaultCurveStyle));

    CurveLayout cl = ag->initCurveLayout(defaultCurveStyle, curves - errorBars);
    cl.lWidth = float(defaultCurveLineWidth);
    cl.sSize = defaultSymbolSize;
    ag->updateCurveLayout(c, &cl);
  }
  ag->newLegend();
  ag->initScaleLimits();
  QApplication::restoreOverrideCursor();
  return g;
}

void ApplicationWindow::initMultilayerPlot(MultiLayer* g, const QString& name)
{
  QString label = name;
  while(alreadyUsedName(label))
    label = generateUniqueName(tr("Graph"));

  g->setWindowTitle(label);
  g->setName(label);
  g->setIcon(getQPixmap("graph_xpm"));
  g->setScaleLayersOnPrint(d_scale_plots_on_print);
  g->printCropmarks(d_print_cropmarks);

  connectMultilayerPlot(g);

  addMdiSubWindow(g);
}

void ApplicationWindow::customizeTables(const QColor& bgColor,const QColor& textColor,
    const QColor& headerColor,const QFont& textFont, const QFont& headerFont, bool showComments)
{
  tableBkgdColor = bgColor;
  tableTextColor = textColor;
  tableHeaderColor = headerColor;
  tableTextFont = textFont;
  tableHeaderFont = headerFont;
  d_show_table_comments = showComments;

  QList<MdiSubWindow *> windows = windowsList();
  foreach(MdiSubWindow *w, windows){
    if (w->inherits("Table"))
      customTable(dynamic_cast<Table*>(w));
  }
}

void ApplicationWindow::setAutoUpdateTableValues(bool on)
{
  if (d_auto_update_table_values == on)
    return;

  d_auto_update_table_values = on;

  Folder *f = projectFolder();
  while (f){
    QList<MdiSubWindow *> folderWindows = f->windowsList();
    foreach(MdiSubWindow *w, folderWindows){
      if (w->inherits("Table"))
        dynamic_cast<Table*>(w)->setAutoUpdateValues(d_auto_update_table_values);
    }
    f = f->folderBelow();
  }
}

void ApplicationWindow::customTable(Table* w)
{
  QColorGroup cg;
  cg.setColor(QColorGroup::Base, QColor(tableBkgdColor));
  cg.setColor(QColorGroup::Text, QColor(tableTextColor));
  w->setPalette(QPalette(cg, cg, cg));

  w->setHeaderColor(tableHeaderColor);
  w->setTextFont(tableTextFont);
  w->setHeaderFont(tableHeaderFont);
  w->showComments(d_show_table_comments);
  w->setNumericPrecision(d_decimal_digits);
}

void ApplicationWindow::setPreferences(Graph* g)
{
  if (!g)
    return;

  if (!g->isPiePlot())
  {
    for (int i = 0; i < QwtPlot::axisCnt; i++)
    {
      bool show = d_show_axes[i];
      g->enableAxis(i, show);
      if (show)
      {
        ScaleDraw *sd = (ScaleDraw *)g->plotWidget()->axisScaleDraw (i);
        sd->enableComponent(QwtAbstractScaleDraw::Labels, d_show_axes_labels[i]);
        sd->setSpacing(d_graph_tick_labels_dist);
        if (i == QwtPlot::yRight && !d_show_axes_labels[i])
          g->setAxisTitle(i, tr(" "));
      }
    }
    //set the scale type i.e. log or linear
    g->setScale(QwtPlot::yLeft, d_axes_scales[0]);
    g->setScale(QwtPlot::yRight, d_axes_scales[1]);
    g->setScale(QwtPlot::xBottom, d_axes_scales[2]);
    g->setScale(QwtPlot::xTop, d_axes_scales[3]);

    // QtiPlot makes these calls here (as of 26/6/12), but they spoil color fill plots for us.
    //   Losing them seems to have no detrimental effect. Perhaps we need to update our updateSecondaryAxis code to match QtiPlot's.
    //g->updateSecondaryAxis(QwtPlot::xTop);
    //g->updateSecondaryAxis(QwtPlot::yRight);

    QList<int> ticksList;
    ticksList<<majTicksStyle<<majTicksStyle<<majTicksStyle<<majTicksStyle;
    g->setMajorTicksType(ticksList);
    ticksList.clear();
    ticksList<<minTicksStyle<<minTicksStyle<<minTicksStyle<<minTicksStyle;
    g->setMinorTicksType(ticksList);

    g->setTicksLength (minTicksLength, majTicksLength);
    g->setAxesLinewidth(axesLineWidth);
    g->drawAxesBackbones(drawBackbones);
    for (int i = 0; i < QwtPlot::axisCnt; i++)
      g->setAxisTitleDistance(i, d_graph_axes_labels_dist);
    //    need to call the plot functions for log/linear, errorbars and distribution stuff
  }

  g->setSynchronizedScaleDivisions(d_synchronize_graph_scales);
  g->initFonts(plotAxesFont, plotNumbersFont);
  g->initTitle(titleOn, plotTitleFont);
  g->setCanvasFrame(canvasFrameWidth);
  g->plotWidget()->setMargin(defaultPlotMargin);


  g->enableAutoscaling(autoscale2DPlots);
  g->setAutoscaleFonts(autoScaleFonts);
  g->setIgnoreResizeEvents(!autoResizeLayers);
  g->setAntialiasing(antialiasing2DPlots);
  g->enableFixedAspectRatio(fixedAspectRatio2DPlots);

}

/*
 *creates a new empty table
 */
Table* ApplicationWindow::newTable()
{
  Table* w = new Table(scriptingEnv(), 30, 2, "", this, 0);
  initTable(w, generateUniqueName(tr("Table")));
  w->showNormal();
  return w;
}

/*
 *used when opening a project file
 */
Table* ApplicationWindow::newTable(const QString& caption, int r, int c)
{
  Table* w = new Table(scriptingEnv(), r, c, "", this, 0);
  initTable(w, caption);
  if (w->objectName() != caption){//the table was renamed
    renamedTables << caption << w->objectName();
    if (d_inform_rename_table){
      QMessageBox:: warning(this, tr("MantidPlot - Renamed Window"),//Mantid
          tr("The table '%1' already exists. It has been renamed '%2'.").arg(caption).arg(w->objectName()));
    }
  }
  w->showNormal();
  return w;
}

Table* ApplicationWindow::newTable(int r, int c, const QString& name, const QString& legend)
{