qsegraphcontroller.cpp

Go to the documentation of this file.

#include "qsegraphcontroller.h"

#include <QListWidget>
#include <QTableWidget>
#include <QPrinter>
#include <QPrintDialog>
#include <QMenu>
#include <QMap>
#include <QThread>

#include <qwt_plot.h>
#include <qwt_plot_zoomer.h>
#include <qwt_plot_panner.h>
#include <qwt_plot_magnifier.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_layout.h>
#include <qwt_legend.h>

#include "qsedataset.h"
#include "qsedataexport.h"
#include "qsedatareference.h"
#include "qsegraphscansmodel.h"
#include "qsegraphcolumnsmodel.h"

QseGraphController::QseGraphController(QseDataSet *f, QWidget *parent)
  : QWidget(parent),
    m_DataSet(f),
    m_ScansModel(NULL),
    m_ScansSelection(NULL),
    m_ColumnsModel(NULL),
    m_ColumnsSelection(NULL),
    m_Zoomer(NULL),
    m_Zoomer2(NULL),
    m_Panner(NULL),
    m_Magnifier(NULL),
    m_Legend(NULL),
    m_LegendShown(true),
    m_ScanPenStep(1),
    m_ScanSymbolStep(0),
    m_CurvePenStep(0),
    m_CurveSymbolStep(1)
{
  m_Pens[0].setColor(Qt::black);
  m_Pens[1].setColor(Qt::red);
  m_Pens[2].setColor(Qt::green);
  m_Pens[3].setColor(Qt::blue);
  m_Pens[4].setColor(Qt::cyan);
  m_Pens[5].setColor(Qt::magenta);
  m_Pens[6].setColor(Qt::darkYellow);
  m_Pens[7].setColor(Qt::darkRed);
  m_Pens[8].setColor(Qt::darkGreen);
  m_Pens[9].setColor(Qt::darkBlue);
  m_Pens[10].setColor(Qt::darkCyan);
  m_Pens[11].setColor(Qt::darkMagenta);

  m_Symbols[0] = QwtSymbol(QwtSymbol::Ellipse, QBrush(), m_Pens[0], QSize(3,3));
  m_Symbols[1] = QwtSymbol(QwtSymbol::Ellipse, QBrush(), m_Pens[1], QSize(5,5));
  m_Symbols[2] = QwtSymbol(QwtSymbol::Rect, QBrush(), m_Pens[2], QSize(5,5));
  m_Symbols[3] = QwtSymbol(QwtSymbol::Diamond, QBrush(), m_Pens[3], QSize(5,5));
  m_Symbols[4] = QwtSymbol(QwtSymbol::Triangle, QBrush(), m_Pens[4], QSize(5,5));
  m_Symbols[5] = QwtSymbol(QwtSymbol::DTriangle, QBrush(), m_Pens[5], QSize(5,5));
  m_Symbols[6] = QwtSymbol(QwtSymbol::UTriangle, QBrush(), m_Pens[6], QSize(5,5));
  m_Symbols[7] = QwtSymbol(QwtSymbol::LTriangle, QBrush(), m_Pens[7], QSize(5,5));
  m_Symbols[8] = QwtSymbol(QwtSymbol::RTriangle, QBrush(), m_Pens[8], QSize(5,5));
  m_Symbols[9] = QwtSymbol(QwtSymbol::Cross, QBrush(), m_Pens[9], QSize(5,5));
  m_Symbols[10] = QwtSymbol(QwtSymbol::XCross, QBrush(), m_Pens[10], QSize(5,5));
  m_Symbols[11] = QwtSymbol(QwtSymbol::Star1, QBrush(), m_Pens[11], QSize(5,5));

  setupUi(this);

  m_Graph->setCanvasBackground(QColor(Qt::white));

  m_Zoomer = new QwtPlotZoomer(QwtPlot::xBottom, QwtPlot::yLeft, m_Graph->canvas());
  m_Zoomer -> setSelectionFlags(QwtPicker::DragSelection | QwtPicker::CornerToCorner);

  m_Zoomer2 = new QwtPlotZoomer(QwtPlot::xTop, QwtPlot::yRight, m_Graph->canvas());
  m_Zoomer2 -> setSelectionFlags(QwtPicker::DragSelection | QwtPicker::CornerToCorner);

  m_Magnifier = new QwtPlotMagnifier(m_Graph->canvas());
  m_Magnifier -> setMouseFactor(1.0);

  enableAxes(true, false);

  // RightButton: zoom out by 1
  // Ctrl+RightButton: zoom out to full size

  m_Zoomer -> setMousePattern(QwtEventPattern::MouseSelect2,
            Qt::LeftButton, Qt::ControlModifier | Qt::ShiftModifier);
  m_Zoomer2 -> setMousePattern(QwtEventPattern::MouseSelect2,
            Qt::LeftButton, Qt::ControlModifier | Qt::ShiftModifier);
  
  m_Zoomer -> setMousePattern(QwtEventPattern::MouseSelect3,
            Qt::LeftButton, Qt::ControlModifier);
  m_Zoomer2 -> setMousePattern(QwtEventPattern::MouseSelect3,
            Qt::LeftButton, Qt::ControlModifier);

  m_Panner = new QwtPlotPanner(m_Graph->canvas());
  m_Panner -> setMouseButton(Qt::MidButton);
  m_Panner -> setEnabled(true);

  m_Legend = new QwtLegend;
  m_Legend -> setFrameStyle(QFrame::Box|QFrame::Sunken);
  m_Legend -> setItemMode(QwtLegend::CheckableItem);

  m_Graph -> insertLegend(m_Legend, QwtPlot::BottomLegend);

  connect(m_Graph, SIGNAL(legendChecked(QwtPlotItem*,bool)), 
    this, SLOT(legendChecked(QwtPlotItem*,bool)));

  m_Graph -> canvas() -> setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_Graph -> canvas(), SIGNAL(customContextMenuRequested(const QPoint &)),
    this, SLOT(graphContextMenu(const QPoint&)));

  m_ScansView -> setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_ScansView, SIGNAL(customContextMenuRequested(const QPoint &)),
      this, SLOT(scansListContextMenu(const QPoint &)));

  m_ColumnsView -> setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_ColumnsView, SIGNAL(customContextMenuRequested(const QPoint &)),
      this, SLOT(columnsTableContextMenu(const QPoint &)));

  m_ScansModel = new QseGraphScansModel(m_DataSet, m_ScansView, this);
  m_ColumnsModel = new QseGraphColumnsModel(this, m_ColumnsView, this);

  m_ScansView -> setModel(m_ScansModel);
  m_ColumnsView -> setModel(m_ColumnsModel);

  m_ScansSelection = m_ScansView->selectionModel();
  m_ColumnsSelection = m_ColumnsView->selectionModel();

  connect(m_DataSet, SIGNAL(dataCleared()),   this, SLOT(dataCleared()));
  connect(m_DataSet, SIGNAL(dataChanged()),   this, SLOT(dataChanged()));
  connect(m_DataSet, SIGNAL(operationCompleted()), this, SLOT(operationCompleted()));
//   connect(m_DataSet, SIGNAL(scanAdded(int)),  this, SLOT(scanAdded(int)));

  connect(m_ColumnsView, SIGNAL(clicked(const QModelIndex&)),
    this, SLOT(columnsCellClicked(const QModelIndex&)));

  connect(m_ScansSelection, 
    SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)),
    this,
    SLOT(scansSelectionChanged(const QItemSelection&, const QItemSelection&)));

  connect(m_PrintButton, SIGNAL(clicked()), this, SLOT(printGraph()));
  connect(m_ZoomAllButton, SIGNAL(clicked()), this, SLOT(zoomGraphAll()));
  connect(m_ZoomInButton, SIGNAL(clicked()), this, SLOT(zoomGraphIn()));
  connect(m_ZoomOutButton, SIGNAL(clicked()), this, SLOT(zoomGraphOut()));
}

QseGraphController::~QseGraphController()
{
}

QseDataSet* QseGraphController::dataSet() const
{
  return m_DataSet;
}

int QseGraphController::selectedColumnCount() const
{
  return m_SelectedScanColumns.count();
}

QString QseGraphController::selectedColumn(int i) const
{
  return m_SelectedScanColumns[i];
}

void QseGraphController::setTitle(const QString &title)
{
  m_Graph -> setTitle(title);
}

void QseGraphController::addContextMenuAction(QAction *action)
{
  m_Actions.append(action);
}

void QseGraphController::scanAdded(int s)
{
//   printf("QseGraphController::scanAdded(%d)\n",s);
// //   printf("Threads : this %p, curr %p\n", thread(), QThread::currentThread());

//   int nsc = m_DataSet -> scanCount();
//   int selmm = scanSelected(nsc-3);
//   int selm  = scanSelected(nsc-2);
    
//   for (int i=-4; i<1; i++) {
//     printf("scan(%d,%d,%d):%d\n", i,nsc+i,nsc, scanSelected(nsc+i));
//   }

//   if (selm) {
//     QItemSelectionModel *m = m_ScansView -> selectionModel();

//     if (selmm) {
//       printf("select %d\n", nsc-1);
//       m -> select(m_ScansModel->indexOfScan(nsc-1),
//      QItemSelectionModel::Current | 
//      QItemSelectionModel::Rows |
//      QItemSelectionModel::Select); 
//     } else {
//       printf("deselect %d\n", nsc-2);
//       printf("select %d\n", nsc-1);      
//       QItemSelection ss(m_ScansModel->indexOfScan(nsc-2), m_ScansModel->indexOfScan(nsc-1));
//       m -> select(ss,
//      QItemSelectionModel::Current | 
//      QItemSelectionModel::Rows |
//      QItemSelectionModel::Toggle);
//     }
//   }
    
//   QApplication::processEvents();

//   for (int i=-4; i<1; i++) {
//     printf("scan(%d,%d,%d):%d\n", i,nsc+i,nsc, scanSelected(nsc+i));
//   }

//   m_ColumnsModel -> columnsChanged();
//   m_ColumnsView->resizeRowsToContents();
//   m_ColumnsView->resizeColumnsToContents();

//   updateGraph();
}

void QseGraphController::operationCompleted()
{
//   printf("QseGraphController::operationCompleted\n");

  m_ScansView->resizeRowsToContents();
  m_ScansView->resizeColumnsToContents();

  updateGraph();
}

void QseGraphController::dataCleared()
{
//   printf("QseGraphController::dataCleared\n");

//   m_SelectedScans.clear();
  m_SelectedScanColumns.clear();
  m_SelectedScanColumnCounts.clear();

  m_ColumnsModel -> columnsChanged();
//   m_ScansView->clear();
}

void QseGraphController::dataChanged()
{
//   printf("QseGraphController::dataChanged\n");

//   int nscans = m_DataSet -> scanCount();
//   int nlines = m_ScansView -> count();

//   if (nscans > nlines) {
//     for (int i = nlines; i<nscans; i++) {
//       m_ScansView->addItem(m_DataSet->scan(i)->name());
//     }
//   } else if (nscans < nlines) {
//     printf("QseGraphController::dataChanged removed scans:%d lines%d\n", nscans, nlines);
//   }

//   updateGraph();
}

// void QseGraphController::deselectScan(int i)
// {
//   if (m_SelectedScans.contains(i)) {
//     m_SelectedScans.removeAll(i);

//     QList<int> slct = m_SelectedScans;
//     int scan;
   
//     m_SelectedScans.clear();
//     m_SelectedScanColumns.clear();
//     m_SelectedScanColumnCounts.clear();

//     foreach(scan, slct) {
//       selectScan(scan);
//     }
//   }
// }

// void QseGraphController::selectScan(int i)
// {
//   if (!m_SelectedScans.contains(i)) {
//     m_SelectedScans.append(i);

//     QseScan* s = m_DataSet -> scan(i);

//     if (s) {
//       int nc = s->columnCount();

//       for (int i=0; i<nc; i++) {
//  QseColumn* col = s->column(i);
//  if (col) {
//    QString colname = col->name();
//    if (!m_SelectedScanColumnCounts.contains(colname)) {
//      m_SelectedScanColumns.append(colname);
//    }
//    m_SelectedScanColumnCounts[colname] += 1;
//  }
//       }
//     }
//   }
// }

bool QseGraphController::scanSelected(int i)
{
  return m_ScansSelection -> isRowSelected(i, QModelIndex());
//   return m_SelectedScans.contains(i);
}

bool QseGraphController::selectedPlotX(int i) const
{
  QString colname = selectedColumn(i);

  return m_PlotXColumns.contains(colname);
}

bool QseGraphController::selectedPlotY(int i) const
{
  QString colname = selectedColumn(i);

  return m_PlotYColumns.contains(colname);
}

bool QseGraphController::selectedPlotY2(int i) const
{
  QString colname = selectedColumn(i);

  return m_PlotY2Columns.contains(colname);
}

bool QseGraphController::selectedPlotNorm(int i) const
{
  QString colname = selectedColumn(i);

  return m_PlotNormColumns.contains(colname);
}

void QseGraphController::scansSelectionChanged
(const QItemSelection & selected, const QItemSelection & deselected)
{
//   printf("QseGraphController::scansSelectionChanged()\n");

  m_SelectedScanColumns.clear();
  m_SelectedScanColumnCounts.clear();

  int n = scanCount();

  for (int i = 0; i<n; i++) {
    if (scanSelected(i)) {
      QseScan* s = m_DataSet -> scan(i);

      if (s) {
  int nc = s->columnCount();

  for (int i=0; i<nc; i++) {
    QseColumn* col = s->column(i);
    if (col) {
      QString colname = col->name();
      if (!m_SelectedScanColumnCounts.contains(colname)) {
        m_SelectedScanColumns.append(colname);
      }
      m_SelectedScanColumnCounts[colname] += 1;
    }
  }
      }
    }
  }

  m_ColumnsModel -> columnsChanged();
  m_ColumnsView->resizeRowsToContents();
  m_ColumnsView->resizeColumnsToContents();

  updateGraph();
}

void QseGraphController::toggleGraphSelection
(int n, QSet<QString>& set)
{
  QString colname = selectedColumn(n);

  if (set.contains(colname)) {
    set.remove(colname);
  } else {
    set.insert(colname);
  }
}

void QseGraphController::columnsSelectionChanged
(const QItemSelection & selected, const QItemSelection & deselected)
{
//   printf("QseGraphController::columnsSelectionChanged()\n");

  QItemSelectionRange r;
  
  foreach(r, selected) {
    int tp=r.top(), bt=r.bottom();
    int lf=r.left(), rt=r.right();
    for (int i=tp; i<=bt; i++) {
      for (int j=lf; j<=rt; j++) {
  printf("QseGraphController::columnsSelectionChanged::selected(%d,%d)\n",i,j);
//  switch(j) {
//  case 1:
//    m_PlotXColumns.clear();
//    toggleGraphSelection(i, m_PlotXColumns);
//    break;
//  case 2:
//    toggleGraphSelection(i, m_PlotYColumns);
//    break;
//  case 3:
//    toggleGraphSelection(i, m_PlotY2Columns);
//    break;
//  case 4:
//    toggleGraphSelection(i, m_PlotNormColumns);
//    break;
//  }
      }
    }

    m_ColumnsModel -> emitDataChanged(r.topLeft(), r.bottomRight());
  }

  foreach(r, deselected) {
    int tp=r.top(), bt=r.bottom();
    int lf=r.left(), rt=r.right();
    for (int i=tp; i<=bt; i++) {
      for (int j=lf; j<=rt; j++) {
  printf("QseGraphController::columnsSelectionChanged::deselected(%d,%d)\n",i,j);
      }
    }

    m_ColumnsModel -> emitDataChanged(r.topLeft(), r.bottomRight());
  }
//   m_ColumnsModel -> columnsChanged();

  updateGraph();
}

void QseGraphController::columnsCellClicked(const QModelIndex& index)
{
//   printf("QseGraphController::columnsCellClicked(%d,%d)\n", index.column(), index.row());

  int i = index.row(), j = index.column();

  switch (j) {
  case 1:
    m_PlotXColumns.clear();
    toggleGraphSelection(i, m_PlotXColumns);
    m_ColumnsModel -> emitDataChanged(m_ColumnsModel->index(0,1), 
              m_ColumnsModel->index(m_ColumnsModel->rowCount(),1));
    break;
  case 2:
    toggleGraphSelection(i, m_PlotYColumns);
    break;
  case 3:
    toggleGraphSelection(i, m_PlotY2Columns);
    break;
  case 4:
    toggleGraphSelection(i, m_PlotNormColumns);
    break;
  }

  m_ColumnsModel -> emitDataChanged(index, index);

  updateGraph();
}

void QseGraphController::updateGraph()
{
//   printf("QseGraphController::updateGraph()\n");

  m_Graph -> clear();

  int s;
  int nscans = 0;
  int nscanstotal = m_DataSet -> scanCount();

  for (s=0; s<nscanstotal; s++) {
    if (scanSelected(s)) {
      nscans++;
    }
  }

  int pnnum = 0;
  int smnum = -1;

  int ncurves = 0;
  int npscans = 0;
  int ncrvscn = 0;

  QSet<QString> xnames, ynames, y2names;

  if (nscans > 1) {
    m_Graph -> setTitle(QString("%1 Scans").arg(nscans));
  }

  int hasy1 = false;
  int hasy2 = false;

  for (s=0; s<nscanstotal; s++) {
    if (scanSelected(s)) {
//     printf("Scan %d\n", s);

      ncrvscn = 0;

      if (m_ScanPenStep) {
  pnnum = (pnnum + m_ScanPenStep + NPENS) % NPENS;
      } else {
  pnnum = 0;
      }

      if (m_ScanSymbolStep) {
  smnum = (smnum + m_ScanSymbolStep + NSYMBOLS) % NSYMBOLS;
      } else {
  smnum = 0;
      }

      QseScan *scan = m_DataSet -> scan(s);

      if (scan) {
  if (nscans == 1) {
    m_Graph->setTitle(scan->scanCommand());
  }
  int nc = scan->columnCount();
  QseColumn *xc = NULL;
  int nxc = -1;
  
  for (int c = 0; c<nc; c++) {
    QseColumn *col = scan->column(c);
    if (col) {
      QString colname = col->name();
      
      if (m_PlotXColumns.contains(colname)) {
        xc = col;
        nxc = c;
        break;
      }
    }
  }
 
  if (nc && (xc == NULL)) {
    xc = scan->column(0);
    nxc = 0;
  }
  
  if (xc) {
    //    int nr = xc->rowCount();
    int nnc = 0;
    
    for (int c = 0; c<nc; c++) {
      QseColumn *yc = scan->column(c);
      if (yc) {
        QString colname = yc->name();
        
        if (m_PlotYColumns.contains(colname)) {
    QString name;
    nnc += 1;
    ncurves += 1;
    
    if (nnc == 1) {
      xnames.insert(xc->name());
    }
    ynames.insert(colname);
    
    if (ncurves <= MAX_CURVES) {
      if (ncrvscn == 0) {
        npscans += 1;
      }
      ncrvscn += 1;
      
      if (nscans == 1) {
        name = colname;
      } else {
        name = QString("S%1:%2").arg(scan->scanNumber()).arg(colname);
      }
        
      QwtPlotCurve *pc = new QwtPlotCurve(name);
      //    pc->setData(xc->data(), yc->data(), nr);
      pc->setData(QseDataReference(m_DataSet, s, nxc, c));
      pc->setPen(m_Pens[pnnum]);
      QwtSymbol ps = m_Symbols[smnum];
      ps.setPen(m_Pens[pnnum]);
      ps.setBrush(QBrush(m_Pens[pnnum].color()));
      pc->setSymbol(ps);
      pnnum = (pnnum + m_CurvePenStep + NPENS) % NPENS;
      smnum = (smnum + m_CurveSymbolStep + NSYMBOLS) % NSYMBOLS;
      pc->setItemAttribute(QwtPlotItem::Legend, m_LegendShown);
      pc->attach(m_Graph);
      hasy1 = true;
    }
        }
      }
    }
      
    for (int c = 0; c<nc; c++) {
      QseColumn *yc = scan->column(c);
      if (yc) {
        QString colname = yc->name();
        
        if (m_PlotY2Columns.contains(colname)) {
    QString name;
    nnc += 1;
    ncurves += 1;
    
    if (nnc == 1) {
      xnames.insert(xc->name());
    }
    y2names.insert(colname);
    
    if (ncurves <= MAX_CURVES) {
      if (ncrvscn == 0) {
        npscans += 1;
      }
      ncrvscn += 1;
      
      if (nscans == 1) {
        name = colname;
      } else {
        name = QString("S%1:%2").arg(scan->scanNumber()).arg(colname);
      }
      
      QwtPlotCurve *pc = new QwtPlotCurve(name);
      //    pc->setData(xc->data(), yc->data(), nr);
      pc->setData(QseDataReference(m_DataSet, s, nxc, c));
      pc->setYAxis(QwtPlot::yRight);
      pc->setPen(m_Pens[pnnum]);
      QwtSymbol ps = m_Symbols[smnum];
      ps.setPen(m_Pens[pnnum]);
      ps.setBrush(QBrush(m_Pens[pnnum].color()));
      pc->setSymbol(ps);
      pnnum = (pnnum + m_CurvePenStep + NPENS) % NPENS;
      smnum = (smnum + m_CurveSymbolStep + NSYMBOLS) % NSYMBOLS;
      pc->setItemAttribute(QwtPlotItem::Legend, m_LegendShown);
      pc->attach(m_Graph);
      hasy2 = true;
    }
        }
      }
    }
  }
      }
    }
  }

  if (ncurves > MAX_CURVES) {
    m_Graph -> setTitle(QString("%1 of %2 curves from %3 scans").
      arg(MAX_CURVES).arg(ncurves).arg(npscans));
  } else if (npscans > 1) {
    m_Graph -> setTitle(QString("%1 curves from %2 scans").arg(ncurves).arg(npscans));
  }

  setAxisTitle(QwtPlot::xBottom, xnames);
  setAxisTitle(QwtPlot::yLeft,   ynames);
  setAxisTitle(QwtPlot::yRight,  y2names);

  enableAxes(hasy1, hasy2);

  m_Graph -> replot();

  if (m_Zoomer -> zoomRectIndex() == 0) {
    m_Zoomer -> setZoomBase();
  }

  if (m_Zoomer2 -> zoomRectIndex() == 0) {
    m_Zoomer2 -> setZoomBase();
  }

//   printf("finished\n");
}

void QseGraphController::setAxisTitle(int axisId, const QSet<QString>& names)
{
  QString title, name;
  int n = names.count();
  int nt;

  if (n == 0) {
    m_Graph -> setAxisTitle(axisId, "");
  } else {
    if (n > 4) {
      nt = 4;
    } else {
      nt = n;
    }

    QSet<QString>::const_iterator it = names.constBegin();
    title = *it;

    for (int i = 1; i<nt; i++) {
      it++;
      title += ", " + *it;
    }

    if (n > nt) {
      title += "...";
    }

    m_Graph -> setAxisTitle(axisId, title);
  }
}

void QseGraphController::enableAxes(bool y1, bool y2)
{
  m_Graph -> enableAxis(QwtPlot::yLeft, y1 | !y2);
  m_Graph -> enableAxis(QwtPlot::yRight, y2);

  if (y1 | !y2) {
    m_Zoomer -> setTrackerMode(QwtPicker::AlwaysOn);
    m_Zoomer -> setRubberBand(QwtPicker::RectRubberBand);
    m_Zoomer2 -> setTrackerMode(QwtPicker::AlwaysOff);
    m_Zoomer2 -> setRubberBand(QwtPicker::NoRubberBand);
  } else {
    m_Zoomer2 -> setTrackerMode(QwtPicker::AlwaysOn);
    m_Zoomer2 -> setRubberBand(QwtPicker::RectRubberBand);
    m_Zoomer -> setTrackerMode(QwtPicker::AlwaysOff);
    m_Zoomer -> setRubberBand(QwtPicker::NoRubberBand);
  }
}

void QseGraphController::setAutoScale()
{
  m_Graph -> setAxisAutoScale(QwtPlot::xBottom);
  m_Graph -> setAxisAutoScale(QwtPlot::yLeft);
  m_Graph -> setAxisAutoScale(QwtPlot::yRight);
  m_Graph -> replot();
  
  m_Zoomer -> setZoomBase();
  m_Zoomer2 -> setZoomBase();
}

void QseGraphController::showLegend()
{
  m_LegendShown = true;

  QwtPlotItem *item;
  const QwtPlotItemList &items = m_Graph->itemList();

  foreach (item, items) {
    item->setItemAttribute(QwtPlotItem::Legend, true);
  }

  m_Graph -> updateLayout();
}

void QseGraphController::hideLegend()
{
  m_LegendShown = false;

  QwtPlotItem *item;
  const QwtPlotItemList &items = m_Graph->itemList();

  foreach (item, items) {
    item->setItemAttribute(QwtPlotItem::Legend, false);
  }

  m_Graph -> updateLayout();
}

void QseGraphController::printGraph()
{
  QPrinter printer;

  printer.setCreator("Spec EXAFS Processor");
  //   printer.setOrientation(QPrinter::Landscape);

  QPrintDialog dialog(&printer);

  if (dialog.exec()) {
    QwtPlotPrintFilter filter;

//     if ( printer.colorMode() == QPrinter::GrayScale ) {
//       filter.setOptions(QwtPlotPrintFilter::PrintAll & ~QwtPlotPrintFilter::PrintCanvasBackground);
//     }
    
    m_Graph -> print(printer, filter);
  }
}

void QseGraphController::legendChecked(QwtPlotItem *it, bool checked)
{
  if (it) {
    QwtPlotCurve *pc = dynamic_cast<QwtPlotCurve*>(it);

    if (pc) {
      QPen p = pc->pen();
      if (checked) {
  p.setWidth(3);
      } else {
  p.setWidth(0);
      }

      if (m_Graph) {
  pc->setPen(p);
  m_Graph->replot();
      }
    }
  }
}

void QseGraphController::columnsTableContextMenu(const QPoint & pos)
{
  QMenu menu(NULL, NULL);

  QAction* selectCells = menu.addAction(QString("Select..."));
  QAction* deselectCells = menu.addAction(QString("Deselect..."));

  menu.setMouseTracking(TRUE);

  QAction* id = menu.exec(QCursor::pos() + QPoint( -40, -10), selectCells);

}

void QseGraphController::scansListContextMenu(const QPoint & pos)
{
  QMenu menu(NULL, NULL);

  QAction* selectCells = menu.addAction(QString("Select..."));
  QAction* deselectCells = menu.addAction(QString("Deselect..."));

  menu.setMouseTracking(TRUE);

  QAction* id = menu.exec(QCursor::pos() + QPoint( -40, -10), selectCells);
}

void QseGraphController::graphContextMenu(const QPoint &pos)
{
  QMenu menu(NULL, NULL);
  QAction *action;

  foreach (action, m_Actions) {
    menu.addAction(action);
  }

  QAction* autoscaleItem = menu.addAction(QString("Autoscale Graph"));
  QAction* printItem   = menu.addAction(QString("Print Graph..."));
  
  QAction* showLegendItem = NULL;
  QAction* hideLegendItem = NULL;

  if (m_LegendShown) {
    hideLegendItem = menu.addAction(QString("Hide Legend"));
  } else {
    showLegendItem = menu.addAction(QString("Display Legend"));
  }

  QAction* saveItem = NULL;
  QAction* removeItem = NULL;

  if (m_ScansView) {
    saveItem    = menu.addAction(QString("Save selected scans"));
    removeItem  = menu.addAction(QString("Remove selected scans"));
  }

  menu.setMouseTracking(TRUE);

  QAction* id = menu.exec(QCursor::pos() + QPoint( -40, -10), saveItem);

  if (id == autoscaleItem) {
    setAutoScale();
  } else if (id == printItem) {
    printGraph();
  } else if (id == showLegendItem) {
    showLegend();
  } else if (id == hideLegendItem) {
    hideLegend();
  } else if (m_ScansView && (id == saveItem)) {
    saveSelectedScans();
  } else if (m_ScansView && (id == removeItem)) {
    removeSelectedScans();
  }
}

int QseGraphController::scanCount()
{
  return m_DataSet -> scanCount();
}

QList<int> QseGraphController::selectedScans()
{
  QList<int> res;
  int nscans = scanCount();

  for (int i=0; i<nscans; i++) {
    if (scanSelected(i)) {
      res.append(i);
    }
  }

  return res;
}

void QseGraphController::saveSelectedScans()
{
  QseDataExport::exportSelectedData("export/data", m_DataSet, selectedScans());
}

void QseGraphController::removeSelectedScans()
{
}

void QseGraphController::zoomGraphAll()
{
  setAutoScale();
}

void QseGraphController::zoomGraphOut()
{
  m_Zoomer -> zoom(-1);
  m_Zoomer2 -> zoom(-1);
}

void QseGraphController::zoomGraphIn()
{
  m_Zoomer -> zoom(1);
  m_Zoomer2 -> zoom(1);
}

---