mcacontroller.cpp

Go to the documentation of this file.

#include "mcacontroller.h"
#include "epicsarray.h"
#include "epicsdouble.h"
#include "epicsmca.h"
#include "epicsamplifier.h"
#include "epicsa2dconverter.h"
#include "epicspulseanalyser.h"
#include "epicspowersupply.h"
#include "mcaplotcurve.h"
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_zoomer.h>
#include <qwt_plot_panner.h>
#include <qwt_plot_renderer.h>
#include <qwt_picker_machine.h>
#include <qwt_legend.h>
#include <qwt_plot_grid.h>
#include "qmcacontrolpanel.h"
#include "mcamainwindow.h"
#include "mcacontrolpanel.h"
#include "amplifiercontrolpanel.h"
#include "a2dconvertercontrolpanel.h"
#include "pulseanalysercontrolpanel.h"
#include "powersupplycontrolpanel.h"
#include "bm12controlpanel.h"

#include <QPrinter>
#include <QPrintDialog>
#include <QMessageBox>
#include <QPainter>
#include <QApplication>
#include <QTimer>

#include <stdio.h>

static const int NPENS=12;
static QPen m_Pens[NPENS];

MCAController::MCAController(MCAMainWindow* w, QObject* parent)
  : QObject(parent),
    m_MainWindow(w),
    m_MainControlPanel(m_MainWindow->mainControlPanel),
    m_Plot(m_MainWindow->qwtPlot),
    m_Zoomer(NULL),
    m_Panner(NULL),
    m_Legend(NULL),
    m_Grid(NULL),
    m_Adding(NONE),
    m_MCAControlPanel(NULL),// m_MainWindow->mcaPanel),
    m_AmplifierControlPanel(NULL),     // m_MainWindow->ampPanel),
    m_A2DConverterControlPanel(NULL),  // m_MainWindow->a2dPanel),
    m_PulseAnalyserControlPanel(NULL), // m_MainWindow->tcaPanel),
    m_PowerSupplyControlPanel(NULL),   // m_MainWindow->hvpsPanel)
    m_BM12ControlPanel(NULL),
    m_Timer(NULL)
{
  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);

  for (int i = 0; i<NPENS; i++) {
    m_Pens[i].setWidthF(0.75);
  }

  m_Plot->setCanvasBackground(QColor(255,255,250,255));

  m_Zoomer = new QwtPlotZoomer(QwtPlot::xBottom, QwtPlot::yLeft, m_Plot->canvas());
  m_Zoomer -> setStateMachine(new QwtPickerDragRectMachine());
  m_Zoomer -> setTrackerMode(QwtPicker::AlwaysOn);
  m_Zoomer -> setRubberBand(QwtPicker::RectRubberBand);
  m_Zoomer -> setRubberBandPen(m_Pens[2]);

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

  m_Panner = new QwtPlotPanner(m_Plot->canvas());
  m_Panner -> setMouseButton(Qt::MidButton);
  m_Panner -> setEnabled(true);
  
  m_Legend = new QwtLegend();
  m_Legend -> setFrameStyle(QFrame::Box|QFrame::Sunken);
  m_Legend -> setDefaultItemMode(QwtLegendData::Checkable);
 
  m_Plot -> insertLegend(m_Legend, QwtPlot::BottomLegend);

//   m_Grid = new QwtPlotGrid();
//   m_Grid -> setPen(QPen(QColor(220,220,220,255),0,Qt::DotLine));
//   m_Grid -> attach(m_Plot);

  connect(m_MainWindow->actionPrintGraph, SIGNAL(triggered()), this, SLOT(printGraph()));
  connect(m_MainWindow->actionZoomIn, SIGNAL(triggered()), this, SLOT(zoomIn()));
  connect(m_MainWindow->actionZoomOut, SIGNAL(triggered()), this, SLOT(zoomOut()));
  connect(m_MainWindow->actionAutoscaleGraph, SIGNAL(triggered()), this, SLOT(autoscaleGraph()));
  connect(m_MainWindow->actionSaveData, SIGNAL(triggered()), this, SLOT(saveData()));
  connect(m_MainWindow->actionSaveEnergyWindows, SIGNAL(triggered()), this, SLOT(saveEnergyWindows()));
  connect(m_MainWindow->actionLoadEnergyWindows, SIGNAL(triggered()), this, SLOT(loadEnergyWindows()));
  connect(m_MainWindow->actionExit, SIGNAL(triggered()), this, SLOT(wantToQuit()));
}

MCAController::~MCAController()
{
}

void MCAController::addArgument(QString arg)
{
  if (arg == "-mca") {
    m_Adding = MCA;
  } else if (arg == "-amp") {
    m_Adding = AMP;
  } else if (arg == "-adc") {
    m_Adding = ADC;
  } else if (arg == "-tca") {
    m_Adding = TCA;
  } else if (arg == "-hvps") {
    m_Adding = HVPS;
  } else if (arg == "-bm12") {
    m_Adding = BM12;

    if (m_BM12ControlPanel == NULL) {
      m_BM12ControlPanel = m_MainControlPanel -> newBM12ControlPanel(this);
    }
  } else if (m_Adding == MCA) {
    EpicsMCA *newMCA = new EpicsMCA(arg);

    if (m_MCAControlPanel == NULL) {
      m_MCAControlPanel = m_MainControlPanel -> newMCAControlPanel(this);
    }

    m_MCAControlPanel->append(newMCA);

    MCAPlotCurve *pc = new MCAPlotCurve(NULL, arg, this, m_Plot, newMCA);
    pc->setPen(m_Pens[m_MCACurves.size()%NPENS]);

    m_MCACurves.append(pc);

    pc->attach(m_Plot);
  } else if (m_Adding == AMP) {
    EpicsAmplifier *newAmp = new EpicsAmplifier(arg);

    if (m_AmplifierControlPanel == NULL) {
      m_AmplifierControlPanel = m_MainControlPanel -> newAmplifierControlPanel(this);
    }

    m_AmplifierControlPanel->append(newAmp);
  } else if (m_Adding == ADC) {
    EpicsA2DConverter *newADC = new EpicsA2DConverter(arg);

    if (m_A2DConverterControlPanel == NULL) {
      m_A2DConverterControlPanel = m_MainControlPanel -> newA2DConverterControlPanel(this);
    }

    m_A2DConverterControlPanel->append(newADC);
  } else if (m_Adding == TCA) {
    EpicsPulseAnalyser *newTCA = new EpicsPulseAnalyser(arg);

    if (m_PulseAnalyserControlPanel == NULL) {
      m_PulseAnalyserControlPanel = m_MainControlPanel -> newPulseAnalyserControlPanel(this);
    }

    m_PulseAnalyserControlPanel->append(newTCA);
  } else if (m_Adding == HVPS) {
    EpicsPowerSupply *newHVPS = new EpicsPowerSupply(arg);

    if (m_PowerSupplyControlPanel == NULL) {
      m_PowerSupplyControlPanel = m_MainControlPanel -> newPowerSupplyControlPanel(this);
    }

    m_PowerSupplyControlPanel -> append(newHVPS);
  }
}

void MCAController::replot()
{
  m_Plot->replot();

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

QwtPlot* MCAController::graph()
{
  return m_Plot;
}

void MCAController::printGraph()
{
  QPrinter printer(QPrinter::HighResolution);

  printer.setCreator("qmca");
  printer.setOrientation(QPrinter::Landscape);

  QPrintDialog dialog(&printer);

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

//    if ( printer.colorMode() == QPrinter::GrayScale ) {
//      filter.setOptions(QwtPlotPrintFilter::PrintAll &
//                      ~QwtPlotPrintFilter::PrintBackground);
//    }

    QRect geo = m_Plot -> geometry();
    QPainter p(&printer);

//    m_Plot -> print(&p, geo, filter);
    filter.renderTo(m_Plot, printer);
  }
}

void MCAController::wantToQuit()
{
  if (QMessageBox::question(NULL, tr("Really Quit?"),
                            tr("Do you really want to exit the application?"),
                            QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok) {
    qApp -> quit();
  }
}

void MCAController::zoomIn()
{
  m_Zoomer -> zoom(+1);

  m_Plot -> replot();
}

void MCAController::zoomOut()
{
  m_Zoomer -> zoom(-1);

  m_Plot -> replot();
}

void MCAController::autoscaleGraph()
{
  m_Plot -> setAxisAutoScale(QwtPlot::xBottom);
  m_Plot -> setAxisAutoScale(QwtPlot::yLeft);

  m_Plot -> replot();

  m_Zoomer -> setZoomBase();
}

void MCAController::saveData()
{
  if (m_BM12ControlPanel) {
    m_BM12ControlPanel -> saveData();
  }
}

void MCAController::saveEnergyWindows()
{
  if (m_BM12ControlPanel) {
    m_BM12ControlPanel -> saveEnergyWindows();
  }
}

void MCAController::loadEnergyWindows()
{
  if (m_BM12ControlPanel) {
    m_BM12ControlPanel -> loadEnergyWindows();
  }
}

void MCAController::save_a()
{
//   printf("MCAController::save_a()\n");

  save_curves(m_MCACurvesA, ".A", Qt::DashLine);
}

void MCAController::save_b()
{
//   printf("MCAController::save_b()\n");

  save_curves(m_MCACurvesB, ".B", Qt::DotLine);
}

void MCAController::save_c()
{
//   printf("MCAController::save_c()\n");

  save_curves(m_MCACurvesC, ".C", Qt::DashDotLine);
}

void MCAController::clear_a()
{
//   printf("MCAController::clear_a()\n");

  clear_curves(m_MCACurvesA);
}

void MCAController::clear_b()
{
//   printf("MCAController::clear_b()\n");

  clear_curves(m_MCACurvesB);
}

void MCAController::clear_c()
{
//   printf("MCAController::clear_c()\n");

  clear_curves(m_MCACurvesC);
}

void MCAController::save_curves(QList<QwtPlotCurve*> &crvs, QString suffix, Qt::PenStyle style)
{
  QwtPlotCurve *pc;

  foreach(pc, crvs) {
//     printf("Detach %s\n", qPrintable(pc->title().text()));

    pc -> detach();
    delete pc;
  }

  crvs.clear();

  foreach(pc, m_MCACurves) {
    QwtPlotCurve *pc1 = new QwtPlotCurve(pc->title().text()+suffix);
    QwtSeriesData<QPointF> *data = pc->data();

    QVector<double> x(data->size()), y(data->size());

    for (int i=0; i<data->size(); i++) {
      x[i] = data->sample(i).x();
      y[i] = data->sample(i).y();
    }

    QPen pen = pc->pen();

    pen.setStyle(style);

//     printf("pen style %d\n", (int) pen.style());

    pc1 -> setSamples(x,y);
    pc1 -> setPen(pen);
    pc1 -> attach(m_Plot);

    crvs.append(pc1);
  }
}

void MCAController::clear_curves(QList<QwtPlotCurve*> &crvs)
{
  QwtPlotCurve *pc;

  foreach(pc, crvs) {
//     printf("Detach %s\n", qPrintable(pc->title().text()));

    pc -> detach();
    delete pc;
  }

  crvs.clear();
}