simplegraphcontroller.cpp

Go to the documentation of this file.

#include <QTableWidget>
#include <QPrinter>
#include <QPrintDialog>
#include <QMenu>
#include <QFileDialog>

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

#include "simplegraphcontroller.h"
#include "qsedataset.h"
#include "qsedataexport.h"
#include "qseaveragerrole.h"
#include "coloredtableitem.h"

SimpleGraphController::SimpleGraphController
(QseDataSet *f, QwtPlot *qp, QTableWidget *scans, QTableWidget *cols, QseAveragerRole* rl, QObject *parent)
  : QObject(parent),
    m_DataSet(f),
    m_CurrentScan(-1),
    m_Plot(qp),
    m_ScansTable(scans),
    m_ColumnsTable(cols),
    m_Role(rl),
    m_Zoomer(NULL),
    m_Panner(NULL),
    m_Legend(NULL),
    m_LegendShown(true)
{
  m_Plot->setCanvasBackground(QColor(Qt::white));

  m_Zoomer = new QwtPlotZoomer(QwtPlot::xBottom, QwtPlot::yLeft, qp->canvas());
  m_Zoomer -> setSelectionFlags(QwtPicker::DragSelection | QwtPicker::CornerToCorner);
  m_Zoomer -> setTrackerMode(QwtPicker::ActiveOnly);
  m_Zoomer -> setRubberBand(QwtPicker::RectRubberBand);

  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);

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

#if QT_VERSION < 0x040000
  
  m_Zoomer -> setMousePattern(QwtEventPattern::MouseSelect2,
            Qt::LeftButton, Qt::ControlButton | Qt::ShiftButton);
#else
  
  m_Zoomer -> setMousePattern(QwtEventPattern::MouseSelect2,
            Qt::LeftButton, Qt::ControlModifier | Qt::ShiftModifier);
#endif
  
  m_Zoomer -> setMousePattern(QwtEventPattern::MouseSelect3,
            Qt::LeftButton, Qt::ControlModifier);

  m_Panner = new QwtPlotPanner(qp->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_Plot -> insertLegend(m_Legend, QwtPlot::BottomLegend);

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

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

  if (m_ColumnsTable) {
    m_ColumnsTable->setContextMenuPolicy(Qt::CustomContextMenu);

    connect(m_ColumnsTable, SIGNAL(customContextMenuRequested(const QPoint &)),
      this, SLOT(columnsTableContextMenu(const QPoint &)));

    connect(m_DataSet, SIGNAL(dataChanged()),
      this,      SLOT(updateColumnsTable()));
  }

  if (m_ScansTable) {
    m_ScansTable->setContextMenuPolicy(Qt::CustomContextMenu);
  
    connect(m_ScansTable, SIGNAL(customContextMenuRequested(const QPoint &)),
      this, SLOT(scansTableContextMenu(const QPoint &)));
  
    connect(m_ScansTable, SIGNAL(itemSelectionChanged()), this, SLOT(updateGraph()));

    connect(m_DataSet, SIGNAL(dataChanged()),
      this,      SLOT(updateScansTable()));
  }

}

SimpleGraphController::~SimpleGraphController()
{
}

QseScan* SimpleGraphController::currentScan()
{
  return m_DataSet->scan(m_CurrentScan);
}

void SimpleGraphController::setCurrentScan(int n)
{
  if (n != m_CurrentScan) {
    m_CurrentScan = n;

    if (m_ColumnsTable) {
      updateColumnsTable();
    }

    updateGraph();
  }
}

void SimpleGraphController::setAutoScale()
{
  m_Plot -> setAxisAutoScale(QwtPlot::xBottom);
  m_Plot -> setAxisAutoScale(QwtPlot::yLeft);
  m_Plot -> replot();
  
  m_Zoomer -> setZoomBase();
}

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

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

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

  m_Plot -> updateLayout();
}

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

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

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

  m_Plot -> updateLayout();
}

void SimpleGraphController::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_Plot -> print(printer, filter);
  }
}

void SimpleGraphController::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_Plot) {
  pc->setPen(p);
  m_Plot->replot();
      }
    }
  }
}

void SimpleGraphController::setDataSet(QseDataSet *ds)
{
  m_DataSet = ds;
}

void SimpleGraphController::updateScansTable()
{
  return;

  Q_ASSERT(m_ScansTable);

  int ns = m_DataSet -> scanCount();

  m_ScansTable -> setUpdatesEnabled(false);

  m_ScansTable -> setRowCount(ns);
  m_ScansTable -> setColumnCount(2);

  m_ScansTable -> setHorizontalHeaderItem(0, new ColoredTableItem(Qt::black, false, "Scan"));
  m_ScansTable -> setHorizontalHeaderItem(1, new ColoredTableItem(Qt::black, false, "#Points"));

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

    if (s) {
      m_ScansTable->setItem(i,0, new ColoredTableItem(Qt::black, false, s->scanCommand()));
      int nr = s->maxRowCount();
      m_ScansTable->setItem(i,1, new ColoredTableItem(Qt::black, false, QString("%1").arg(nr)));
    }
  }

  m_ScansTable -> resizeColumnsToContents();
  m_ScansTable -> resizeRowsToContents();

  m_ScansTable -> setUpdatesEnabled(true);
  m_ScansTable -> repaint();
}

void SimpleGraphController::updateColumnsTable()
{
  return;

  Q_ASSERT(m_ColumnsTable);

  QseScan *s = currentScan();

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

    m_ColumnsTable->setUpdatesEnabled(false);
    m_ColumnsTable->setRowCount(nc);
    m_ColumnsTable->setColumnCount(1);
    m_ColumnsTable->setHorizontalHeaderItem(0, new ColoredTableItem(Qt::black, false, "Column"));

    for (int i = 0; i < nc; i++) {
      QseColumn *col = s->column(i);
      
      if (col) {
  m_ColumnsTable-> setItem(i, 0, m_Role -> styledColumnItem(col));
      }
    }

    m_ColumnsTable -> resizeColumnsToContents();
    m_ColumnsTable -> resizeRowsToContents();
    
    m_ColumnsTable->setUpdatesEnabled(true);
    m_ColumnsTable->repaint();
  }
}

void SimpleGraphController::updateGraph()
{
  m_Plot -> clear();

  if (m_ScansTable) {
    
    int pnnum = 0;

    QList<QTableWidgetSelectionRange> selections = m_ScansTable -> selectedRanges();
    QTableWidgetSelectionRange selection;

    foreach(selection, selections) {
      int r0 = selection.topRow();
      int r1 = selection.bottomRow();
      
      for (int i = r0; i<=r1; i++) {
  QseScan *s = m_DataSet -> scan(i);
  
  if (s) {
    int nc = s->columnCount();
    
    if (nc >= 5) {
      QseColumn *xc = s->column(0);
      int nr = xc->rowCount();
      
      QseColumn *yc = s->column(4);
      QwtPlotCurve *pc = new QwtPlotCurve(s->scanCommand());
      
      pc->setData(xc->data(), yc->data(), nr);
      pc->setPen(m_Pens[pnnum]);
      pnnum = (pnnum + 1) % NPENS;
      pc->setItemAttribute(QwtPlotItem::Legend, m_LegendShown);
      pc->attach(m_Plot);
    }
  }
      }
    }
  } else if (m_ColumnsTable == NULL) {
    QseScan *s = currentScan();
    if (s) {
      int nc = s->columnCount();
    
      if (nc >= 5) {
  QseColumn *xc = s->column(0);
  int nr = xc->rowCount();
      
  QseColumn *yc = s->column(4);
  QwtPlotCurve *pc = new QwtPlotCurve(s->scanCommand());
  
  pc->setData(xc->data(), yc->data(), nr);
  pc->setPen(m_Pens[0]);
  pc->setItemAttribute(QwtPlotItem::Legend, m_LegendShown);
  pc->attach(m_Plot);
      }
    }
  } else if (m_ColumnsTable && m_Role) {
    QseScan *s = currentScan();

    if (s) {
      m_Plot->setTitle(s->scanCommand());

      QseColumn *xc = NULL;
      int nc = s->columnCount();

      for (int i = 0; i < nc; i++) {
  QseColumn *col = s->column(i);
  if (col && m_Role->matchesEnergyColumn(col)) {
    xc = col;
    break;
  }
      }

      if (xc) {
  int nr = xc->rowCount();
  int pnnum = 0;

  for (int i = 0; i < nc; i++) {
    QseColumn *yc = s->column(i);

    if (yc && m_Role->matchesDetectorColumn(yc)) {
      QwtPlotCurve *pc = new QwtPlotCurve(yc->name());
      pc->setData(xc->data(), yc->data(), nr);
      pc->setPen(m_Pens[pnnum]);
      pnnum = (pnnum + 1) % NPENS;
      pc->setItemAttribute(QwtPlotItem::Legend, m_LegendShown);
      pc->attach(m_Plot);
    }
  }
      }
    }
  }

  m_Plot -> replot();

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

  //   setAutoScale();
}

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

void SimpleGraphController::columnsTableContextMenu(const QPoint & pos)
{
  int col = m_ColumnsTable -> columnAt(pos.x());

  if (col == 0) {
    QseScan *s = currentScan();

    if (s) {
      QList<QTableWidgetSelectionRange> selections = m_ColumnsTable -> selectedRanges();
      QTableWidgetSelectionRange selection;
      //  int row = t->rowAt(pos.y()), col = t->columnAt(pos.x());

      QMenu menu(NULL, NULL);
  
      QAction* revertItem = menu.addAction(QString("Revert column(s) to Default Usage"));
      QAction* unusedItem = menu.addAction(QString("Do Not Use column(s)"));
      QAction* detectorItem = menu.addAction(QString("Use column(s) as a signal channel"));
      QAction* normalizationItem = menu.addAction(QString("Use column(s) as a normalization channel"));
      QAction* energyItem = menu.addAction(QString("Use column(s) as Energy (X Value)"));
      QAction* secondsItem = menu.addAction(QString("Use column(s) as counting time"));

      QAction* init = revertItem;
      QseColumn::QseColumnRole newrole = QseColumn::UnspecifiedRole;

      menu.setMouseTracking(TRUE);

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

      if (id == revertItem) {
  newrole = QseColumn::UnspecifiedRole;
      } else if (id == unusedItem) {
  newrole = QseColumn::NotUsedRole;
      } else if (id == detectorItem) {
  newrole = QseColumn::DetectorRole;
      } else if (id == normalizationItem) {
  newrole = QseColumn::NormalizationRole;
      } else if (id == energyItem) {
  newrole = QseColumn::EnergyRole;
      } else if (id == secondsItem) {
  newrole = QseColumn::SecondsRole;
      }
      
      if (id) {
  foreach (selection, selections) {
    int minrow = selection.topRow();
    int maxrow = selection.bottomRow();

    int nchanged = 0;

    for (int row = minrow; row <= maxrow; row++) {
      QseColumn *c = s->column(row);
      if (c) {
        nchanged++;
        c->setColumnRole(newrole);
      }
    }

    if (nchanged) {
      emit columnRangeRolesChanged(m_CurrentScan, m_CurrentScan, minrow, maxrow);
    }
  }
      }
    }
  }
}

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

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

  QAction* saveItem    = menu.addAction(QString("Save selected scans"));
  QAction* removeItem  = menu.addAction(QString("Remove selected scans"));

  menu.setMouseTracking(TRUE);

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

  if (id == saveItem) {
    saveSelectedScans();
  } else if (id == removeItem) {
    removeSelectedScans();
  }
}

void SimpleGraphController::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_ScansTable) {
    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_ScansTable && (id == saveItem)) {
    saveSelectedScans();
  } else if (m_ScansTable && (id == removeItem)) {
    removeSelectedScans();
  }
}

// void SimpleGraphController::writeSelectedScans(const QString &name)
// {
//   QList<QTableWidgetSelectionRange> selections = m_ScansTable -> selectedRanges();
//   QTableWidgetSelectionRange selection;
  
//   foreach (selection, selections) {
//     int r0 = selection.topRow();
//     int r1 = selection.bottomRow();

//     for (int i = r0; i <= r1; i++) {
//       m_DataSet -> writeScan(i, name);
//     }
//   }  
// }

// void SimpleGraphController::saveSelectedScans()
// {
//   QList<QTableWidgetSelectionRange> selections = m_ScansTable -> selectedRanges();
//   QTableWidgetSelectionRange selection;
//   int nselected = 0;

//   foreach (selection, selections) {
//     int r0 = selection.topRow();
//     int r1 = selection.bottomRow();

//     for (int i = r0; i <= r1; i++) {
//       nselected++;
//     }
//   }  

//   if (nselected) {
//     QString filename = QFileDialog::getSaveFileName(m_ScansTable, tr("Save Selected Scans"), ".", "");

//     if (filename != "") {
//       writeSelectedScans(filename);
//     }
//   }
// }

void SimpleGraphController::saveSelectedScans()
{
  QList<QTableWidgetSelectionRange> selections = m_ScansTable -> selectedRanges();
  QTableWidgetSelectionRange selection;
  QList<int> selectedScans;

  foreach (selection, selections) {
    int r0 = selection.topRow();
    int r1 = selection.bottomRow();

    for (int i = r0; i <= r1; i++) {
      selectedScans.append(i);
    }
  }  

  QseDataExport::exportSelectedData("export/data", m_DataSet, selectedScans);
}
  
void SimpleGraphController::removeSelectedScans()
{
  QList<QTableWidgetSelectionRange> selections = m_ScansTable -> selectedRanges();
  QTableWidgetSelectionRange selection;
  int ns = m_DataSet->scanCount();

  QVector<int> toRemove;
  toRemove.resize(ns);

  foreach (selection, selections) {
    int r0 = selection.topRow();
    int r1 = selection.bottomRow();

    for (int i = r0; i <= r1; i++) {
      if (i >= 0 && i < ns) {
  toRemove[i] = 1;
      }
    }
  }

  for (int i = ns-1; i >= 0; i--) {
    if (toRemove[i]) {
      m_ScansTable -> removeRow(i);
      m_DataSet -> removeScan(i);
    }
  }
  
  updateGraph();
}

---