qavrgwindow.cpp

Go to the documentation of this file.

#include "qavrgwindow.h"
#include "qavrgapplication.h"
#include "qavrgacquisition.h"
#include "qavrgfillpattern.h"
#include "qavrghighlighter.h"
#include "qavrgresultsmodel.h"
#include "qavrgsettings.h"
#include "qcepproperty.h"
#include "qavrgfitter.h"
#include "qavrgscriptingengine.h"
#include "qavrgmeasurer.h"
#include "qavrgtestwindow.h"

#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_zoomer.h>
#include <qwt_plot_magnifier.h>
#include <qwt_plot_panner.h>
#include <qwt_plot_picker.h>
#include <qwt_picker_machine.h>
#include <qwt_legend.h>
#include <qwt_symbol.h>
#include <QPen>
#include <QFile>
#include <QCheckBox>
#include <QSignalMapper>
#include <QMessageBox>
#include <QCloseEvent>
#include <QMetaProperty>
#include <QProgressBar>
#include <QTimer>
#include <QFileDialog>
#include <stdio.h>
#include <QThread>

QavrgWindow::QavrgWindow(QavrgApplication *app, QWidget *parent)
  : QMainWindow(parent),
    m_DisplayXUnits(app->saver(), this, "displayXUnits", 0, "X Units in Display"),
    m_DisplayXRange(app->saver(), this, "displayXRange", 0, "X Range Display"),
    m_DisplayOrbit(app->saver(), this, "displayOrbit", 0, "Display Orbit"),
    m_DisplayBunch(app->saver(), this, "displayBunch", 0, "Display Bunch"),
    m_Application(app),
    m_Acquisition(NULL),
    m_ScriptingEngine(NULL),
    m_Progress(NULL),
    m_StatusMessage(NULL),
    m_XUnits(0),
    m_XStep(1.0),
    m_Highlighter(NULL),
    m_AcquireDockWidget(NULL),
    m_InputsDockWidget(NULL),
    m_OutputDockWidget(NULL),
    m_TimingDockWidget(NULL),
    m_ViewDockWidget(NULL)
{
  setupUi(this);

  m_AcquireDockWidget = new QavrgAcquireDialog();
  m_InputsDockWidget = new QavrgInputsDialog();
  m_OutputDockWidget = new QavrgOutputDialog();
  m_TimingDockWidget = new QavrgTimingDialog();
  m_ViewDockWidget = new QavrgViewDialog();

  addDockWidget(Qt::RightDockWidgetArea, m_AcquireDockWidget);
  tabifyDockWidget(m_AcquireDockWidget, m_InputsDockWidget);
  tabifyDockWidget(m_InputsDockWidget, m_OutputDockWidget);

  addDockWidget(Qt::RightDockWidgetArea, m_TimingDockWidget);
  tabifyDockWidget(m_TimingDockWidget, m_ViewDockWidget);

  m_WindowsMenu -> addAction(m_ViewDockWidget -> toggleViewAction());
  m_WindowsMenu -> addAction(m_AcquireDockWidget -> toggleViewAction());
  m_WindowsMenu -> addAction(m_OutputDockWidget -> toggleViewAction());
  m_WindowsMenu -> addAction(m_InputsDockWidget -> toggleViewAction());
  m_WindowsMenu -> addAction(m_TimingDockWidget -> toggleViewAction());
  m_WindowsMenu -> addSeparator();
  m_WindowsMenu -> addAction(m_ToolBar -> toggleViewAction());

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

  m_Zoomer = new QwtPlotZoomer(QwtPlot::xBottom, QwtPlot::yLeft, m_Plot->canvas());
  m_Zoomer -> setStateMachine(new QwtPickerDragRectMachine());
  m_Zoomer -> setTrackerMode(QwtPicker::ActiveOnly);
  m_Zoomer -> setRubberBand(QwtPicker::RectRubberBand);

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

  m_Magnifier = new QwtPlotMagnifier(m_Plot->canvas());
  m_Magnifier -> setMouseButton(Qt::NoButton);

  m_Panner = new QwtPlotPanner(m_Plot->canvas());
  m_Panner -> setMouseButton(Qt::MidButton);

  m_Measurer = new QavrgMeasurer(QwtPlot::xBottom, QwtPlot::yLeft, m_Plot->canvas());
  m_Measurer -> setStateMachine(new QwtPickerPolygonMachine());
  m_Measurer -> setTrackerMode(QwtPicker::AlwaysOn);
  m_Measurer -> setRubberBand(QwtPicker::PolygonRubberBand);

  connect(m_Measurer, SIGNAL(printMessage(QString)), this, SLOT(printMessage(QString)));
  connect(m_Measurer, SIGNAL(printMessage(QString)), this, SLOT(displayStatusMessage(QString)));

  m_Legend = new QwtLegend;
  m_Legend -> setFrameStyle(QFrame::Box|QFrame::Sunken);
  m_Legend -> setDefaultItemMode(QwtLegendData::Checkable);

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

  setZoomingMode();

  connect(m_ActionAutoScale, SIGNAL(triggered()), this, SLOT(autoScale()));
  connect(m_ActionQuit, SIGNAL(triggered()), m_Application, SLOT(possiblyQuit()));
  connect(m_ActionLoadData, SIGNAL(triggered()), this, SLOT(loadData()));
  connect(m_ActionSaveData, SIGNAL(triggered()), this, SLOT(saveData()));

  connect(m_ActionLoadSettings, SIGNAL(triggered()), m_Application, SLOT(loadSettings()));
  connect(m_ActionSaveSettings, SIGNAL(triggered()), m_Application, SLOT(saveSettings()));

  connect(m_ActionEvaluateScript, SIGNAL(triggered()), this, SLOT(doScript()));
  connect(m_EvaluateScript, SIGNAL(clicked()), this, SLOT(doScript()));
  connect(m_CancelScript, SIGNAL(clicked()), this, SLOT(cancelScript()));

  m_CancelScript   -> setEnabled(false);
  m_EvaluateScript -> setEnabled(true);

  m_Highlighter = new QavrgHighlighter(m_InputScript->document());

  m_HelpText -> setReadOnly(true);

  QFile file(":/qavrghelptext.html");

  file.open(QIODevice::ReadOnly);

  QString contents = file.readAll();

  m_HelpText -> setHtml(contents);

  m_StatusMessage = new QLabel(NULL);
  m_StatusMessage -> setMinimumWidth(200);
  m_StatusMessage -> setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);

  statusBar() -> addPermanentWidget(m_StatusMessage);

  m_Progress = new QProgressBar(NULL);
  m_Progress -> setMinimumWidth(150);
  m_Progress -> setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);

  statusBar() -> addPermanentWidget(m_Progress);

  m_Progress -> hide();

  connect(&m_StatusTimer, SIGNAL(timeout()), this, SLOT(clearStatusMessage()));

  connect(m_ZoomButton, SIGNAL(clicked()), this, SLOT(setZoomingMode()));
  connect(m_ZoomOutButton, SIGNAL(clicked()), this, SLOT(zoomOut()));
  connect(m_ZoomAllButton, SIGNAL(clicked()), this, SLOT(zoomAll()));
  connect(m_MeasureButton, SIGNAL(clicked()), this, SLOT(setMeasuringMode()));

  connect(m_OutputDockWidget->m_BrowseOutputDirectory, SIGNAL(clicked()), this, SLOT(browseOutputDirectory()));

  QString winTitle = windowTitle();

  setWindowTitle(winTitle + " v" STR(QAVRG_VERSION));
}

void QavrgWindow::setAcquisition(QavrgAcquisition *acq)
{
  m_Acquisition = acq;

  connect(m_AcquireDockWidget->m_AcquireDataButton,      SIGNAL(clicked()), m_ActionAcquireData, SIGNAL(triggered()));
  connect(m_AcquireDockWidget->m_AcquireReferenceButton, SIGNAL(clicked()), m_ActionAcquireReference, SIGNAL(triggered()));
  connect(m_AcquireDockWidget->m_AcquireDarkButton,      SIGNAL(clicked()), m_ActionAcquireDark, SIGNAL(triggered()));
  connect(m_AcquireDockWidget->m_AcquireOnceButton,      SIGNAL(clicked()), m_ActionAcquireOnce, SIGNAL(triggered()));
  connect(m_AcquireDockWidget->m_AcquireScopeButton,     SIGNAL(clicked()), m_ActionAcquireScope, SIGNAL(triggered()));
  connect(m_AcquireDockWidget->m_AcquireCancelButton,    SIGNAL(clicked()), m_ActionAcquireCancel, SIGNAL(triggered()));

  connect(m_ActionAcquireData,      SIGNAL(triggered()), m_Acquisition, SLOT(acquireData()));
  connect(m_ActionAcquireReference, SIGNAL(triggered()), m_Acquisition, SLOT(acquireReference()));
  connect(m_ActionAcquireDark,      SIGNAL(triggered()), m_Acquisition, SLOT(acquireDark()));
  connect(m_ActionAcquireOnce,      SIGNAL(triggered()), m_Acquisition, SLOT(acquireOnce()));
  connect(m_ActionAcquireScope,     SIGNAL(triggered()), m_Acquisition, SLOT(acquireScope()));
  connect(m_ActionAcquireCancel,    SIGNAL(triggered()), this, SLOT(acquireCancel()));

  connect(m_Acquisition,         SIGNAL(acquisitionStarted()), this, SLOT(onAcquisitionStarted()));
  connect(m_Acquisition,         SIGNAL(acquisitionCancelled()), this, SLOT(onAcquisitionCancelled()));
  connect(m_Acquisition,         SIGNAL(acquisitionProgress(double)), this, SLOT(onAcquisitionProgress(double)));
  connect(m_Acquisition,         SIGNAL(acquisitionCompleted()), this, SLOT(onAcquisitionCompleted()));
  connect(m_AcquireDockWidget->m_SetReferenceButton,     SIGNAL(clicked()), m_Acquisition, SLOT(setReferenceData()));
  connect(m_AcquireDockWidget->m_SetDarkButton,          SIGNAL(clicked()), m_Acquisition, SLOT(setDarkData()));

  m_DisplayXUnits        .linkTo(m_ViewDockWidget->m_DisplayXUnits);
  m_DisplayXRange        .linkTo(m_ViewDockWidget->m_DisplayXRange);
  m_DisplayOrbit         .linkTo(m_ViewDockWidget->m_DisplayOrbit);
  m_DisplayBunch         .linkTo(m_ViewDockWidget->m_DisplayBunch);
//
//  m_DisplayXUnits.setDebug(true);
//  m_DisplayXRange.setDebug(true);
//  m_DisplayOrbit.setDebug(true);
//  m_DisplayBunch.setDebug(true);

  connect(m_ViewDockWidget->m_DisplayXUnits,  SIGNAL(currentIndexChanged(int)), this, SLOT(viewScalingChanged()));
  connect(m_ViewDockWidget->m_DisplayXRange,  SIGNAL(currentIndexChanged(int)), this, SLOT(viewParametersChanged()));
  connect(m_ViewDockWidget->m_DisplayOrbit,   SIGNAL(valueChanged(int)), this, SLOT(viewParametersChanged()));
  connect(m_ViewDockWidget->m_DisplayBunch,   SIGNAL(valueChanged(int)), this, SLOT(viewParametersChanged()));

  connect(m_ViewDockWidget->m_AutoScale,       SIGNAL(clicked()), this, SLOT(autoScale()));

  QGridLayout * grid = new QGridLayout(m_ViewDockWidget->m_GraphChooser);

  grid -> addWidget(new QLabel("Chn"), 0,0, Qt::AlignHCenter);
  grid -> addWidget(new QLabel("Dat"), 0,1+DataSignal, Qt::AlignHCenter);
  grid -> addWidget(new QLabel("Raw"), 0,1+RawSignal, Qt::AlignHCenter);
  grid -> addWidget(new QLabel("Drk"), 0,1+DarkSignal, Qt::AlignHCenter);
  grid -> addWidget(new QLabel("Ref"), 0,1+RefSignal, Qt::AlignHCenter);
  grid -> addWidget(new QLabel("Fit"), 0,1+FitSignal, Qt::AlignHCenter);

  int nchan = m_Acquisition -> get_NChannels();

  if (nchan < 4) nchan = 4;

  QSignalMapper *mapper = new QSignalMapper(this);

  for (int i=0; i<nchan; i++) {
    grid -> addWidget(new QLabel(tr("ch%1").arg(i)), i+1,0, Qt::AlignHCenter);

    QCheckBox *datCkb = new QCheckBox();
    QCheckBox *rawCkb = new QCheckBox();
    QCheckBox *drkCkb = new QCheckBox();
    QCheckBox *refCkb = new QCheckBox();
    QCheckBox *fitCkb = new QCheckBox();

    datCkb -> setToolTip(tr("Display (Dark Subtracted) Data for channel %1").arg(i));
    rawCkb -> setToolTip(tr("Display Raw Data for channel %1").arg(i));
    drkCkb -> setToolTip(tr("Display Dark Data for channel %1").arg(i));
    refCkb -> setToolTip(tr("Display Reference Data for channel %1").arg(i));
    fitCkb -> setToolTip(tr("Display (Dark Subtracted) Fitted Data for channel %1").arg(i));

    grid -> addWidget(datCkb, i+1,1+DataSignal, Qt::AlignHCenter);
    grid -> addWidget(rawCkb, i+1,1+RawSignal, Qt::AlignHCenter);
    grid -> addWidget(drkCkb, i+1,1+DarkSignal, Qt::AlignHCenter);
    grid -> addWidget(refCkb, i+1,1+RefSignal, Qt::AlignHCenter);
    grid -> addWidget(fitCkb, i+1,1+FitSignal, Qt::AlignHCenter);

    connect(datCkb, SIGNAL(clicked()), mapper, SLOT(map()));
    connect(rawCkb, SIGNAL(clicked()), mapper, SLOT(map()));
    connect(drkCkb, SIGNAL(clicked()), mapper, SLOT(map()));
    connect(refCkb, SIGNAL(clicked()), mapper, SLOT(map()));
    connect(fitCkb, SIGNAL(clicked()), mapper, SLOT(map()));

    m_Acquisition -> fitter(i) -> prop_DisplayData() -> linkTo(datCkb);
    m_Acquisition -> fitter(i) -> prop_DisplayRaw()  -> linkTo(rawCkb);
    m_Acquisition -> fitter(i) -> prop_DisplayReference() -> linkTo(refCkb);
    m_Acquisition -> fitter(i) -> prop_DisplayDark() -> linkTo(drkCkb);
    m_Acquisition -> fitter(i) -> prop_DisplayFit() -> linkTo(fitCkb);

    mapper -> setMapping(datCkb, i*5+DataSignal);
    mapper -> setMapping(rawCkb, i*5+RawSignal);
    mapper -> setMapping(drkCkb, i*5+DarkSignal);
    mapper -> setMapping(refCkb, i*5+RefSignal);
    mapper -> setMapping(fitCkb, i*5+FitSignal);

    m_CheckBoxes.append(datCkb);
    m_CheckBoxes.append(rawCkb);
    m_CheckBoxes.append(drkCkb);
    m_CheckBoxes.append(refCkb);
    m_CheckBoxes.append(fitCkb);
  }

  connect(mapper, SIGNAL(mapped(int)), this, SLOT(chooserClicked(int)));

  QGridLayout *timingsGrid = new QGridLayout(m_TimingDockWidget->m_ChannelTimingsPanel);

  timingsGrid -> addWidget(new QLabel("Chan"), 0, 0, Qt::AlignHCenter);
  timingsGrid -> addWidget(new QLabel("Offset"), 0, 1, Qt::AlignHCenter);
  timingsGrid -> addWidget(new QLabel("Start"), 0, 2, Qt::AlignHCenter);
  timingsGrid -> addWidget(new QLabel("End"), 0, 3, Qt::AlignHCenter);

  for (int i=0; i<nchan; i++) {
    timingsGrid -> addWidget(new QLabel(tr("ch%1").arg(i)), i+1,0, Qt::AlignHCenter);
    QDoubleSpinBox *offset = new QDoubleSpinBox();
    QSpinBox *start = new QSpinBox();
    QSpinBox *end = new QSpinBox();

    offset -> setMinimum(-5.0);
    offset -> setMaximum(5.0);
    offset -> setSingleStep(0.01);
    offset -> setDecimals(3);
    offset -> setToolTip(tr("Set (software) fitting offset for channel %1 (in Volts)").arg(i));

    start  -> setMinimum(0);
    start  -> setMaximum(10000);
    start  -> setToolTip(tr("Set start of fitting region (in samples) for channel %1").arg(i));

    end    -> setMinimum(0);
    end    -> setMaximum(10000);
    end    -> setToolTip(tr("Set end of fitting region (in samples) for channel %1").arg(i));

    timingsGrid -> addWidget(offset, i+1, 1, Qt::AlignRight);
    timingsGrid -> addWidget(start,  i+1, 2, Qt::AlignRight);
    timingsGrid -> addWidget(end,    i+1, 3, Qt::AlignRight);

    m_Acquisition -> fitter(i) -> prop_FittingOffset() -> linkTo(offset);
    m_Acquisition -> fitter(i) -> prop_FittingStart()  -> linkTo(start);
    m_Acquisition -> fitter(i) -> prop_FittingEnd()    -> linkTo(end);
  }

  QGridLayout *gainsGrid = new QGridLayout(m_InputsDockWidget->m_InputGainsPanel);

  gainsGrid -> addWidget(new QLabel("Chan"), 0, 0, Qt::AlignHCenter);
  gainsGrid -> addWidget(new QLabel("Gain"), 0, 1, Qt::AlignHCenter);
  gainsGrid -> addWidget(new QLabel("Offset"), 0, 2, Qt::AlignHCenter);

  for (int i=0; i<nchan; i++) {
    gainsGrid -> addWidget(new QLabel(tr("ch%1").arg(i)), i+1,0, Qt::AlignHCenter);
    QComboBox *gain = new QComboBox();
    gain -> setEditable(false);
    gain -> addItem("50 mV", 0.05);
    gain -> addItem("100 mV", 0.1);
    gain -> addItem("200 mV", 0.2);
    gain -> addItem("500 mV", 0.5);
    gain -> addItem("1 V", 1.0);
    gain -> addItem("2 V", 2.0);
    gain -> addItem("5 V", 5.0);
    gain -> setToolTip(tr("Set input gain (full scale) for channel %1").arg(i));

    QDoubleSpinBox *offset = new QDoubleSpinBox();
    offset -> setMinimum(-5);
    offset -> setMaximum(5);
    offset -> setDecimals(3);
    offset -> setSingleStep(0.01);
    offset -> setToolTip(tr("Set input (hardware) offset for channel %1").arg(i));

    gainsGrid -> addWidget(gain, i+1, 1, Qt::AlignRight);
    gainsGrid -> addWidget(offset, i+1, 2, Qt::AlignRight);

    m_Acquisition -> fitter(i) -> prop_InputGain()   -> linkTo(gain);
    m_Acquisition -> fitter(i) -> prop_InputOffset() -> linkTo(offset);
  }

  m_Acquisition -> prop_IntegrationTime()      -> linkTo(m_AcquireDockWidget->m_IntegrationTime);
  m_Acquisition -> prop_ScopeIntegrationTime() -> linkTo(m_AcquireDockWidget->m_ScopeIntegrationTime);
  m_Acquisition -> prop_NRepeats()             -> linkTo(m_AcquireDockWidget->m_NRepeats);
  m_Acquisition -> prop_DarkNRepeats()         -> linkTo(m_AcquireDockWidget->m_DarkNRepeats);
  m_Acquisition -> prop_ReferenceNRepeats()    -> linkTo(m_AcquireDockWidget->m_ReferenceNRepeats);
  m_Acquisition -> prop_BucketsPerOrbit()      -> linkTo(m_TimingDockWidget->m_BucketsPerOrbit);
  m_Acquisition -> prop_SamplesPerOrbit()      -> linkTo(m_TimingDockWidget->m_SamplesPerOrbit);
  m_Acquisition -> prop_FillPatternMode()      -> linkTo(m_TimingDockWidget->m_FillPatternMode);
  m_Acquisition -> prop_TriggerLevel()         -> linkTo(m_InputsDockWidget->m_TriggerLevel);
  m_Acquisition -> prop_TriggerSlope()         -> linkTo(m_InputsDockWidget->m_TriggerSlope);
  m_Acquisition -> prop_TriggerSource()        -> linkTo(m_InputsDockWidget->m_TriggerSource);
  m_Acquisition -> prop_OutputDirectory()      -> linkTo(m_OutputDockWidget->m_OutputDirectory);
  m_Acquisition -> prop_FileName()             -> linkTo(m_OutputDockWidget->m_FileName);
  m_Acquisition -> prop_ScanNumber()           -> linkTo(m_OutputDockWidget->m_ScanNumber);
  m_Acquisition -> prop_NSamples()             -> linkTo(m_TimingDockWidget->m_SamplesToAcquire);
  m_Acquisition -> prop_NChannels()            -> linkTo(m_TimingDockWidget->m_ChannelsToAcquire);
  m_Acquisition -> prop_LaserRepRate()         -> linkTo(m_TimingDockWidget->m_LaserRepRate);
  m_Acquisition -> prop_CustomFilledBucketsPerOrbit() -> linkTo(m_TimingDockWidget->m_NFilledBuckets);

  m_TimingDockWidget->m_SamplesToAcquire -> setMinimum(0);
  m_TimingDockWidget->m_SamplesToAcquire -> setMaximum(m_Acquisition -> def_NSamples());

  m_TimingDockWidget->m_ChannelsToAcquire -> setMaximum(m_Acquisition -> def_NChannels());

  connect(m_Acquisition -> prop_FillPatternMode(),  SIGNAL(valueChanged(int,int)), this, SLOT(fillPatternModeChanged()));
  connect(m_Acquisition -> prop_CustomFilledBucketsPerOrbit(),  SIGNAL(valueChanged(int,int)), this, SLOT(fillPatternModeChanged()));

  connect(m_TimingDockWidget->m_TimingResetDefaults, SIGNAL(clicked()), m_Acquisition, SLOT(timingResetDefaults()));
  connect(m_InputsDockWidget->m_TriggerResetDefaults, SIGNAL(clicked()), m_Acquisition, SLOT(triggerResetDefaults()));

  onAcquisitionCompleted();
  fillPatternModeChanged();
}

void QavrgWindow::setScriptingEngine(QavrgScriptingEngine *engine)
{
  m_ScriptingEngine = engine;
}

void QavrgWindow::fillPatternModeChanged()
{
//  printf("QavrgWindow::fillPatternModeChanged()\n");

  int newMode = m_Acquisition -> get_FillPatternMode();

  if (newMode == 3) {
    m_TimingDockWidget->m_NFilledBuckets -> setEnabled(true);
  } else {
    m_TimingDockWidget->m_NFilledBuckets -> setEnabled(false);
  }

  m_Acquisition -> fillPatternChanged();
}

void QavrgWindow::acquireCancel()
{
  m_Acquisition -> acquireCancel();
}

void QavrgWindow::onAcquisitionStarted()
{
  m_AcquireDockWidget->m_AcquireDataButton -> setEnabled(false);
  m_AcquireDockWidget->m_AcquireReferenceButton -> setEnabled(false);
  m_AcquireDockWidget->m_AcquireDarkButton -> setEnabled(false);
  m_AcquireDockWidget->m_AcquireOnceButton -> setEnabled(false);
  m_AcquireDockWidget->m_AcquireScopeButton -> setEnabled(false);
  m_AcquireDockWidget->m_AcquireCancelButton -> setEnabled(true);

  m_ActionAcquireData -> setEnabled(false);
  m_ActionAcquireReference -> setEnabled(false);
  m_ActionAcquireDark -> setEnabled(false);
  m_ActionAcquireOnce -> setEnabled(false);
  m_ActionAcquireScope -> setEnabled(false);
  m_ActionAcquireCancel -> setEnabled(true);

  displayStatusMessage("Acquisition Started...", m_Acquisition -> get_IntegrationTime()+5);

  m_Progress -> reset();
  m_Progress -> setRange(0,100);
  m_Progress -> show();
}

void QavrgWindow::onAcquisitionCancelled()
{
  displayStatusMessage("Acquisition Cancelled...", m_Acquisition -> get_IntegrationTime()+5);
}

void QavrgWindow::onAcquisitionProgress(double pct)
{
  if (pct < 0) {
    m_Progress -> setRange(0,0);
  } else {
    m_Progress -> setRange(0,100);
    m_Progress -> setValue(pct);
  }

  displayStatusMessage("Acquisition In Progress...", m_Acquisition -> get_IntegrationTime()+5);
}

void QavrgWindow::onAcquisitionCompleted()
{
  m_AcquireDockWidget->m_AcquireDataButton -> setEnabled(true);
  m_AcquireDockWidget->m_AcquireReferenceButton -> setEnabled(true);
  m_AcquireDockWidget->m_AcquireDarkButton -> setEnabled(true);
  m_AcquireDockWidget->m_AcquireOnceButton -> setEnabled(true);
  m_AcquireDockWidget->m_AcquireScopeButton -> setEnabled(true);
  m_AcquireDockWidget->m_AcquireCancelButton -> setEnabled(false);

  m_ActionAcquireData -> setEnabled(true);
  m_ActionAcquireReference -> setEnabled(true);
  m_ActionAcquireDark -> setEnabled(true);
  m_ActionAcquireOnce -> setEnabled(true);
  m_ActionAcquireScope -> setEnabled(true);
  m_ActionAcquireCancel -> setEnabled(false);

  displayStatusMessage("Acquisition Completed...", 5);

  m_Progress -> reset();
  m_Progress -> hide();
}

void QavrgWindow::showDeviceError()
{
//  printf ("QavrgWindow::showDeviceError()\n");
//
  QMessageBox::warning(this, "No Averager Available",
                       "No averager was found.  This is most likely caused either by there being "\
                       "another copy of qavrg running already, or perhaps you are running qavrg "\
                       "on a computer without an averager card.\n"\
                       "The program will continue in simulation mode");
}

void QavrgWindow::displayStatusMessage(QString msg, double time)
{
  m_StatusMessage -> setText(msg);

  m_StatusTimer.start(time*1000.0);
}

void QavrgWindow::clearStatusMessage()
{
  m_StatusMessage -> setText("");
}

void QavrgWindow::closeEvent ( QCloseEvent * event )
{
  if (wantToClose()) {
    event -> accept();
  } else {
    event -> ignore();
  }
}

void QavrgWindow::possiblyClose()
{
//   printf("QxrdWindow::possiblyClose()\n");
  if (wantToClose()) {
    close();
  }
}

bool QavrgWindow::wantToClose()
{
  return QMessageBox::question(this, tr("Really Close?"),
                               tr("Do you really want to close the window?"),
                                  QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok;
}

void QavrgWindow::doScript()
{
  QString script = m_InputScript -> toPlainText();

  m_CancelScript   -> setEnabled(true);
  m_EvaluateScript -> setEnabled(false);

  emit executeCommand(script);
}

void QavrgWindow::cancelScript()
{
  m_ScriptingEngine -> cancelCommand();
}

void QavrgWindow::finishedCommand(QScriptValue result)
{
  if (result.isError()) {
    int line = result.property("lineNumber").toInteger();

    m_OutputResult -> append(tr("Error in line %1").arg(line));
    m_OutputResult -> append(result.property("message").toString());
  } else {
    m_OutputResult -> append(result.toString());
  }

  m_CancelScript   -> setEnabled(false);
  m_EvaluateScript -> setEnabled(true);
}

void QavrgWindow::printMessage(QString msg)
{
  m_OutputResult -> append(msg);
}

void QavrgWindow::warningMessage(QString msg)
{
  m_OutputResult -> append(tr("Error: %1").arg(msg));

  QMessageBox::warning(this, "Error", msg);
}

void QavrgWindow::chooserClicked(int /*n*/)
{
  updateGraph();
}


void QavrgWindow::new_RawData()
{
//  printf("QavrgWindow::new_RawData()\n");
//

  if (m_Acquisition -> decr_NQueuedResults() <= 1) {
    updateGraph();
//  } else {
//    printf("Skipped Update\n");
  }
}

void QavrgWindow::new_DarkData()
{
//  printf("QavrgWindow::new_DarkData()\n");
//

  if (m_Acquisition -> decr_NQueuedResults() <= 1) {
    updateGraph();
//  } else {
//    printf("Skipped Update\n");
  }
}

void QavrgWindow::new_ReferenceData()
{
//  printf("QavrgWindow::new_ReferenceData()\n");
//

  if (m_Acquisition -> decr_NQueuedResults() <= 1) {
    updateGraph();
//  } else {
//    printf("Skipped Update\n");
  }
}

void QavrgWindow::new_FitData()
{
//  printf("QavrgWindow::new_FitData()\n");
//

  if (m_Acquisition -> decr_NQueuedResults() <= 1) {
    updateGraph();
//  } else {
//    printf("Skipped Update\n");
  }
}

void QavrgWindow::viewParametersChanged()
{
//  printf("QavrgWindow::viewParametersChanged()\n");
//
  updateGraph();
}

void QavrgWindow::viewScalingChanged()
{
//  printf("QavrgWindow::viewScalingChanged()\n");
//
  updateGraph();
}

QString QavrgWindow::signalName(QavrgWindow::Signal sig)
{
  switch (sig) {
  case DataSignal:
    return "Data";
  case RawSignal:
    return "Raw";
  case DarkSignal:
    return "Dark";
  case RefSignal:
    return "Ref";
  case FitSignal:
    return "Fit";
  }

  return "Unk";
}

QPen QavrgWindow::curvePen(int ch)
{
  QPen pen1(Qt::red);
  QPen pen2(Qt::green);
  QPen pen3(Qt::blue);
  QPen pen4(Qt::magenta);

  switch (ch & 3) {
  case 0:
    return pen1;
    break;
  case 1:
    return pen2;
    break;
  case 2:
    return pen3;
    break;
  default:
    return pen4;
    break;
  }

  return pen1;
}

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

  QTime tm;
  tm.start();

  int nSamples                   = m_Acquisition -> get_NSamples();
  int nChans                     = m_Acquisition -> get_NChannels();
  double nSamplesPerOrbit        = m_Acquisition -> get_SamplesPerOrbit();

  if (nSamplesPerOrbit <= 0) nSamplesPerOrbit = 3683.5;

  int nOrbits                    = nSamples / nSamplesPerOrbit;
  int nFilledBuckets             = m_Acquisition -> get_FilledBucketsPerOrbit();

  if (nFilledBuckets <= 0) nFilledBuckets = 24;

  double nSamplesPerFilledBucket = nSamplesPerOrbit / nFilledBuckets;

  int viewChoice                 = get_DisplayXRange();
  int xunits                     = get_DisplayXUnits();
  int viewOrbit                  = get_DisplayOrbit();
  int viewBunch                  = get_DisplayBunch();

  m_ViewDockWidget->m_DisplayOrbit -> setMaximum(nOrbits);
  m_ViewDockWidget->m_DisplayBunch -> setMinimum(-4);
  m_ViewDockWidget->m_DisplayBunch -> setMaximum(nFilledBuckets+4);

  switch (viewChoice) {
  case ViewAllData:
    m_ViewDockWidget->m_DisplayOrbit -> setEnabled(false);
    m_ViewDockWidget->m_DisplayBunch -> setEnabled(false);
    break;

  case ViewThreeOrbits:
    m_ViewDockWidget->m_DisplayOrbit -> setEnabled(true);
    m_ViewDockWidget->m_DisplayBunch -> setEnabled(false);
    break;

  case ViewOneOrbit:
    m_ViewDockWidget->m_DisplayOrbit -> setEnabled(true);
    m_ViewDockWidget->m_DisplayBunch -> setEnabled(false);
    break;

  case ViewOneBunch:
    m_ViewDockWidget->m_DisplayOrbit -> setEnabled(true);
    m_ViewDockWidget->m_DisplayBunch -> setEnabled(true);
    break;
  };

  //   printf("Update graph\n");

//  QVector< QVector<double> > data = m_Acquisition->get_RawData();
//  QVector< QVector<double> > ref  = m_Acquisition->get_ReferenceData();
//  QVector< QVector<double> > dark = m_Acquisition->get_DarkData();
//  QVector< QVector<double> > fit  = m_Acquisition->get_FitData();

//  for (int i=0; i<10; i++) {
//    printf("%g  ", data.value(0).value(i));
//  }
//  printf("%g\n", data.value(0).value(10));

  const char *xlabel; double xstep;
  int  nSamplesViewed = 0, firstSampleViewed = 0, useChannelOffsets = false;

  switch (xunits) {
  case NanosecondUnits:
  default:
    xstep = 1.0;
    xlabel = "Time (nsec)";
    break;

  case MicrosecondUnits:
    xstep = 1.0e-3;
    xlabel = "Time (usec)";
    break;

  case MillisecondUnits:
    xstep = 1.0e-6;
    xlabel = "Time (msec)";
    break;

  case OrbitUnits:
    xstep = 1.0/nSamplesPerOrbit;
    xlabel = "Orbit Number";
    break;

  case FilledBunchUnits:
    xstep = 1.0/nSamplesPerFilledBucket;
    xlabel = "Bunch Number";
    break;
  }

  m_Plot -> detachItems(QwtPlotItem::Rtti_PlotCurve);
  m_Plot -> detachItems(QwtPlotItem::Rtti_PlotMarker);
  m_Plot -> setAxisTitle(QwtPlot::xBottom, xlabel);

  switch (viewChoice) {
  case ViewAllData: // View all data
    {
      nSamplesViewed    = nSamples;
      firstSampleViewed = 0;
      useChannelOffsets = false;
    }
    break;

  case ViewThreeOrbits: // View one orbit
    {
      nSamplesViewed    = (int) (nSamplesPerOrbit*3);
      firstSampleViewed = (int) (viewOrbit*nSamplesPerOrbit);
      useChannelOffsets = false;
    }
    break;

  case ViewOneOrbit: // View one orbit
    {
      nSamplesViewed    = (int) (nSamplesPerOrbit);
      firstSampleViewed = (int) (viewOrbit*nSamplesPerOrbit);
      useChannelOffsets = false;
    }
    break;

  case ViewOneBunch: // View one bunch
    {
      nSamplesViewed    = (int) (nSamplesPerFilledBucket);
      firstSampleViewed = (int) (viewOrbit*nSamplesPerOrbit + viewBunch*nSamplesPerFilledBucket);
      useChannelOffsets = true;
    }
    break;
  }

  QVector<double> timeb(nSamplesViewed);
  QVector<double> ydata(nSamplesViewed);

  for (int i=0; i<nSamplesViewed; i++) {
    timeb[i] = i*xstep;
  }

  for (int ch = 0; ch < nChans; ch++) {
    QVector<double> data = m_Acquisition->fitter(ch)->get_RawData();
    QVector<double> ref  = m_Acquisition->fitter(ch)->get_ReferenceData();
    QVector<double> dark = m_Acquisition->fitter(ch)->get_DarkData();
    QVector<double> fit  = m_Acquisition->fitter(ch)->get_FitData();

    for (int sig = DataSignal; sig <= FitSignal; sig++) {
      QCheckBox *cb = m_CheckBoxes.value(ch*5+sig);
      if (cb && cb->isChecked()) {
        QwtPlotCurve *crv = new QwtPlotCurve(tr("Ch%1%2").arg(ch).arg(signalName((Signal) sig)));

        int firstSample = firstSampleViewed;
        int nSamples    = nSamplesViewed;

        if (useChannelOffsets) {
          int start = m_Acquisition -> fitter(ch) -> get_FittingStart();
          int end   = m_Acquisition -> fitter(ch) -> get_FittingEnd();

          firstSample += start;
          nSamples     = end - start;

          if (nSamples < 0) {
            nSamples = 0;
          }

          timeb.resize(nSamples);
          ydata.resize(nSamples);

          for (int i=0; i<nSamples; i++) {
            timeb[i] = (i+start)*xstep;
          }
        }

        QPen pen = curvePen(ch);
        QwtSymbol *symbol = new QwtSymbol();
        QwtPlotCurve::CurveStyle style = QwtPlotCurve::Lines;

        switch (sig) {
        case DataSignal:
          if (m_Acquisition->fitter(ch)->get_DarkAvailable()) {
            for (int i=0; i<nSamples; i++) {
              ydata[i] = data.value(firstSample+i) - dark.value(firstSample+i);
            }
          } else {
            for (int i=0; i<nSamples; i++) {
              ydata[i] = data.value(firstSample+i);
            }
          }
          if (nSamples < 12000) {
            symbol->setStyle(QwtSymbol::Ellipse);
            symbol->setSize(7,7);
            symbol->setPen(pen);
            symbol->setBrush(QBrush(pen.color()));
            style = QwtPlotCurve::NoCurve;
          }
          break;

        case RawSignal:
          for (int i=0; i<nSamples; i++) {
            ydata[i] = data.value(firstSample+i);
          }
          if (nSamples < 12000) {
            symbol->setStyle(QwtSymbol::Ellipse);
            symbol->setSize(5,5);
            symbol->setBrush(QBrush(pen.color()));
            symbol->setPen(pen);
            style = QwtPlotCurve::NoCurve;
          } else {
            pen.setStyle(Qt::DotLine);
          }
          break;

        case DarkSignal:
          for (int i=0; i<nSamples; i++) {
            ydata[i] = dark.value(firstSample+i);
          }
          pen.setStyle(Qt::DashDotDotLine);
          break;

        case RefSignal:
          for (int i=0; i<nSamples; i++) {
            ydata[i] = ref.value(firstSample+i);
          }
          pen.setStyle(Qt::DashLine);
          break;

        case FitSignal:
          for (int i=0; i<nSamples; i++) {
            ydata[i] = fit.value(firstSample+i);
          }
          pen.setStyle(Qt::DashDotLine);
          break;
        }

        crv -> setSamples(timeb.data(), ydata.data(), nSamples);
        crv -> setPen(pen);
        crv -> setSymbol(symbol);
        crv -> setStyle(style);
        crv -> attach(m_Plot);
      }
    }
  }

  if (xunits != m_XUnits) {
    // If the x scaling changes, go and update the coordinates in the zoom stack...
    double ratio = xstep/m_XStep;

    for (int i=0; i<m_Zoomer->zoomStack().count(); i++) {
      QRectF &zr = const_cast<QRectF&>(m_Zoomer->zoomStack()[i]);

      zr.setLeft(zr.left()*ratio);
      zr.setRight(zr.right()*ratio);
    }

    m_XUnits = xunits;
    m_XStep = xstep;

    m_Zoomer->zoom(m_Zoomer -> zoomRectIndex());
  }

  if (m_Zoomer -> zoomRectIndex() == 0) {
    m_Plot -> setAxisAutoScale(QwtPlot::xBottom);
    m_Plot -> setAxisAutoScale(QwtPlot::yLeft);
  }

  m_Plot->replot();

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

  emit printMessage(tr("updateGraph took %1 msec\n").arg(tm.restart()));
}

void QavrgWindow::setZoomingMode()
{
  m_Zoomer    -> setEnabled(true);
  m_Magnifier -> setEnabled(true);
  m_Panner    -> setEnabled(true);
  m_Measurer  -> setEnabled(false);
}

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

void QavrgWindow::zoomAll()
{
  autoScale();
}

void QavrgWindow::setMeasuringMode()
{
  m_Zoomer    -> setEnabled(false);
  m_Magnifier -> setEnabled(true);
  m_Panner    -> setEnabled(true);
  m_Measurer  -> setEnabled(true);
}

void QavrgWindow::autoScale()
{
  m_Plot -> setAxisAutoScale(QwtPlot::xBottom);
  m_Plot -> setAxisAutoScale(QwtPlot::yLeft);
  
  m_Plot->replot();

  m_Zoomer -> setZoomBase();
}

void QavrgWindow::readSettings(QavrgSettings *settings)
{
  QcepProperty::readSettings(this, &QavrgWindow::staticMetaObject, "display", settings);

  QByteArray geometry = settings->value("window/geometry").toByteArray();
  QByteArray winstate = settings->value("window/state").toByteArray();

  restoreGeometry(geometry);
  restoreState(winstate,1);
}

void QavrgWindow::writeSettings(QavrgSettings *settings)
{
  QcepProperty::writeSettings(this, &QavrgWindow::staticMetaObject, "display", settings);

  settings->setValue("window/geometry", saveGeometry());
  settings->setValue("window/state", saveState(1));
}

void QavrgWindow::loadData()
{
  QString loadName = QFileDialog::getOpenFileName(this, tr("Load Acquisitions"));

  if (!loadName.isNull()) {
    m_Acquisition -> loadData(loadName);
  }
}

void QavrgWindow::saveData()
{
  QString saveName = QFileDialog::getSaveFileName(this, tr("Save Acquisitions"));

  if (!saveName.isNull()) {
    m_Acquisition -> saveData(saveName);
  }
}

void QavrgWindow::browseOutputDirectory()
{
  QString directory = m_Acquisition -> get_OutputDirectory();

  QString newDirectory = QFileDialog::getExistingDirectory(this, "Output Directory", directory);

  if (!newDirectory.isNull()) {
    m_Acquisition -> set_OutputDirectory(newDirectory);
  }
}

void QavrgWindow::specialSecretTest(int useProxy, int useTransaction)
{
  if (QThread::currentThread() == thread()) {
    QavrgTestWindow *w = new QavrgTestWindow(useProxy, useTransaction);

    w -> show();
  } else {
    QMetaObject::invokeMethod(this, "specialSecretTest", Q_ARG(int, useProxy), Q_ARG(int, useTransaction));
  }
}