qse  0.5.4
qsecontroller.cpp
Go to the documentation of this file.
1 #include "qsecontroller.h"
2 
3 #include <QTableWidget>
4 #include <QTableWidgetItem>
5 
6 #include <QPushButton>
7 #include <QStatusBar>
8 #include <QProgressBar>
9 #include <QSlider>
10 #include <QLabel>
11 #include <QLineEdit>
12 #include <QCheckBox>
13 #include <QMenu>
14 #include <QCursor>
15 #include <QFileDialog>
16 #include <QSettings>
17 #include <QDesktopServices>
18 
19 #include <qwt_plot.h>
20 #include <qwt_plot_item.h>
21 #include <qwt_plot_curve.h>
22 #include <qwt_plot_zoomer.h>
23 
24 #include "qsescan.h"
25 #include "qsefilereader.h"
26 #include "qsedataset.h"
27 #include "qsedatasetmodel.h"
28 #include "qseinputfile.h"
29 #include "qseprocessormain.h"
30 #include "qsegraphcontroller.h"
31 #include "qsedataflow.h"
32 #include "qsedatadeglitcherui.h"
33 #include "qsenormalizer.h"
34 #include "qsenormalizerui.h"
35 #include "qseedgealignerui.h"
36 #include "qsescanaveragerui.h"
37 
38 #include <stdio.h>
39 
41 (QseProcessorMain *w, QObject *parent)
42  : QObject(parent),
43  m_DataFlow(0),
44  m_MainWindow(w),
45  m_CurrentScan(0),
46  m_InputDataUI(NULL),
47  m_DeglitcherUI(NULL),
48  m_NormalizerUI(NULL),
49  m_EdgeAlignerUI(NULL),
50  m_ScanAveragerUI(NULL),
51  m_NormalizedController(NULL),
52  m_AveragedController(NULL),
53  m_Progress(NULL)
54 {
55  m_DataFlow = new QseDataFlow();
56  int tab = 0;
57 
58  m_InputDataUI = new QseGraphController(m_DataFlow->m_InputData, NULL);
59  m_MainWindow -> m_TabWidget -> insertTab(tab++, m_InputDataUI, "Input Data");
60 
61 // m_DeglitcherUI = new QseDataDeglitcherUI(m_DataFlow->m_Deglitcher, NULL);
62 // m_MainWindow -> m_TabWidget -> insertTab(tab++, m_DeglitcherUI, "Deglitched Data");
63 
64  m_NormalizerUI = new QseNormalizerUI(m_DataFlow->m_Normalizer, NULL);
65  m_MainWindow -> m_TabWidget -> insertTab(tab++, m_NormalizerUI, "Normalization");
66 
67  m_NormalizedController =
68  new QseGraphController(m_DataFlow->m_NormalizedData, NULL);
69  m_MainWindow -> m_TabWidget ->
70  insertTab(tab++, m_NormalizedController, "Normalized Data");
71 
72 // m_EdgeAlignerUI = new QseEdgeAlignerUI(m_DataFlow->m_EdgeAligner, NULL);
73 // m_MainWindow -> m_TabWidget -> insertTab(tab++, m_EdgeAlignerUI, "Aligned Data");
74 
75  m_ScanAveragerUI = new QseScanAveragerUI(m_DataFlow->m_ScanAverager, NULL);
76  m_MainWindow -> m_TabWidget -> insertTab(tab++, m_ScanAveragerUI, "Averaging");
77 
78  m_AveragedController =
79  new QseGraphController(m_DataFlow->m_AveragedData, NULL);
80  m_MainWindow -> m_TabWidget ->
81  insertTab(tab++, m_AveragedController, "Averaged Data");
82 
83  m_MainWindow -> m_TabWidget -> setCurrentIndex(0);
84 
85  m_NormalizedController -> addContextMenuAction(m_MainWindow->actionAverageSelectedScans);
86 
87  setupActions();
88 
89  connect(m_MainWindow -> actionRunNormalizer, SIGNAL(triggered()),
90  this, SLOT(runNormalizer(void)));
91 
92  connect(m_DataFlow->m_InputData, SIGNAL(message(const QString&)),
93  this, SLOT(message(const QString&)));
94 
95  connect(m_DataFlow->m_Normalizer, SIGNAL(message(const QString&)),
96  this, SLOT(message(const QString&)));
97 
98  connect(m_DataFlow->m_InputData, SIGNAL(madeProgress(int)), this, SLOT(setProgress(int)));
99 
100  m_NormalizedController->setTitle("Normalized Scans");
101 
102  m_AveragedController->setTitle("Averaged Data");
103 
104  m_Progress = new QProgressBar(NULL);
105  m_Progress -> setMinimumWidth(150);
106  m_Progress -> setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
107 
108  m_MainWindow -> statusBar() -> addPermanentWidget(m_Progress);
109 
110  QStringList args = QApplication::arguments();
111  int nargs = args.size();
112 
113  for (int i=1; i<nargs; i++) {
114  appendDataFile(args.at(i));
115  }
116 }
117 
119 {
120  delete m_NormalizedController;
121  delete m_AveragedController;
122 }
123 
125 {
126  connect(m_MainWindow->actionOpenDataFile, SIGNAL(triggered()),
127  this, SLOT(openDataFile()));
128  connect(m_MainWindow->actionAppendDataFile, SIGNAL(triggered()),
129  this, SLOT(appendDataFile()));
130  connect(m_MainWindow->actionOpenControlFile, SIGNAL(triggered()),
131  this, SLOT(openControlFile()));
132  connect(m_MainWindow->actionSaveSplitDataFiles, SIGNAL(triggered()),
133  this, SLOT(saveSplitDataFile()));
134  connect(m_MainWindow->actionSaveNormalizedFiles, SIGNAL(triggered()),
135  this, SLOT(saveNormalizedFile()));
136  connect(m_MainWindow->actionSaveAveragedFiles, SIGNAL(triggered()),
137  this, SLOT(saveAveragedFile()));
138  connect(m_MainWindow->actionSaveControlFile, SIGNAL(triggered()),
139  this, SLOT(saveControlFile()));
140  connect(m_MainWindow->actionExit, SIGNAL(triggered()),
141  this, SLOT(exitApplication()));
142 
143  connect(m_MainWindow->actionPrintNormalizedGraph, SIGNAL(triggered()),
144  m_NormalizedController, SLOT(printGraph()));
145  connect(m_MainWindow->actionPrintAveragedGraph, SIGNAL(triggered()),
146  m_AveragedController, SLOT(printGraph()));
147 
148  connect(m_MainWindow->actionQSEHomePage, SIGNAL(triggered()),
149  this, SLOT(openQSEHomePage()));
150 
151  connect(m_MainWindow->actionExit, SIGNAL(triggered()),
152  qApp, SLOT(quit()));
153 
154  connect(m_MainWindow->actionAverageSelectedScans, SIGNAL(triggered()),
155  this, SLOT(averageSelectedScans()));
156 }
157 
158 void QseController::message(const QString& message)
159 {
160  m_MainWindow->statusBar()->showMessage(message, 5000);
161  m_MainWindow->outputMessageView->append(message);
162 }
163 
165 {
166  if (level > 100) {
167  m_Progress -> reset();
168  } else {
169  m_Progress -> setValue(level);
170  }
171 }
172 
174 {
175  m_MainWindow -> loadedFile -> setText(m_DataFlow->m_InputData -> filePath());
176 
177  QString fname = m_DataFlow->m_InputData -> fileName();
178  QStringList hdr = m_DataFlow->m_InputData -> header();
179 
180  m_DataFlow->m_NormalizedData -> setFileName(fname+"_norm");
181  m_DataFlow->m_NormalizedData -> setHeader(hdr);
182 
183  m_DataFlow->m_AveragedData -> setFileName(fname+"_avg");
184  m_DataFlow->m_AveragedData -> setHeader(hdr);
185 }
186 
187 
192 {
193  return m_DataFlow->m_InputData->scan(n);
194 }
195 
200 {
202 }
203 
205 {
207 
208  emit normalizedScansChanged();
209 }
210 
212 {
213  QString filename = QFileDialog::getOpenFileName(m_MainWindow, tr("Open Data File"), ".", "");
214 
215  if (filename != "") {
216  readDataFile(filename);
217  }
218 }
219 
220 void QseController::readDataFile(const QString &name)
221 {
222 // setCurrentScan(0);
223 
224  m_DataFlow -> m_InputReader -> openFile(name);
225 
226  openCompleted();
227 
228  message(tr("New Data File loaded %1").arg(name));
229 }
230 
232 {
233  QString filename = QFileDialog::getOpenFileName(m_MainWindow, tr("Append Data File"), ".", "");
234 
235  if (filename != "") {
236  appendDataFile(filename);
237  }
238 }
239 
240 void QseController::appendDataFile(const QString &name)
241 {
242  m_DataFlow -> m_InputReader -> appendFile(name);
243 
244  openCompleted();
245 
246  message(tr("New Data File appended %1").arg(name));
247 }
248 
250 {
251  QString filename = QFileDialog::getOpenFileName(m_MainWindow, tr("Open Control File"), ".", "");
252 
253  if (filename != "") {
254  readControlFile(filename);
255  }
256 }
257 
258 void QseController::readControlFile(const QString &name)
259 {
260  QSettings settings(name, QSettings::IniFormat);
261 
262  readSettings(&settings);
263 }
264 
266 {
267 // m_MainController -> saveSelectedScans();
268 }
269 
271 {
272  m_NormalizedController -> saveSelectedScans();
273 }
274 
276 {
277  m_AveragedController -> saveSelectedScans();
278 }
279 
281 {
282  QString filename = QFileDialog::getSaveFileName(m_MainWindow, tr("Save Control File"), ".", "");
283 
284  if (filename != "") {
285  writeControlFile(filename);
286  }
287 }
288 
289 void QseController::writeControlFile(const QString &name)
290 {
291  QSettings settings(name, QSettings::IniFormat);
292 
293  writeSettings(&settings);
294 }
295 
297 {
298 }
299 
300 void QseController::readSettings(QSettings *settings)
301 {
302 // QString scanPattern = settings->value("scanPattern").toString();
303 // QString energyPattern = settings->value("energyPattern").toString();
304 // QString detectorPattern = settings->value("detectorPattern").toString();
305 // QString normalizationPattern = settings->value("normalizationPattern").toString();
306 // QString secondsPattern = settings->value("secondsPattern").toString();
307 // QString minScanRowCount = settings->value("minScanRowCount").toString();
308 // QString maxScanRowCount = settings->value("maxScanRowCount").toString();
309 
310 // int inputEnergyUnits = settings->value("inputEnergyUnits").toInt();
311 // int outputEnergyUnits = settings->value("outputEnergyUnits").toInt();
312 
313 // bool scanRegexp = settings->value("scanRegexp").toBool();
314 // bool energyRegexp = settings->value("energyRegexp").toBool();
315 // bool detectorRegexp = settings->value("detectorRegexp").toBool();
316 // bool normalizationRegexp = settings->value("normalizationRegexp").toBool();
317 // bool secondsRegexp = settings->value("secondsRegexp").toBool();
318 
319 // m_DataFlow->m_AveragerRole->setScanPattern(scanPattern);
320 // m_DataFlow->m_AveragerRole->setEnergyPattern(energyPattern);
321 // m_DataFlow->m_AveragerRole->setDetectorPattern(detectorPattern);
322 // m_DataFlow->m_AveragerRole->setNormalizationPattern(normalizationPattern);
323 // m_DataFlow->m_AveragerRole->setSecondsPattern(secondsPattern);
324 // m_DataFlow->m_AveragerRole->setMinScanRowCount(minScanRowCount);
325 // m_DataFlow->m_AveragerRole->setMaxScanRowCount(maxScanRowCount);
326 
327 // m_DataFlow->m_AveragerRole->setInputEnergyUnits(inputEnergyUnits);
328 // m_DataFlow->m_AveragerRole->setOutputEnergyUnits(outputEnergyUnits);
329 
330 // m_DataFlow->m_AveragerRole->setScanRegexp(scanRegexp);
331 // m_DataFlow->m_AveragerRole->setEnergyRegexp(energyRegexp);
332 // m_DataFlow->m_AveragerRole->setDetectorRegexp(detectorRegexp);
333 // m_DataFlow->m_AveragerRole->setNormalizationRegexp(normalizationRegexp);
334 // m_DataFlow->m_AveragerRole->setSecondsRegexp(secondsRegexp);
335 
336 // if (m_DataFlow->m_InputData) {
337 // if (m_DataFlow->m_InputData->filePath() == settings->value("inputfile").toString()) {
338 // settings->beginReadArray("overrides");
339 // int ns = m_DataFlow->m_InputData -> scanCount();
340 
341 // m_DataFlow->m_InputData -> setDefaultRoles();
342 
343 // for (int i=0; i<ns; i++) {
344 // QseScan *s = m_DataFlow->m_InputData->scan(i);
345 
346 // if (s) {
347 // settings->setArrayIndex(i);
348 
349 // if (settings->contains("scanrole")) {
350 // QseScan::QseScanRole r = (QseScan::QseScanRole) settings->value("scanrole").toInt();
351 // int nc = s -> columnCount();
352 
353 // s -> setScanRole(r);
354 
355 // settings->beginReadArray("roles");
356 
357 // for (int j=0; j<nc; j++) {
358 // QseColumn *c = s->column(j);
359 
360 // settings->setArrayIndex(j);
361 
362 // if (settings->contains("role")) {
363 // QseColumn::QseColumnRole r = (QseColumn::QseColumnRole) settings->value("role").toInt();
364 
365 // c -> setColumnRole(r);
366 // }
367 // }
368 
369 // settings -> endArray();
370 // }
371 // }
372 // }
373 
374 // settings -> endArray();
375 // } else {
376 // printf("overridden file name does not match\n");
377 // }
378 // }
379 
380 // // revertPatternDisplay();
381 
382 // emit defaultRolesChanged();
383 }
384 
385 void QseController::writeSettings(QSettings *settings)
386 {
387 // settings->setValue("scanPattern", m_DataFlow->m_AveragerRole->scanPattern());
388 // settings->setValue("energyPattern", m_DataFlow->m_AveragerRole->energyPattern());
389 // settings->setValue("detectorPattern", m_DataFlow->m_AveragerRole->detectorPattern());
390 // settings->setValue("normalizationPattern", m_DataFlow->m_AveragerRole->normalizationPattern());
391 // settings->setValue("secondsPattern", m_DataFlow->m_AveragerRole->secondsPattern());
392 // settings->setValue("minScanRowCount", m_DataFlow->m_AveragerRole->minScanRowCount());
393 // settings->setValue("maxScanRowCount", m_DataFlow->m_AveragerRole->maxScanRowCount());
394 // settings->setValue("inputEnergyUnits", m_DataFlow->m_AveragerRole->inputEnergyUnits());
395 // settings->setValue("outputEnergyUnits", m_DataFlow->m_AveragerRole->outputEnergyUnits());
396 
397 // settings->setValue("scanRegexp", m_DataFlow->m_AveragerRole->scanRegexp());
398 // settings->setValue("energyRegexp", m_DataFlow->m_AveragerRole->energyRegexp());
399 // settings->setValue("detectorRegexp", m_DataFlow->m_AveragerRole->detectorRegexp());
400 // settings->setValue("normalizationRegexp", m_DataFlow->m_AveragerRole->normalizationRegexp());
401 // settings->setValue("secondsRegexp", m_DataFlow->m_AveragerRole->secondsRegexp());
402 
403 // if (m_DataFlow->m_InputData) {
404 // settings->setValue("inputfile", m_DataFlow->m_InputData->filePath());
405 // int ns = m_DataFlow->m_InputData -> scanCount();
406 // settings->setValue("inputscancount", ns);
407 
408 // if (ns > 0) {
409 // settings->beginWriteArray("overrides");
410 
411 // for (int i=0; i<ns; i++) {
412 // settings -> setArrayIndex(i);
413 
414 // QseScan *s = m_DataFlow->m_InputData -> scan(i);
415 
416 // if (s) {
417 // int nc = s->columnCount();
418 // int ovr = false;
419 
420 // for (int j=0; j<nc; j++) {
421 // QseColumn *c = s->column(j);
422 // if (c) {
423 // QseColumn::QseColumnRole r = c->columnRole();
424 
425 // if (r != QseColumn::UnspecifiedRole) {
426 // ovr = true;
427 // break;
428 // }
429 // }
430 // }
431 
432 // if (ovr) {
433 // QseScan::QseScanRole r = s->scanRole();
434 // settings->setValue("scanrole", r);
435 
436 // settings->beginWriteArray("roles");
437 
438 // for (int j=0; j<nc; j++) {
439 // QseColumn *c = s->column(j);
440 // if (c) {
441 // QseColumn::QseColumnRole r = c->columnRole();
442 
443 // if (r != QseColumn::UnspecifiedRole) {
444 // settings->setArrayIndex(j);
445 // settings->setValue("name", c->name());
446 // settings->setValue("role", r);
447 // }
448 // }
449 // }
450 
451 // settings->endArray();
452 // }
453 // }
454 // }
455 
456 // settings->endArray();
457 // }
458 // }
459 }
460 
462 {
463 // QTableWidget *t = m_MainWindow->normalizedScanTable;
464 
465 // QList<QTableWidgetSelectionRange> selections = t -> selectedRanges();
466 // QTableWidgetSelectionRange selection;
467 
468 // int nscans = 0;
469 // QseScan *result = m_DataFlow->m_AveragedDataSet -> appendScan();
470 
471 // foreach (selection, selections) {
472 // int r0 = selection.topRow();
473 // int r1 = selection.bottomRow();
474 
475 // for (int i = r0; i<=r1; i++) {
476 // QseScan *s = m_DataFlow->m_NormalizedDataSet->scan(i);
477 
478 // if (s) {
479 // if (m_DataFlow->m_Averager->addScans(result, s)) {
480 // nscans++;
481 // }
482 // }
483 // }
484 // }
485 
486 // if (nscans > 0) {
487 // m_DataFlow->m_Averager->divideScan(result, nscans);
488 
489 // emit averagedScansChanged();
490 // } else {
491 // delete result;
492 // }
493 }
494 
496 {
497  QDesktopServices::openUrl(QUrl("http://qse.sourceforge.net"));
498 }
QseScan * scan(int n) const
Definition: qsedataset.cpp:70
QseScan * scan(int n)
void normalizedScansChanged()
QseController(QseProcessorMain *w, QObject *parent=0)
QseNormalizer * m_Normalizer
Definition: qsedataflow.h:35
void saveSplitDataFile()
QseInputFile * m_InputData
Definition: qsedataflow.h:32
void readControlFile(const QString &name)
void saveNormalizedFile()
QseDataSet * m_NormalizedData
Definition: qsedataflow.h:36
void setProgress(int level)
void readSettings(QSettings *settings)
void saveControlFile()
void openCompleted(void)
void averageSelectedScans()
void openControlFile()
void openQSEHomePage()
void runNormalizer(void)
QseDataSet * m_AveragedData
Definition: qsedataflow.h:40
int openFile(QString fileName)
QseGraphController * m_NormalizedController
Definition: qsecontroller.h:88
QseScan * currentScan()
QProgressBar * m_Progress
Definition: qsecontroller.h:93
void message(const QString &message)
void readDataFile(const QString &name)
void writeControlFile(const QString &name)
QseGraphController * m_AveragedController
Definition: qsecontroller.h:89
QseProcessorMain * m_MainWindow
Definition: qsecontroller.h:80
void exitApplication()
QseDataFlow * m_DataFlow
Definition: qsecontroller.h:79
void writeSettings(QSettings *settings)
void saveAveragedFile()