QseController Class Reference

#include <qsecontroller.h>

Inheritance diagram for QseController:

Inheritance graph
[legend]
Collaboration diagram for QseController:

Collaboration graph
[legend]

List of all members.

Public Slots

void message (const QString &message)
void setProgress (int level)
void newScanStarted ()
void nextScan (void)
void previousScan (void)
void setCurrentScan (int n)
void updateGraphs (void)
void openCompleted (void)
void runNormalizer (void)
void averageSelectedScans ()
void previousValidScan ()
void nextValidScan ()
void updateSelectedScan (int scan)
void updateScanRole (int scan)
void updateRangeScanRoles (int scan0, int scan1)
void updateColumnRole (int scan, int col)
void updateRangeColumnRoles (int scan0, int scan1, int col0, int col1)
void updateDefaultRoles ()
void openDataFile ()
void appendDataFile ()
void openControlFile ()
void saveSplitDataFile ()
void saveNormalizedFile ()
void saveAveragedFile ()
void saveControlFile ()
void exitApplication ()
void readDataFile (const QString &name)
void appendDataFile (const QString &name)
void readControlFile (const QString &name)
void writeControlFile (const QString &name)

Signals

void currentScanChanged (int)
void defaultRolesChanged (void)
void scanRoleChanged (int)
void normalizedScansChanged ()
void averagedScansChanged ()
int openFile (QString fileName)
void writeScans (const QString &fileName)

Public Member Functions

 QseController (QseProcessorMain *w, QObject *parent=0)
 ~QseController ()
int isValidScan (int i)
void readSettings (QSettings *settings)
void writeSettings (QSettings *settings)

Protected Attributes

QPen m_Pens [NPENS]
QProgressBar * m_Progress

Static Protected Attributes

static const int NPENS = 12

Private Slots

void onDataCleared ()
void onScanAdded (int n)
void onLoadCompleted ()
void openQSEHomePage ()

Private Member Functions

void setupActions ()
QseScan * scan (int n)
QseScan * currentScan ()

Private Attributes

QseDataFlow * m_DataFlow
QseProcessorMain * m_MainWindow
int m_CurrentScan
QseGraphController * m_InputDataUI
QseDataDeglitcherUI * m_DeglitcherUI
QseNormalizerUI * m_NormalizerUI
QseEdgeAlignerUI * m_EdgeAlignerUI
QseScanAveragerUI * m_ScanAveragerUI
QseGraphController * m_NormalizedController
QseGraphController * m_AveragedController
SummaryTableController * m_SummaryTableController
SimpleGraphController * m_MainController
SimpleGraphController * m_TotalController

Detailed Description

Definition at line 26 of file qsecontroller.h.

Constructor & Destructor Documentation

QseController::QseController ( QseProcessorMain *  w,
QObject *  parent = 0 
)

Definition at line 43 of file qsecontroller.cpp.

00044   : QObject(parent),
00045     m_DataFlow(0),
00046     m_MainWindow(w),
00047     m_CurrentScan(0),
00048     m_InputDataUI(NULL),
00049     m_DeglitcherUI(NULL),
00050     m_NormalizerUI(NULL),
00051     m_EdgeAlignerUI(NULL),
00052     m_ScanAveragerUI(NULL),
00053     m_NormalizedController(NULL),
00054     m_AveragedController(NULL),
00055 
00056     m_SummaryTableController(NULL),
00057     m_MainController(NULL),
00058     m_TotalController(NULL),
00059     m_Progress(NULL)
00060 {
00061   m_DataFlow = new QseDataFlow();
00062 
00063   m_InputDataUI = new QseGraphController(m_DataFlow->m_InputData, NULL);
00064   m_MainWindow -> m_TabWidget -> insertTab(0, m_InputDataUI, "Input Data");
00065 
00066   m_DeglitcherUI = new QseDataDeglitcherUI(m_DataFlow->m_Deglitcher, NULL);
00067   m_MainWindow -> m_TabWidget -> insertTab(1, m_DeglitcherUI, "Deglitched Data");
00068 
00069   m_NormalizerUI = new QseNormalizerUI(m_DataFlow->m_Normalizer, NULL);
00070   m_MainWindow -> m_TabWidget -> insertTab(2, m_NormalizerUI, "Normalized Data");
00071 
00072   m_EdgeAlignerUI = new QseEdgeAlignerUI(m_DataFlow->m_EdgeAligner, NULL);
00073   m_MainWindow -> m_TabWidget -> insertTab(3, m_EdgeAlignerUI, "Aligned Data");
00074 
00075   m_ScanAveragerUI = new QseScanAveragerUI(m_DataFlow->m_ScanAverager, NULL);
00076   m_MainWindow -> m_TabWidget -> insertTab(4, m_ScanAveragerUI, "Averaged Data");
00077   
00078   m_SummaryTableController =
00079     new SummaryTableController(m_DataFlow->m_InputData, m_DataFlow->m_AveragerRole,
00080              m_MainWindow->scanTable, m_MainWindow);
00081 
00082   m_MainController         = 
00083     new SimpleGraphController(m_DataFlow->m_InputData, 
00084             m_MainWindow->mainGraph,
00085             m_MainWindow->scanTable, 
00086             m_MainWindow->scanColumnsView,
00087             m_DataFlow->m_AveragerRole,
00088             NULL);
00089   m_TotalController        = 
00090     new SimpleGraphController(m_DataFlow->m_TotalDataSet, 
00091             m_MainWindow->totalGraph, NULL, NULL, NULL, NULL);
00092 
00093   m_NormalizedController   = 
00094     new QseGraphController(m_DataFlow->m_NormalizedDataSet, NULL);
00095   m_MainWindow -> m_TabWidget -> 
00096     insertTab(4, m_NormalizedController, "Normalized Data");
00097 
00098   m_AveragedController     = 
00099     new QseGraphController(m_DataFlow->m_AveragedDataSet, NULL);
00100   m_MainWindow -> m_TabWidget -> 
00101     insertTab(5, m_AveragedController, "Averaged Data");
00102 
00103 
00104   m_NormalizedController -> addContextMenuAction(m_MainWindow->actionAverageSelectedScans);
00105 
00106   setupActions();
00107 
00108   connect(m_MainWindow -> scanSlider, SIGNAL(valueChanged(int)),
00109     this, SLOT(setCurrentScan(int)));
00110   
00111   connect(this, SIGNAL(currentScanChanged(int)),
00112     m_MainWindow -> scanSlider, SLOT(setValue(int)));
00113   
00114   connect(m_MainWindow -> runNormalizer, SIGNAL(clicked(void)),
00115     this, SLOT(runNormalizer(void)));
00116 
00117   connect(m_MainWindow->nextScanButton, SIGNAL(clicked(void)),
00118     this, SLOT(nextValidScan(void)));
00119   
00120   connect(m_MainWindow->previousScanButton, SIGNAL(clicked(void)),
00121     this, SLOT(previousValidScan(void)));
00122   
00123   connect(m_MainWindow -> actionRunNormalizer, SIGNAL(triggered()), 
00124     this, SLOT(runNormalizer(void)));
00125   connect(m_MainWindow -> actionSelectNextInputScan, SIGNAL(triggered()), 
00126     this, SLOT(nextScan(void)));
00127   connect(m_MainWindow -> actionSelectPreviousInputScan, SIGNAL(triggered()), 
00128     this, SLOT(previousScan(void)));
00129 
00130   connect(m_DataFlow->m_Averager,     SIGNAL(message(const QString&)),
00131     this,           SLOT(message(const QString&)));
00132 
00133   connect(m_DataFlow->m_InputData, SIGNAL(message(const QString&)),
00134     this,           SLOT(message(const QString&)));
00135 
00136   connect(m_DataFlow->m_InputData, SIGNAL(madeProgress(int)), this, SLOT(setProgress(int)));
00137 
00138   connect(m_DataFlow->m_InputData, SIGNAL(dataCleared()), this, SLOT(onDataCleared()));
00139 //   connect(m_DataFlow->m_InputData, SIGNAL(scanAdded(int)), this, SLOT(onScanAdded(int)));
00140   connect(m_DataFlow->m_InputData, SIGNAL(loadCompleted()), this, SLOT(onLoadCompleted()));
00141 
00142   connect(this, SIGNAL(defaultRolesChanged(void)), this, SLOT(updateDefaultRoles()));
00143   connect(m_SummaryTableController, SIGNAL(scanRangeRoleChanged(int,int)), 
00144     this, SLOT(updateRangeScanRoles(int,int)));
00145 
00146   connect(m_MainController, SIGNAL(columnRangeRolesChanged(int,int,int,int)), 
00147     this, SLOT(updateRangeColumnRoles(int,int,int,int)));
00148   connect(m_SummaryTableController, SIGNAL(columnRangeRolesChanged(int,int,int,int)), 
00149     this, SLOT(updateRangeColumnRoles(int,int,int,int)));
00150  
00151   m_MainWindow->mainGraph->setTitle("Scan Data");
00152   m_MainWindow->totalGraph->setTitle("Normalized");
00153  
00154   m_Pens[0].setColor(Qt::black);
00155   m_Pens[1].setColor(Qt::red);
00156   m_Pens[2].setColor(Qt::green);
00157   m_Pens[3].setColor(Qt::blue);
00158   m_Pens[4].setColor(Qt::cyan);
00159   m_Pens[5].setColor(Qt::magenta);
00160   m_Pens[6].setColor(Qt::darkYellow);
00161   m_Pens[7].setColor(Qt::darkRed);
00162   m_Pens[8].setColor(Qt::darkGreen);
00163   m_Pens[9].setColor(Qt::darkBlue);
00164   m_Pens[10].setColor(Qt::darkCyan);
00165   m_Pens[11].setColor(Qt::darkMagenta);
00166 
00167   m_NormalizedController->setTitle("Normalized Scans");
00168 
00169 //   connect(this, SIGNAL(normalizedScansChanged()), 
00170 //    m_NormalizedController, SLOT(updateScansTable()));
00171 
00172   m_AveragedController->setTitle("Averaged Data");
00173 
00174 //   connect(this, SIGNAL(averagedScansChanged()), 
00175 //    m_AveragedController, SLOT(updateScansTable()));
00176 
00177   m_Progress = new QProgressBar(NULL);
00178   m_Progress -> setMinimumWidth(150);
00179   m_Progress -> setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
00180 
00181   m_MainWindow -> statusBar() -> addPermanentWidget(m_Progress);
00182 
00183   QStringList args = QApplication::arguments();
00184   int nargs = args.size();
00185 
00186   for (int i=1; i<nargs; i++) {
00187     appendDataFile(args.at(i));
00188   }
00189 }

QseController::~QseController (  ) 

Definition at line 191 of file qsecontroller.cpp.

References m_AveragedController, m_MainController, m_NormalizedController, m_SummaryTableController, and m_TotalController.

00192 {
00193   delete m_SummaryTableController;
00194   delete m_MainController;
00195   delete m_TotalController;
00196   delete m_NormalizedController;
00197   delete m_AveragedController;
00198 }

Member Function Documentation

int QseController::isValidScan ( int  i  ) 

Definition at line 354 of file qsecontroller.cpp.

References QseDataFlow::m_AveragerRole, m_DataFlow, QseAveragerRole::matchesScan(), and scan().

Referenced by nextValidScan(), and previousValidScan().

00355 {
00356   int res = FALSE;
00357 
00358   QseScan *s = scan(i);
00359 
00360   if (s) {
00361     res = m_DataFlow->m_AveragerRole->matchesScan(s);
00362   }
00363 
00364   return res;
00365 }

Here is the call graph for this function:

void QseController::readSettings ( QSettings *  settings  ) 

Definition at line 537 of file qsecontroller.cpp.

References QseScan::column(), defaultRolesChanged(), QseInputFile::filePath(), QseDataFlow::m_AveragerRole, m_DataFlow, QseDataFlow::m_InputData, QseDataSet::scan(), QseAveragerRole::setDetectorPattern(), QseAveragerRole::setDetectorRegexp(), QseAveragerRole::setEnergyPattern(), QseAveragerRole::setEnergyRegexp(), QseAveragerRole::setInputEnergyUnits(), QseAveragerRole::setMaxScanRowCount(), QseAveragerRole::setMinScanRowCount(), QseAveragerRole::setNormalizationPattern(), QseAveragerRole::setNormalizationRegexp(), QseAveragerRole::setOutputEnergyUnits(), QseAveragerRole::setScanPattern(), QseAveragerRole::setScanRegexp(), QseAveragerRole::setSecondsPattern(), and QseAveragerRole::setSecondsRegexp().

Referenced by readControlFile().

00538 {
00539   QString scanPattern = settings->value("scanPattern").toString();
00540   QString energyPattern = settings->value("energyPattern").toString();
00541   QString detectorPattern = settings->value("detectorPattern").toString();
00542   QString normalizationPattern = settings->value("normalizationPattern").toString();
00543   QString secondsPattern = settings->value("secondsPattern").toString();
00544   QString minScanRowCount = settings->value("minScanRowCount").toString();
00545   QString maxScanRowCount = settings->value("maxScanRowCount").toString();
00546 
00547   int  inputEnergyUnits = settings->value("inputEnergyUnits").toInt();
00548   int  outputEnergyUnits = settings->value("outputEnergyUnits").toInt();
00549 
00550   bool scanRegexp = settings->value("scanRegexp").toBool();
00551   bool energyRegexp = settings->value("energyRegexp").toBool();
00552   bool detectorRegexp = settings->value("detectorRegexp").toBool();
00553   bool normalizationRegexp = settings->value("normalizationRegexp").toBool();
00554   bool secondsRegexp = settings->value("secondsRegexp").toBool();
00555 
00556   m_DataFlow->m_AveragerRole->setScanPattern(scanPattern);
00557   m_DataFlow->m_AveragerRole->setEnergyPattern(energyPattern);
00558   m_DataFlow->m_AveragerRole->setDetectorPattern(detectorPattern);
00559   m_DataFlow->m_AveragerRole->setNormalizationPattern(normalizationPattern);
00560   m_DataFlow->m_AveragerRole->setSecondsPattern(secondsPattern);
00561   m_DataFlow->m_AveragerRole->setMinScanRowCount(minScanRowCount);
00562   m_DataFlow->m_AveragerRole->setMaxScanRowCount(maxScanRowCount);
00563   
00564   m_DataFlow->m_AveragerRole->setInputEnergyUnits(inputEnergyUnits);
00565   m_DataFlow->m_AveragerRole->setOutputEnergyUnits(outputEnergyUnits);
00566 
00567   m_DataFlow->m_AveragerRole->setScanRegexp(scanRegexp);
00568   m_DataFlow->m_AveragerRole->setEnergyRegexp(energyRegexp);
00569   m_DataFlow->m_AveragerRole->setDetectorRegexp(detectorRegexp);
00570   m_DataFlow->m_AveragerRole->setNormalizationRegexp(normalizationRegexp);
00571   m_DataFlow->m_AveragerRole->setSecondsRegexp(secondsRegexp);
00572 
00573   if (m_DataFlow->m_InputData) {
00574     if (m_DataFlow->m_InputData->filePath() == settings->value("inputfile").toString()) {
00575       settings->beginReadArray("overrides");
00576       int ns = m_DataFlow->m_InputData -> scanCount();
00577 
00578       m_DataFlow->m_InputData -> setDefaultRoles();
00579 
00580       for (int i=0; i<ns; i++) {
00581   QseScan *s = m_DataFlow->m_InputData->scan(i);
00582   
00583   if (s) {
00584     settings->setArrayIndex(i);
00585 
00586     if (settings->contains("scanrole")) {
00587       QseScan::QseScanRole r = (QseScan::QseScanRole) settings->value("scanrole").toInt();
00588       int nc = s -> columnCount();
00589 
00590       s -> setScanRole(r);
00591 
00592       settings->beginReadArray("roles");
00593 
00594       for (int j=0; j<nc; j++) {
00595         QseColumn *c = s->column(j);
00596 
00597         settings->setArrayIndex(j);
00598 
00599         if (settings->contains("role")) {
00600     QseColumn::QseColumnRole r = (QseColumn::QseColumnRole) settings->value("role").toInt();
00601 
00602     c -> setColumnRole(r);
00603         }
00604       }
00605 
00606       settings -> endArray();
00607     }
00608   }
00609       }
00610 
00611       settings -> endArray();
00612     } else {
00613       printf("overridden file name does not match\n");
00614     }
00615   }
00616 
00617 //   revertPatternDisplay();
00618 
00619   emit defaultRolesChanged();
00620 }

Here is the call graph for this function:

void QseController::writeSettings ( QSettings *  settings  ) 

Definition at line 622 of file qsecontroller.cpp.

References QseScan::column(), QseScan::columnCount(), QseColumn::columnRole(), QseAveragerRole::detectorPattern(), QseAveragerRole::detectorRegexp(), QseAveragerRole::energyPattern(), QseAveragerRole::energyRegexp(), QseInputFile::filePath(), QseAveragerRole::inputEnergyUnits(), QseDataFlow::m_AveragerRole, m_DataFlow, QseDataFlow::m_InputData, QseAveragerRole::maxScanRowCount(), QseAveragerRole::minScanRowCount(), QseColumn::name(), QseAveragerRole::normalizationPattern(), QseAveragerRole::normalizationRegexp(), QseAveragerRole::outputEnergyUnits(), scan(), QseAveragerRole::scanPattern(), QseAveragerRole::scanRegexp(), QseScan::scanRole(), QseAveragerRole::secondsPattern(), QseAveragerRole::secondsRegexp(), and QseColumn::UnspecifiedRole.

Referenced by writeControlFile().

00623 {
00624   settings->setValue("scanPattern", m_DataFlow->m_AveragerRole->scanPattern());
00625   settings->setValue("energyPattern", m_DataFlow->m_AveragerRole->energyPattern());
00626   settings->setValue("detectorPattern", m_DataFlow->m_AveragerRole->detectorPattern());
00627   settings->setValue("normalizationPattern", m_DataFlow->m_AveragerRole->normalizationPattern());
00628   settings->setValue("secondsPattern", m_DataFlow->m_AveragerRole->secondsPattern());
00629   settings->setValue("minScanRowCount", m_DataFlow->m_AveragerRole->minScanRowCount());
00630   settings->setValue("maxScanRowCount", m_DataFlow->m_AveragerRole->maxScanRowCount());
00631   settings->setValue("inputEnergyUnits", m_DataFlow->m_AveragerRole->inputEnergyUnits());
00632   settings->setValue("outputEnergyUnits", m_DataFlow->m_AveragerRole->outputEnergyUnits());
00633 
00634   settings->setValue("scanRegexp", m_DataFlow->m_AveragerRole->scanRegexp());
00635   settings->setValue("energyRegexp", m_DataFlow->m_AveragerRole->energyRegexp());
00636   settings->setValue("detectorRegexp", m_DataFlow->m_AveragerRole->detectorRegexp());
00637   settings->setValue("normalizationRegexp", m_DataFlow->m_AveragerRole->normalizationRegexp());
00638   settings->setValue("secondsRegexp", m_DataFlow->m_AveragerRole->secondsRegexp());
00639 
00640   if (m_DataFlow->m_InputData) {
00641     settings->setValue("inputfile", m_DataFlow->m_InputData->filePath());
00642     int ns = m_DataFlow->m_InputData -> scanCount();
00643     settings->setValue("inputscancount", ns);
00644 
00645     if (ns > 0) {
00646       settings->beginWriteArray("overrides");
00647 
00648       for (int i=0; i<ns; i++) {
00649   settings -> setArrayIndex(i);
00650 
00651   QseScan *s = m_DataFlow->m_InputData -> scan(i);
00652 
00653   if (s) {
00654     int nc = s->columnCount();
00655     int ovr = false;
00656 
00657     for (int j=0; j<nc; j++) {
00658       QseColumn *c = s->column(j);
00659       if (c) {
00660         QseColumn::QseColumnRole r = c->columnRole();
00661         
00662         if (r != QseColumn::UnspecifiedRole) {
00663     ovr = true;
00664     break;
00665         }
00666       }
00667     }
00668     
00669     if (ovr) {
00670       QseScan::QseScanRole r = s->scanRole();
00671       settings->setValue("scanrole", r);
00672       
00673       settings->beginWriteArray("roles");
00674 
00675       for (int j=0; j<nc; j++) {
00676         QseColumn *c = s->column(j);
00677         if (c) {
00678     QseColumn::QseColumnRole r = c->columnRole();
00679 
00680     if (r != QseColumn::UnspecifiedRole) {
00681       settings->setArrayIndex(j);
00682       settings->setValue("name", c->name());
00683       settings->setValue("role", r);
00684     }
00685         }
00686       }
00687 
00688       settings->endArray();
00689     }
00690   }
00691       }
00692 
00693       settings->endArray();
00694     }
00695   }
00696 }

Here is the call graph for this function:

void QseController::currentScanChanged ( int   )  [signal]

Referenced by setCurrentScan().

void QseController::defaultRolesChanged ( void   )  [signal]

Referenced by readSettings().

void QseController::scanRoleChanged ( int   )  [signal]

void QseController::normalizedScansChanged (  )  [signal]

Referenced by runNormalizer().

void QseController::averagedScansChanged (  )  [signal]

void QseController::message ( const QString &  message  )  [slot]

Definition at line 244 of file qsecontroller.cpp.

References m_MainWindow.

Referenced by appendDataFile(), and readDataFile().

00245 {
00246   m_MainWindow->statusBar()->showMessage(message, 5000);
00247   m_MainWindow->outputMessageView->append(message);
00248 }

void QseController::setProgress ( int  level  )  [slot]

Definition at line 250 of file qsecontroller.cpp.

References m_Progress.

00251 {
00252   if (level > 100) {
00253     m_Progress -> reset();
00254   } else {
00255     m_Progress -> setValue(level);
00256   }
00257 }

void QseController::newScanStarted (  )  [slot]

Definition at line 238 of file qsecontroller.cpp.

References m_DataFlow, QseDataFlow::m_InputData, and m_MainWindow.

Referenced by onScanAdded().

00239 {
00240   m_MainWindow -> scanSlider -> setMinimum(0);
00241   m_MainWindow -> scanSlider -> setMaximum(m_DataFlow->m_InputData -> scanCount());
00242 }

void QseController::nextScan ( void   )  [slot]

Definition at line 279 of file qsecontroller.cpp.

References m_CurrentScan, and setCurrentScan().

00280 {
00281   setCurrentScan(m_CurrentScan + 1);
00282 }

void QseController::previousScan ( void   )  [slot]

Definition at line 284 of file qsecontroller.cpp.

References m_CurrentScan, and setCurrentScan().

00285 {
00286   setCurrentScan(m_CurrentScan - 1);
00287 }

void QseController::setCurrentScan ( int  n  )  [slot]

Definition at line 326 of file qsecontroller.cpp.

References currentScanChanged(), m_CurrentScan, m_DataFlow, QseDataFlow::m_InputData, m_MainController, QseDataSet::scanCount(), and updateGraphs().

Referenced by nextScan(), nextValidScan(), onDataCleared(), previousScan(), previousValidScan(), readDataFile(), and updateGraphs().

00327 {
00328   Q_ASSERT(m_DataFlow->m_InputData);
00329 
00330   if (m_DataFlow->m_InputData->scanCount()==0) {
00331     Q_ASSERT(m_CurrentScan == 0);
00332   } else {
00333     Q_ASSERT((0 <= m_CurrentScan) && (m_CurrentScan < m_DataFlow->m_InputData->scanCount()));
00334   }
00335 
00336   int nscans = m_DataFlow->m_InputData->scanCount();
00337 
00338   if ((0 <= n) && (n < nscans)) {
00339     if (n != m_CurrentScan) {
00340       m_CurrentScan = n;
00341 
00342       m_MainController -> setCurrentScan(n);
00343 
00344       updateGraphs();
00345 
00346       emit currentScanChanged(m_CurrentScan);
00347     }
00348   }
00349 }

void QseController::updateGraphs ( void   )  [slot]

Definition at line 384 of file qsecontroller.cpp.

References QseDataFlow::m_Averager, QseDataFlow::m_AveragerRole, m_CurrentScan, m_DataFlow, QseDataFlow::m_InputData, m_MainController, m_TotalController, QseDataFlow::m_TotalDataSet, QseAverager::normalizeScan(), and setCurrentScan().

Referenced by setCurrentScan(), updateDefaultRoles(), updateRangeColumnRoles(), updateRangeScanRoles(), and updateSelectedScan().

00385 {
00386   m_MainController -> updateGraph();
00387 
00388   m_DataFlow->m_TotalDataSet -> clear();
00389   QseScan *s = m_DataFlow->m_TotalDataSet -> appendScan();
00390 
00391   m_DataFlow->m_Averager->normalizeScan(m_DataFlow->m_InputData, 
00392           m_DataFlow->m_AveragerRole, s, m_CurrentScan);
00393   
00394   m_TotalController -> setCurrentScan(0);
00395   m_TotalController -> updateGraph();
00396 }

void QseController::openCompleted ( void   )  [slot]

Definition at line 259 of file qsecontroller.cpp.

References QseDataFlow::m_AveragedDataSet, m_DataFlow, QseDataFlow::m_InputData, m_MainWindow, QseDataFlow::m_NormalizedDataSet, and QseDataFlow::m_TotalDataSet.

Referenced by appendDataFile(), and readDataFile().

00260 {
00261   m_MainWindow -> loadedFile -> setText(m_DataFlow->m_InputData -> filePath());
00262 
00263   m_MainWindow -> scanSlider -> setMinimum(0);
00264   m_MainWindow -> scanSlider -> setMaximum(m_DataFlow->m_InputData -> scanCount());
00265 
00266   QString fname = m_DataFlow->m_InputData -> fileName();
00267   QStringList hdr = m_DataFlow->m_InputData -> header();
00268 
00269   m_DataFlow->m_TotalDataSet -> setFileName(fname+"_total");
00270   m_DataFlow->m_TotalDataSet -> setHeader(hdr);
00271 
00272   m_DataFlow->m_NormalizedDataSet -> setFileName(fname+"_norm");
00273   m_DataFlow->m_NormalizedDataSet -> setHeader(hdr);
00274 
00275   m_DataFlow->m_AveragedDataSet -> setFileName(fname+"_avg");
00276   m_DataFlow->m_AveragedDataSet -> setHeader(hdr);
00277 }

void QseController::runNormalizer ( void   )  [slot]

Definition at line 398 of file qsecontroller.cpp.

References QseAverager::exec(), QseDataFlow::m_Averager, QseDataFlow::m_AveragerRole, m_DataFlow, QseDataFlow::m_InputData, QseDataFlow::m_NormalizedDataSet, and normalizedScansChanged().

00399 {
00400   m_DataFlow->m_Averager->exec(m_DataFlow->m_InputData, 
00401              m_DataFlow->m_AveragerRole, 
00402              m_DataFlow->m_NormalizedDataSet);
00403 
00404   emit normalizedScansChanged();
00405 }

void QseController::averageSelectedScans (  )  [slot]

Definition at line 698 of file qsecontroller.cpp.

Referenced by setupActions().

00699 {
00700 //   QTableWidget *t = m_MainWindow->normalizedScanTable;
00701 
00702 //   QList<QTableWidgetSelectionRange> selections = t -> selectedRanges();
00703 //   QTableWidgetSelectionRange selection;
00704 
00705 //   int nscans = 0;
00706 //   QseScan *result = m_DataFlow->m_AveragedDataSet -> appendScan();
00707 
00708 //   foreach (selection, selections) {
00709 //     int r0 = selection.topRow();
00710 //     int r1 = selection.bottomRow();
00711 
00712 //     for (int i = r0; i<=r1; i++) {
00713 //       QseScan *s = m_DataFlow->m_NormalizedDataSet->scan(i);
00714 
00715 //       if (s) {
00716 //  if (m_DataFlow->m_Averager->addScans(result, s)) {
00717 //    nscans++;
00718 //  }
00719 //       }
00720 //     }
00721 //   }
00722 
00723 //   if (nscans > 0) {
00724 //     m_DataFlow->m_Averager->divideScan(result, nscans);
00725 
00726 //     emit averagedScansChanged();
00727 //   } else {
00728 //     delete result;
00729 //   }
00730 }

void QseController::previousValidScan (  )  [slot]

Definition at line 292 of file qsecontroller.cpp.

References isValidScan(), m_CurrentScan, and setCurrentScan().

00293 {
00294   int ns = m_CurrentScan - 1;
00295 
00296   while (ns >= 0) {
00297     if (isValidScan(ns)) {
00298       setCurrentScan(ns);
00299       break;
00300     } else {
00301       ns--;
00302     }
00303   }
00304 }

void QseController::nextValidScan (  )  [slot]

Definition at line 310 of file qsecontroller.cpp.

References isValidScan(), m_CurrentScan, m_DataFlow, QseDataFlow::m_InputData, and setCurrentScan().

00311 {
00312   Q_ASSERT(m_DataFlow->m_InputData);
00313 
00314   int ns = m_CurrentScan + 1;
00315 
00316   while (ns < m_DataFlow->m_InputData->scanCount()) {
00317     if (isValidScan(ns)) {
00318       setCurrentScan(ns);
00319       break;
00320     } else {
00321       ns++;
00322     }
00323   }
00324 }

void QseController::updateSelectedScan ( int  scan  )  [slot]

Definition at line 407 of file qsecontroller.cpp.

References m_MainController, and updateGraphs().

00408 {
00409   m_MainController -> updateColumnsTable();
00410   updateGraphs();
00411 }

void QseController::updateScanRole ( int  scan  )  [slot]

Definition at line 413 of file qsecontroller.cpp.

References updateRangeScanRoles().

00414 {
00415   updateRangeScanRoles(scan, scan);
00416 }

void QseController::updateRangeScanRoles (