WSL/SLF GitLab Repository

MainWindow.cc 46.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*****************************************************************************/
/*  Copyright 2019 WSL Institute for Snow and Avalanche Research  SLF-DAVOS  */
/*****************************************************************************/
/* This file is part of INIshell.
   INIshell is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   INIshell is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License
   along with INIshell. If not, see <http://www.gnu.org/licenses/>.
*/

19
20
21
22
23
/*
 * The main window that is displayed on startup.
 * 2019-10
 */

24
#include "MainWindow.h"
Michael Reisecker's avatar
Michael Reisecker committed
25
#include "src/gui/AboutWindow.h"
26
#include "src/gui_elements/Group.h" //to exclude Groups from panel search
27
#include "src/main/colors.h"
28
29
30
#include "src/main/Error.h"
#include "src/main/dimensions.h"
#include "src/main/INIParser.h"
31
#include "src/main/inishell.h"
32
#include "src/main/settings.h"
33
#include "src/main/XMLReader.h"
34
35

#include <QApplication>
36
#include <QCheckBox>
37
#include <QDesktopServices>
38
#include <QDir>
39
#include <QFileDialog>
40
#include <QFileInfo>
Michael Reisecker's avatar
Michael Reisecker committed
41
#include <QGroupBox>
42
#include <QMenuBar>
43
#include <QMessageBox>
44
#include <QRegularExpression>
45
#include <QSpacerItem>
46
47
48
49
#include <QStatusBar>
#include <QSysInfo>
#include <QToolBar>

50
51
#include <QMovie>

52
53
54
#ifdef DEBUG
	#include <iostream>
#endif
55

56
57
58
59
60
61
62
/**
 * @class MouseEventFilter
 * @brief Mouse event listener for the main program window.
 * @param[in] object Object the event stems from.
 * @param[in] event The type of event.
 * @return True if the event was accepted.
 */
63
64
65
bool MouseEventFilter::eventFilter(QObject *object, QEvent *event)
{
	if (event->type() == QEvent::MouseButtonPress) {
66
		if (object->property("mouseclick") == "open_log") {
67
			getMainWindow()->viewLogger();
68
69
70
71
		} else if (object->property("mouseclick") == "open_ini") {
			if (!getMainWindow()->ini_filename_->text().isEmpty())
				QDesktopServices::openUrl("file:" + getMainWindow()->ini_filename_->text());
		}
72
	}
73
	return QObject::eventFilter(object, event); //pass to actual event of the object
74
75
}

76
77
78
79
80
81
/**
 * @class MainWindow
 * @brief Constructor for the main window.
 * @param[in] xml_settings Settings for the static INIshell GUI.
 * @param[in] parent Unused since the main window is kept in scope by the entry point function.
 */
Michael Reisecker's avatar
Michael Reisecker committed
82
MainWindow::MainWindow(QDomDocument &xml_settings, QString &settings_location, const QStringList &errors, QMainWindow *parent)
83
    : QMainWindow(parent), logger_(this), xml_settings_(xml_settings), xml_settings_filename_(settings_location)
84
{
85

86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
	/*
	 * Program flowchart sketch:
	 *
	 *   _________________________________
	 *   |  Build GUI elements from XML  |
	 *   ---------------------------------
	 *                  |
	 *                  | set elements' INI key values via:
	 *                  V
	 *
	 *         XML              INI
	 *   (default values)  (file system)                      VALIDATION
	 *          |                |                           (set styles)
	 *          |                |                                ^
	 *          v                v                               /
	 *    _____________________________________                 /
	 *    |      Element's onPropertySet      |  -----> CHECK VALUE
	 *    -------------------------------------               |
	 *          ^                ^        (Property "no_ini" not set? Value not empty?)
	 *          |                |                            |
	 *          |                |                            v
	 *         GUI              CODE                        OUTPUT
	 * (user interaction)  (reactive changes)            (on request)
	 */
110

111
	status_timer_ = new QTimer(this); //for temporary status messages
112
113
114
	status_timer_->setSingleShot(true);
	connect(status_timer_, &QTimer::timeout, this, &MainWindow::clearStatus);

115
	logger_.logSystemInfo();
116
	for (auto &err : errors) //errors from main.cc before the Logger existed
117
		logger_.log(err, "error");
118

119
	/* retrieve and set main window geometry */
Michael Reisecker's avatar
Michael Reisecker committed
120
121
	dim::setDimensions(this, dim::MAIN_WINDOW);
	dim::setDimensions(&logger_, dim::LOGGER);
122

123
	/* create basic GUI items */
124
125
	createMenu();
	createToolbar();
126
	createStatusbar();
127

128
	preview_ = new PreviewWindow(this);
129
	/* create the dynamic GUI area */
130
	control_panel_ = new MainPanel(this);
131
	this->setCentralWidget(control_panel_);
132
	ini_.setLogger(&logger_);
133
134
135
136
	if (errors.isEmpty())
		setStatus(tr("Ready."), "info");
	else
		setStatus(tr("Errors occurred on startup"), "error");
137
}
138

139
140
141
142
/**
 * @brief Destructor for the main window.
 * @details This function is called after all safety checks have already been performed.
 */
143
MainWindow::~MainWindow()
144
{ //safety checks are performed in closeEvent()
145
	setWindowSizeSettings(); //put the main window sizes into the settings XML
146
	saveSettings(xml_settings_);
147
148
	delete mouse_events_toolbar_;
	delete mouse_events_statusbar_;
149
150
}

151
152
153
154
155
156
157
/**
 * @brief Build the dynamic GUI.
 * This function initiates the recursive GUI building with an XML document that was
 * parsed beforehand.
 * @param[in] xml XML to build the gui from.
 */
void MainWindow::buildGui(const QDomDocument &xml)
158
{
159
	setUpdatesEnabled(false); //disable painting until done
160
	QDomNode root = xml.firstChild();
161
162
163
164
165
166
167
168
	while (!root.isNull()) {
		if (root.isElement()) { //skip over comments
			//give no parent group - tabs will be created for top level:
			recursiveBuild(root, nullptr, QString());
			break;
		}
		root = root.nextSibling();
	}
169
	setUpdatesEnabled(true);
170
171
}

172
173
174
/**
 * @brief Set the loaded panels' values from an INI file.
 * @param[in] ini The INI file in form of an INIParser (usually the main one).
175
 * @return True if all INI keys are known to the loaded XML.
176
 */
177
bool MainWindow::setGuiFromIni(const INIParser &ini)
178
{
179
	bool all_ok = true;
180
181
182
183
	for (auto &sec : ini.getSections()) { //run through sections in INI file
		ScrollPanel *tab_scroll = getControlPanel()->getSectionScrollarea(sec.getName(),
		    QString(), QString(), true); //get the corresponding tab of our GUI
		if (tab_scroll != nullptr) { //section exists in GUI
184
			const auto kv_list( sec.getKeyValueList() );
185
			for (size_t ii = 0; ii < kv_list.size(); ++ii) {
186
187
				//find the corresponding panel, and try to create it for dynamic panels
				//(e. g. Selector, Replicator):
188
				QWidgetList widgets( findPanel(tab_scroll, sec, *sec[ii]) );
189
				if (!widgets.isEmpty()) {
190
191
					for (int jj = 0; jj < widgets.size(); ++jj) //multiple panels can share the same key
						widgets.at(jj)->setProperty("ini_value", sec[ii]->getValue());
192
				} else {
193
					logger_.log(tr("No GUI element found for INI key \"") + sec.getName() +
194
					    Cst::sep + sec[ii]->getKey() + "\"", "warning");
195
					all_ok = false;
196
				}
197
198
			} //endfor kv
		} else { //section does not exist
199
			log(tr("No matching section in GUI for section from INI file: \"") +
200
			    sec.getName() + "\"", "warning");
201
			all_ok = false;
202
		} //endif section exists
203
	} //endfor sec
204
	return all_ok;
205
206
}

207
208
209
210
211
/**
 * @brief Retrieve all panels that handle a certain INI key.
 * @param[in] ini_key The INI key to find.
 * @return A list of all panels that handle the INI key.
 */
212
213
QList<Atomic *> MainWindow::getPanelsForKey(const QString &ini_key)
{
214
	QList<Atomic *> panel_list( control_panel_->findChildren<Atomic *>(Atomic::getQtKey(ini_key)) );
215
	for (auto it = panel_list.begin(); it != panel_list.end(); ++it) {
216
217
		//groups don't count towards finding INI keys (for this reason, they additionally
		//have the "no_ini" key set):
218
		if (qobject_cast<Group *>(*it))
219
			panel_list.erase(it);
220
221
222
223
	}
	return panel_list;
}

224
225
226
227
228
229
/**
 * @brief Save the current GUI to an INI file.
 * @details This function calls the underlying function that does this and displays a message if
 * the user has neglected to set some mandatory INI values.
 * @param[in] filename The file to save to. If not given, the current INI file will be used.
 */
230
void MainWindow::saveIni(const QString &filename)
231
{
232
233
234
235
236
237
	/*
	 * We keep the original INIParser as-is, i. e. we always keep the INI file as it was loaded
	 * originally. This is solemnly to be able to check if anything has changed through user
	 * interaction, and if yes, warn before closing.
	 */
	INIParser gui_ini = ini_; //an INIParser is safe to copy around - this is a deep copy
238
	const QString missing( control_panel_->setIniValuesFromGui(&gui_ini) );
239

240
	if (!missing.isEmpty()) {
241
242
243
		QMessageBox msgMissing;
		msgMissing.setWindowTitle("Warning ~ " + QCoreApplication::applicationName());
		msgMissing.setText(tr("<b>Missing mandatory INI values.</b>"));
244
245
		msgMissing.setInformativeText(tr(
		    "Some non-optional INI keys are not set.\nSee details for a list or go back to the GUI and set all highlighted fields."));
246
		msgMissing.setDetailedText(tr("Missing INI keys:\n") + missing);
247
248
249
250
251
252
		msgMissing.setIcon(QMessageBox::Warning);
		msgMissing.setStandardButtons(QMessageBox::Save | QMessageBox::Cancel);
		msgMissing.setDefaultButton(QMessageBox::Cancel);
		int clicked = msgMissing.exec();
		if (clicked == QMessageBox::Cancel)
			return;
253
	}
254
	//if no file is specified we save to the currently open INI file (save vs. save as):
255
256
257
	gui_ini.writeIni(filename.isEmpty()? gui_ini.getFilename() : filename);
}

258
259
260
/**
 * @brief Save the currently set values to a new INI file.
 */
261
262
void MainWindow::saveIniAs()
{
263
264
265
	QString start_path( getSetting("auto::history::last_ini", "path") );
	if (start_path.isEmpty())
		start_path = getSetting("auto::history::last_preview_write", "path");
266
267
268
269
270
	if (start_path.isEmpty())
		start_path = QDir::currentPath();

	const QString filename = QFileDialog::getSaveFileName(this, tr("Save INI file"),
	    start_path + "/" + ini_filename_->text(),
271
	    "INI files (*.ini *.INI);;All files (*)", nullptr, QFileDialog::DontUseNativeDialog);
272
273
274
	if (filename.isNull()) //cancelled
		return;
	saveIni(filename);
275
	ini_.setFilename(filename); //the new file is the new current file like in all programs
276
	ini_filename_->setText(filename);
277
	autoload_->setVisible(true); //if started from an empty GUI, this could still be disabled
278
279
	toolbar_save_ini_->setEnabled(true); //toolbar entry
	file_save_ini_->setEnabled(true); //menu entry
280
281
282

	const QFileInfo finfo(filename);
	setSetting("auto::history::last_ini", "path", finfo.absoluteDir().path());
283
284
}

285
286
287
/**
 * @brief Select a path for an INI file to be opened, and then open it.
 */
288
void MainWindow::openIni()
289
{
290
	QString start_path( getSetting("auto::history::last_ini", "path") );
291
292
293
294
	if (start_path.isEmpty())
		start_path = QDir::currentPath();

	const QString path = QFileDialog::getOpenFileName(this, tr("Open INI file"), start_path,
295
296
	    "INI files (*.ini);;All files (*)", nullptr,
	    QFileDialog::DontUseNativeDialog | QFileDialog::DontConfirmOverwrite);
297
	if (path.isNull()) //cancelled
298
299
		return;
	openIni(path);
300
301
302

	const QFileInfo finfo(path);
	setSetting("auto::history::last_ini", "path", finfo.absoluteDir().path());
303
304
}

305
306
307
308
309
/**
 * @brief Open an INI file and set the GUI to it's values.
 * @param[in] path The INI file to open.
 * @param[in] is_autoopen Is the INI being loaded through the autoopen mechanism?
 */
310
void MainWindow::openIni(const QString &path, const bool &is_autoopen, const bool &fresh)
311
{
312
	this->getControlPanel()->getWorkflowPanel()->setEnabled(false); //hint at INIshell processing...
313
	setStatus(tr("Reading INI file..."), "info", true);
314
	refreshStatus(); //necessary if heavy operations follow
315
316
	if (fresh)
		clearGui();
317
318
319
320
321
	const bool success = ini_.setFile(path); //load the file into the main INI parser
	if (!setGuiFromIni(ini_)) //set the GUI to the INI file's values
		setStatus(tr("INI file read with unknown keys"), "warning");
	else
		setStatus(tr("INI file read ") + (success? tr("successfully") : tr("with warnings")),
322
		    (success? "info" : "warning")); //ill-formatted lines in INI file
323
	toolbar_save_ini_->setEnabled(true);
324
	file_save_ini_->setEnabled(true);
325
	autoload_->setVisible(true);
326
	ini_filename_->setText(path);
327
	autoload_box_->setText(tr("autoload this INI for ") + current_application_);
328
	if (!is_autoopen) //when a user clicks an INI file to open it we ask anew whether to autoopen
329
		autoload_box_->setCheckState(Qt::Unchecked);
330

331
	this->getControlPanel()->getWorkflowPanel()->setEnabled(true);
Mathias Bavay's avatar
Mathias Bavay committed
332
	QApplication::alert( this ); //notify the user that the task is finished
333
334
}

335
336
337
338
339
340
/**
 * @brief Close the currently opened INI file.
 * @details This function checks whether the user has made changes to the INI file and if yes,
 * allows to save first, discard changes, or cancel the operation.
 * @return True if the INI file was closed, false if the user has cancelled.
 */
341
bool MainWindow::closeIni()
342
{
343
	if (!help_loaded_ && //unless user currently has the help opened which we always allow to close
344
	    getSetting("user::inireader::warn_unsaved_ini", "value") == "TRUE") {
345
346
347
348
349
350
351
		/*
		 * We leave the original INIParser - the one that holds the values like they were
		 * originally read from an INI file - intact and make a copy of it. The currently
		 * set values from the GUI are loaded into the copy, and then the two are compared
		 * for changes. This way we don't display a "settings may be lost" warning if in
		 * fact nothing has changed, resp. the changes cancelled out.
		 */
352
353
354
355
356
357
		INIParser gui_ini = ini_;
		(void) control_panel_->setIniValuesFromGui(&gui_ini);
		if (ini_ != gui_ini) {
			QMessageBox msgNotSaved;
			msgNotSaved.setWindowTitle("Warning ~ " + QCoreApplication::applicationName());
			msgNotSaved.setText(tr("<b>INI settings will be lost.</b>"));
358
359
			msgNotSaved.setInformativeText(tr(
			    "Some INI keys you have set will be lost if you don't save the current INI file."));
360
			msgNotSaved.setDetailedText(ini_.getEqualityCheckMsg());
361
362
363
			msgNotSaved.setIcon(QMessageBox::Warning);
			msgNotSaved.setStandardButtons(QMessageBox::Save | QMessageBox::Cancel | QMessageBox::Discard);
			msgNotSaved.setDefaultButton(QMessageBox::Cancel);
364

365
			auto *show_msg_again = new QCheckBox(tr("Don't show this warning again"));
366
367
368
369
370
371
372
373
			show_msg_again->setToolTip(tr("The warning can be re-enabled in the settings"));
			show_msg_again->setStyleSheet("QCheckBox {color: " + colors::getQColor("info").name() + "}");
			msgNotSaved.setCheckBox(show_msg_again);
			connect(show_msg_again, &QCheckBox::stateChanged, [](int state) {
				const bool checked = (state == Qt::CheckState::Checked);
				setSetting("user::inireader::warn_unsaved_ini", "value", !checked? "TRUE" : "FALSE");
			});

374
375
376
			int clicked = msgNotSaved.exec();
			if (clicked == QMessageBox::Cancel)
				return false;
Michael Reisecker's avatar
Michael Reisecker committed
377
			if (clicked == QMessageBox::Save)
378
				saveIni();
379
			delete show_msg_again;
380
381
		}
	} //endif help_loaded
382

383
	ini_.clear();
384
	toolbar_save_ini_->setEnabled(false);
385
	file_save_ini_->setEnabled(false);
386
	ini_filename_->setText(QString());
387
	autoload_->setVisible(false);
388
	return true;
389
390
}

391
392
393
394
395
/**
 * @brief Reset the GUI to default values.
 * @details This function checks whether there were any changes to the INI values
 * (if yes, the user can save first or discard or cancel), then clears the whole GUI.
 */
396
void MainWindow::clearGui(const bool &set_default)
397
{
398
	const bool perform_close = closeIni();
399
	if (!perform_close) //user clicked 'cancel'
400
		return;
401
	getControlPanel()->clearGui(set_default);
402
	ini_filename_->setText(QString());
403
	autoload_->setVisible(false);
404
405
}

406
407
408
409
410
/**
 * @brief Store the main window sizes in the settings XML.
 */
void MainWindow::setWindowSizeSettings()
{
411
	setSplitterSizeSettings();
412
413
414
415
416
417
418
419
420
421
422
423
424

	setSetting("auto::sizes::window_" + QString::number(dim::window_type::PREVIEW),
	    "width", QString::number(preview_->width()));
	setSetting("auto::sizes::window_" + QString::number(dim::window_type::PREVIEW),
	    "height", QString::number(preview_->height()));
	setSetting("auto::sizes::window_" + QString::number(dim::window_type::LOGGER),
	    "width", QString::number(logger_.width()));
	setSetting("auto::sizes::window_" + QString::number(dim::window_type::LOGGER),
	    "height", QString::number(logger_.height()));
	setSetting("auto::sizes::window_" + QString::number(dim::window_type::MAIN_WINDOW),
	    "width", QString::number(this->width()));
	setSetting("auto::sizes::window_" + QString::number(dim::window_type::MAIN_WINDOW),
	    "height", QString::number(this->height()));
425
426
427

	//remember the toolbar position:
	setSetting("auto::position::toolbar", "position", QString::number(this->toolBarArea(toolbar_)));
428
429
}

430
431
432
433
434
435
436
437
438
439
/**
 * @brief Remember the main splitter's space distribution.
 */
void MainWindow::setSplitterSizeSettings()
{
	QList<int> splitter_sizes(control_panel_->getSplitterSizes());
	setSetting("auto::sizes::splitter_workflow", "size", QString::number(splitter_sizes.at(0)));
	setSetting("auto::sizes::splitter_mainpanel", "size", QString::number(splitter_sizes.at(1)));
}

440
441
442
443
444
445
/**
 * @brief Create a context menu for the toolbar.
 */
void MainWindow::createToolbarContextMenu()
{
	/* allow user to enable toolbar dragging */
446
	auto *fix_toolbar_position = new QAction(tr("Fix toolbar position"), this);
447
448
449
450
451
	fix_toolbar_position->setCheckable(true);
	fix_toolbar_position->setChecked(getSetting("user::appearance::fix_toolbar_pos", "value") == "TRUE");
	toolbar_context_menu_.addAction(fix_toolbar_position);
}

452
453
454
455
456
457
/**
 * @brief Open an XML file containing an application/simulation.
 * @param[in] path Path to the file to open.
 * @param[in] app_name When looking for applications, the application name was parsed and put
 * into a list. This is the app_name so we don't have to parse again.
 * @param[in] fresh If true, reset the GUI before opening a new application.
458
 * @param[in] is_settings_dialog Is it the settings that are being loaded?
459
 */
460
461
void MainWindow::openXml(const QString &path, const QString &app_name, const bool &fresh,
    const bool &is_settings_dialog)
462
{
463
	if (fresh) {
464
		const bool perform_close = closeIni();
465
		if (!perform_close)
466
			return;
467
		control_panel_->closeSettingsTab();
468
		control_panel_->clearGuiElements();
469
		help_loaded_ = false;
470
	}
471
	current_application_ = app_name;
472

473
	QString autoload_ini;
474
	if (QFile::exists(path)) {
475
		setStatus(tr("Reading application XML..."), "info", true);
476
		refreshStatus();
477
478
		XMLReader xml;
		QString xml_error = QString();
479
		autoload_ini = xml.read(path, xml_error);
480
481
482
		if (!xml_error.isNull()) {
			xml_error.chop(1); //trailing \n
			Error(tr("Errors occured when parsing the XML configuration file"),
483
			    tr("File: \"") + QDir::toNativeSeparators(path) + "\"", xml_error);
484
		}
485
		setStatus("Building GUI...", "info", true);
486
		buildGui(xml.getXml());
487
		setStatus("Ready.", "info", false);
488
		control_panel_->getWorkflowPanel()->buildWorkflowPanel(xml.getXml());
489
490
491
492
493
494
495
496
		if (!autoload_ini.isEmpty()) {
			if (QFile::exists(autoload_ini)) {
				openIni(autoload_ini);
			} else {
				log(QString("Can not load INI file \"%1\" automatically because it does not exist.").arg(
				    QDir::toNativeSeparators(autoload_ini)), "error");
			}
		}
497
	} else {
498
		topLog(tr("An application or simulation file that has previously been found is now missing. Right-click the list to refresh."),
499
		     "error");
500
		setStatus(tr("File has been removed"), "error");
501
		return;
502
	}
503

504
	toolbar_clear_gui_->setEnabled(true);
505
	gui_reset_->setEnabled(true);
506
507
508
	gui_clear_->setEnabled(true);
	if (is_settings_dialog) //no real XML - don't enable XML options
		return;
509
	toolbar_save_ini_as_->setEnabled(true);
510
	file_save_ini_as_->setEnabled(true);
511

512
513
514
	//run through all INIs that were saved to be autoloaded and check if it's the application we are opening:
	for (auto ini_node = xml_settings_.firstChildElement().firstChildElement("user").firstChildElement(
	    "autoload").firstChildElement("ini");
515
516
517
518
	    !ini_node.isNull(); ini_node = ini_node.nextSiblingElement("ini")) {
		if (ini_node.attribute("application").toLower() == app_name.toLower()) {
			autoload_box_->blockSignals(true); //don't re-save the setting we just fetched
			autoload_box_->setCheckState(Qt::Checked);
519
			autoload_box_->setText(tr("autoload this INI for ") + current_application_);
520
			autoload_box_->blockSignals(false);
521
			openIni(ini_node.text(), true); //TODO: delete if non-existent
522
523
524
			break;
		}
	}
525
526
	toolbar_open_ini_->setEnabled(true); //toolbar entry
	file_open_ini_->setEnabled(true); //menu entry
527
528
529
530
	auto *file_view = getControlPanel()->getWorkflowPanel()->getFilesystemView();
	file_view->setEnabled(true);
	auto *path_label = file_view->getInfoLabel();
	path_label->setText(file_view->getInfoLabel()->property("path").toString());
Mathias Bavay's avatar
Mathias Bavay committed
531
532
	path_label->setWordWrap(true);
	path_label->setStyleSheet("QLabel {font-style: italic}");
Mathias Bavay's avatar
Mathias Bavay committed
533
	QApplication::alert( this ); //notify the user that the task is finished
534
535
}

536
537
538
539
540
541
542
543
544
545
/**
 * @brief Find the panels that control a certain key/value pair.
 * @details This function includes panels that could be created by dynamic panels (Selector etc.).
 * @param[in] parent The parent panel or window to search, since usually we have some information
 * about where to find it. This function is used when iterating through INIParser elements
 * to load the GUI with values.
 * @param[in] section The section to find.
 * @param[in] keyval The key/value pair to find.
 * @return A list of all panels controlling the key/value pair.
 */
546
QWidgetList MainWindow::findPanel(QWidget *parent, const Section &section, const KeyValue &keyval)
547
{
548
	QWidgetList panels;
549
	//first, check if there is a panel for it loaded and available:
550
	panels = findSimplePanel(parent, section, keyval);
551
	int panel_count = parent->findChildren<Atomic *>().count();
552
	//if not found, check if one of our Replicators can create it:
553
	if (panels.isEmpty())
554
		panels = prepareReplicator(parent, section, keyval);
555
556
557
558
559
560
	//if still not found, check if one of our Selectors can create it:
	if (panels.isEmpty())
		panels = prepareSelector(parent, section, keyval);
	//TODO: For the current MeteoIO XML the order is important here so that a TIME filter
	//does not show up twice (because both the normal and time filter's panel fit the pattern).
	//Cleaning up here would also increase performance.
561
	if (parent->findChildren<Atomic *>().count() != panel_count) //new elements were created
562
		return findPanel(parent, section, keyval); //recursion through Replicators that create Selectors that...
Michael Reisecker's avatar
Michael Reisecker committed
563
	return panels; //no more suitable dynamic panels found
564
565
}

566
567
568
569
570
571
572
573
574
/**
 * @brief Find the panels that control a certain key/value pair.
 * @details This function does not include dynamic panels (Selector etc.) and searches only
 * what has already been created.
 * @param[in] parent The parent panel or window to search, because usually we have some information.
 * @param[in] section Section to find.
 * @param[in] keyval Key-value pair to find.
 * @return A list of all panels controlling the key/value pair.
 */
575
QWidgetList MainWindow::findSimplePanel(QWidget *parent, const Section &section, const KeyValue &keyval)
576
577
578
{
	QString id(section.getName() + Cst::sep + keyval.getKey());
	/* simple, not nested, keys */
Michael Reisecker's avatar
Michael Reisecker committed
579
	return parent->findChildren<QWidget *>(Atomic::getQtKey(id));
580
581
}

582
583
584
585
586
587
588
589
590
591
/**
 * @brief Find a Selector in our GUI that could handle a given INI key.
 * @details This function looks for Selectors handling keys like "%::COPY". If one is found,
 * it requests the Selector to create a new panel for the key which will then be available
 * to the parent function that is currently looking for a suitable panel for the INI key.
 * @param[in] parent The parent panel or window to search.
 * @param[in] section Section to find.
 * @param[in] keyval Key/value pair to find.
 * @return A list of panels for the INI key including the possibly newly created ones.
 */
592
QWidgetList MainWindow::prepareSelector(QWidget *parent, const Section &section, const KeyValue &keyval)
593
{
594
	QString id(section.getName() + Cst::sep + keyval.getKey());
595
	//INI key as it would be given in the file, i. e. with the parameters in place instead of the Selector's %:
596
	const QString regex_selector("^" + section.getName() + Cst::sep + R"(([\w\.]+)()" + Cst::sep + R"()(\w+?)([0-9]*$))");
597
598
599
	const QRegularExpression rex(regex_selector);
	const QRegularExpressionMatch matches = rex.match(id);

600
	if (matches.captured(0) == id) { //it could be from a selector with template children
601
602
603
604
605
606
		static const size_t idx_parameter = 1;
		static const size_t idx_keyname = 3;
		static const size_t idx_optional_number = 4;
		const QString parameter(matches.captured(idx_parameter));
		const QString key_name(matches.captured(idx_keyname));
		const QString number(matches.captured(idx_optional_number));
607
		//this would be the ID given in an XML, i. e. with a "%" staing for a parameter:
608
		const QString gui_id = section.getName() + Cst::sep + "%" + Cst::sep + key_name + (number.isEmpty()? "" : "#");
609

610
		//try to find Selector:
Michael Reisecker's avatar
Michael Reisecker committed
611
		QList<Selector *> selector_list = parent->findChildren<Selector *>(Atomic::getQtKey(gui_id));
612
		for (int ii = 0; ii < selector_list.size(); ++ii)
613
			selector_list.at(ii)->setProperty("ini_value", parameter); //cf. notes in prepareReplicator
614
		//now all the right child widgets should exist and we can try to find again:
615
		const QString key_id = section.getName() + Cst::sep + keyval.getKey(); //the one we were originally looking for
616

Michael Reisecker's avatar
Michael Reisecker committed
617
		return parent->findChildren<QWidget *>(Atomic::getQtKey(key_id));
618
	}
619
	return QWidgetList();
620
621
}

622
623
624
625
626
627
628
629
630
631
/**
 * @brief Find a Replicator in our GUI that could handle a given INI key.
 * @details This function looks for Replicators handling keys like "STATION#". If one is found,
 * it requests the Replicator to create a new panel for the key which will then be available
 * to the parent function that is currently looking for a suitable panel for the INI key.
 * @param[in] parent The parent panel or window to search.
 * @param[in] section Section to find.
 * @param[in] keyval Key/value pair to find.
 * @return A list of panels for the INI key including the possibly newly created ones.
 */
632
QWidgetList MainWindow::prepareReplicator(QWidget *parent, const Section &section, const KeyValue &keyval)
633
634
{
	QString id(section.getName() + Cst::sep + keyval.getKey());
635
	//the key how it would look in an INI file:
636
	const QString regex_selector("^" + section.getName() + Cst::sep +
637
	    R"(([\w\.]+)" + Cst::sep + R"()*(\w*?)(?=\d)(\d*)$)");
638
639
640
	const QRegularExpression rex(regex_selector);
	const QRegularExpressionMatch matches = rex.match(id);

641
642
643
644
645
646
647
648
649
650
651
	if (matches.captured(0) == id) { //it's from a replicator with template children
		/*
		 * If we arrive here, we try to find the panel for an INI key that could belong
		 * to the child of a Replicator, e. g. "INPUT::STATION1" or "FILTERS::TA::FILTER1".
		 * We extract the name the Replicator would have (number to "#") and try finding it.
		 */
		static const size_t idx_parameter = 1;
		static const size_t idx_key = 2;
		static const size_t idx_number = 3;
		QString parameter(matches.captured(idx_parameter)); //has trailing "::" if existent
		const QString key(matches.captured(idx_key));
652
		const QString number(matches.captured(idx_number));
653
		//the key how it would look in an XML:
654
655
656
657
658
659
660
661
662
663
664
		QString gui_id = section.getName() + Cst::sep + parameter + key + "#"; //Replicator's name

		/*
		 * A replicator can't normally be accessed via INI keys, because there is no
		 * standalone XML code for it. It always occurs together with child panels,
		 * and those are the ones that will be sought by the INI parser to set values.
		 * Therefore we can use the "ini_value" property listener for a Replicator to
		 * tell it to replicate its panel, thus creating the necessary child panels.
		 */
		QList<Replicator *> replicator_list = parent-> //try to find replicator:
		    findChildren<Replicator *>(Atomic::getQtKey(gui_id));
665
666
		for (int ii = 0; ii < replicator_list.count(); ++ii)
			replicator_list.at(ii)->setProperty("ini_value", number);
667
668
		//now all the right child panels should exist and we can try to find again:
		const QString key_id(section.getName() + Cst::sep + keyval.getKey()); //the one we were originally looking for
Michael Reisecker's avatar
Michael Reisecker committed
669
		return parent->findChildren<QWidget *>(Atomic::getQtKey(key_id));
670
	} //endif has match
671
672

	return QWidgetList(); //no suitable Replicator found
673
674
}

Mathias Bavay's avatar
Mathias Bavay committed
675
//This hack is also duplicated in IniFolderView.cc
676
677
678
679
680
681
inline QIcon getIcon(const QString& icon_name)
{
#ifdef Q_OS_WIN
	return QIcon(":/icons/flat-bw/svg/"+icon_name+".svg");
#endif
#ifdef Q_OS_MAC
Mathias Bavay's avatar
Mathias Bavay committed
682
	return QIcon(":/icons/elementary/svg/"+icon_name+".svg");
683
684
#endif
#if !defined Q_OS_WIN && !defined Q_OS_WIN
Mathias Bavay's avatar
Mathias Bavay committed
685
	//return QIcon(":/icons/flat-bw/svg/"+icon_name+".svg");
686
	return QIcon::fromTheme(icon_name, QIcon(":/icons/flat-bw/svg/"+icon_name+".svg"));
687
688
689
#endif
}

690
691
692
/**
 * @brief Build the main window's menu items.
 */
693
void MainWindow::createMenu()
694
{
695
	/* File menu */
696
	QMenu *menu_file = this->menuBar()->addMenu(tr("&File"));
697
	file_open_ini_ = new QAction(getIcon("document-open"), tr("&Open INI file..."), menu_file);
698
	menu_file->addAction(file_open_ini_); //note that this does not take ownership
699
	connect(file_open_ini_, &QAction::triggered, this, [=]{ toolbarClick("open_ini"); });
700
	file_open_ini_->setShortcut(QKeySequence::Open);
701
	file_save_ini_ = new QAction(getIcon("document-save"), tr("&Save INI file"), menu_file);
702
	file_save_ini_->setShortcut(QKeySequence::Save);
703
704
705
	menu_file->addAction(file_save_ini_);
	file_save_ini_->setEnabled(false); //enable after an INI is opened
	connect(file_save_ini_, &QAction::triggered, this, [=]{ toolbarClick("save_ini"); });
706
	file_save_ini_as_ = new QAction(getIcon("document-save-as"), tr("Save INI file &as..."), menu_file);
707
	file_save_ini_as_->setShortcut(QKeySequence::SaveAs);
708
709
710
711
	menu_file->addAction(file_save_ini_as_);
	file_save_ini_as_->setEnabled(false);
	connect(file_save_ini_as_, &QAction::triggered, this, [=]{ toolbarClick("save_ini_as"); });
	menu_file->addSeparator();
712
	auto *file_quit = new QAction(getIcon("application-exit"), tr("&Exit"), menu_file);
713
	file_quit->setShortcut(QKeySequence::Quit);
Mathias Bavay's avatar
Mathias Bavay committed
714
	file_quit->setMenuRole(QAction::QuitRole);
715
	menu_file->addAction(file_quit);
716
	connect(file_quit, &QAction::triggered, this, &MainWindow::quitProgram);
717

718
719
	/* GUI menu */
	QMenu *menu_gui = this->menuBar()->addMenu(tr("&GUI"));
720
	gui_reset_ = new QAction(getIcon("document-revert"), tr("&Reset GUI to default values"), menu_gui);
721
722
723
724
	menu_gui->addAction(gui_reset_);
	gui_reset_->setEnabled(false);
	gui_reset_->setShortcut(Qt::CTRL + Qt::Key_Backspace);
	connect(gui_reset_, &QAction::triggered, this, [=]{ toolbarClick("reset_gui"); });
725
	gui_clear_ = new QAction(getIcon("edit-delete"), tr("&Clear GUI"), menu_gui);
726
727
	menu_gui->addAction(gui_clear_);
	gui_clear_->setEnabled(false);
728
	gui_clear_->setShortcut( Qt::CTRL + Qt::Key_Backspace );
729
	connect(gui_clear_, &QAction::triggered, this, [=]{ toolbarClick("clear_gui"); });
730
	menu_gui->addSeparator();
731
732
733
734
	gui_close_all_ = new QAction(getIcon("window-close"), tr("Close all content"), menu_gui);
	menu_gui->addAction(gui_close_all_);
	connect(gui_close_all_, &QAction::triggered, this, &MainWindow::resetGui);
	gui_close_all_->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_Backspace);
735

736
	/* View menu */
737
	QMenu *menu_view = this->menuBar()->addMenu(tr("&View"));
738
	auto *view_preview = new QAction(getIcon("document-print-preview"), tr("P&review"), menu_view);
739
	menu_view->addAction(view_preview);
740
	view_preview->setShortcut(QKeySequence::Print);
741
	connect(view_preview, &QAction::triggered, this, &MainWindow::viewPreview);
742
	auto *view_log = new QAction(getIcon("utilities-system-monitor"), tr("&Log"), menu_view);
743
	menu_view->addAction(view_log);
744
	connect(view_log, &QAction::triggered, this, &MainWindow::viewLogger);
745
	view_log->setShortcut(Qt::CTRL + Qt::Key_L);
746
	menu_view->addSeparator();
747
	auto *view_settings = new QAction(getIcon("preferences-system"), tr("&Settings"), menu_view);
748
	view_settings->setShortcut(Qt::Key_F3);
Mathias Bavay's avatar
Mathias Bavay committed
749
	view_settings->setMenuRole(QAction::PreferencesRole);
750
	menu_view->addAction(view_settings);
751
	connect(view_settings, &QAction::triggered, this, &MainWindow::viewSettings);
752
753
754
755
756
	view_close_settings_ = new QAction(tr("Close settings"), menu_view);
	view_close_settings_->setEnabled(false);
	view_close_settings_->setShortcut(Qt::CTRL + Qt::Key_F3);
	menu_view->addAction(view_close_settings_);
	connect(view_close_settings_, &QAction::triggered, this, &MainWindow::closeSettings);
Michael Reisecker's avatar
Michael Reisecker committed
757

758
759
	/* Window menu */
	QMenu *menu_window = this->menuBar()->addMenu(tr("&Window"));
760
	auto *window_show_workflow = new QAction(tr("Show wor&kflow"), menu_window);
761
762
	menu_window->addAction(window_show_workflow);
	connect(window_show_workflow, &QAction::triggered, this, &MainWindow::showWorkflow);
763
	window_show_workflow->setShortcut(Qt::CTRL + Qt::Key_K);
764
	auto *window_hide_workflow = new QAction(tr("&Hide workflow"), menu_window);
765
766
	menu_window->addAction(window_hide_workflow);
	connect(window_hide_workflow, &QAction::triggered, this, &MainWindow::hideWorkflow);
767
	window_hide_workflow->setShortcut(Qt::CTRL + Qt::Key_H);
768

Michael Reisecker's avatar
Michael Reisecker committed
769
770
771
#ifdef DEBUG
	/* Debug menu */
	QMenu *menu_debug = this->menuBar()->addMenu("&Debug");
772
	auto *debug_run = new QAction("&Run action", menu_debug); //to run arbitrary code with a click
Michael Reisecker's avatar
Michael Reisecker committed
773
	menu_debug->addAction(debug_run);
774
	connect(debug_run, &QAction::triggered, this, &MainWindow::z_onDebugRunClick);
Michael Reisecker's avatar
Michael Reisecker committed
775
776
#endif //def DEBUG

Michael Reisecker's avatar
Michael Reisecker committed
777
	/* Help menu */
Michael Reisecker's avatar
Michael Reisecker committed
778
	auto *menu_help_main = new QMenuBar(this->menuBar());
779
	QMenu *menu_help = menu_help_main->addMenu(tr("&Help"));
780
	auto *help = new QAction(getIcon("help-contents"), tr("&Help"), menu_help_main);
781
	help->setShortcut(QKeySequence::HelpContents);
782
783
	menu_help->addAction(help);
	connect(help, &QAction::triggered, this, &MainWindow::loadHelp);
784
	auto *help_about = new QAction(getIcon("help-about"), tr("&About"), menu_help_main);
Mathias Bavay's avatar
Mathias Bavay committed
785
	help_about->setMenuRole(QAction::AboutRole);
786
787
	menu_help->addAction(help_about);
	connect(help_about, &QAction::triggered, this, &MainWindow::helpAbout);
788
	help_about->setShortcut(Qt::Key_F2);
789
	menu_help->addSeparator();
790
	auto *help_dev = new QAction(tr("&Developer's help"), menu_help_main);
791
792
793
	help_dev->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_F1));
	menu_help->addAction(help_dev);
	connect(help_dev, &QAction::triggered, this, &MainWindow::loadHelpDev);
794
	auto *help_bugreport = new QAction(tr("File &bug report..."), menu_help_main);
795
796
	menu_help->addAction(help_bugreport);
	connect(help_bugreport, &QAction::triggered,
797
	    []{ QDesktopServices::openUrl(QUrl("https://models.slf.ch/p/inishell-ng/issues/")); });
798

799
	this->menuBar()->setCornerWidget(menu_help_main); //push help menu to the right
800
801
}

802
803
804
/**
 * @brief Create the main window's toolbar.
 */
805
void MainWindow::createToolbar()
806
807
{
	/* toolbar */
808
	toolbar_ = new QToolBar("Shortcuts toolbar");
809
810
811
812
	toolbar_->setContextMenuPolicy(Qt::CustomContextMenu);
	createToolbarContextMenu();
	connect(toolbar_, &QToolBar::customContextMenuRequested, this, &MainWindow::onToolbarContextMenuRequest);
	toolbar_->setMovable(getSetting("user::appearance::fix_toolbar_pos", "value") == "FALSE");
813
	toolbar_->setFloatable(false);
814

815
816
817
818
819
820
821
	bool toolbar_success;
	Qt::ToolBarArea toolbar_area = static_cast<Qt::ToolBarArea>( //restore last toolbar position
	    getSetting("auto::position::toolbar", "position").toInt(&toolbar_success));
	if (!toolbar_success)
		toolbar_area = Qt::ToolBarArea::TopToolBarArea;
	this->addToolBar(toolbar_area, toolbar_);

822
	/* user interaction buttons */
823
	toolbar_->setIconSize(QSize(32, 32));
824
	toolbar_open_ini_ = toolbar_->addAction(getIcon("document-open"), tr("Open INI file"));
825
826
827
	connect(toolbar_open_ini_, &QAction::triggered, this, [=]{ toolbarClick("open_ini"); });
	toolbar_open_ini_->setEnabled(false); //toolbar entry
	file_open_ini_->setEnabled(false); //menu entry
828
	toolbar_->addSeparator();
829
	toolbar_save_ini_ = toolbar_->addAction(getIcon("document-save"), tr("Save INI"));
830
	toolbar_save_ini_->setEnabled(false); //enable when an INI is open
831
	connect(toolbar_save_ini_, &QAction::triggered, this, [=]{ toolbarClick("save_ini"); });
832
	toolbar_save_ini_as_ = toolbar_->addAction(getIcon("document-save-as"), tr("Save INI file as"));
833
	toolbar_save_ini_as_->setEnabled(false);
834
	connect(toolbar_save_ini_as_, &QAction::triggered, this, [=]{ toolbarClick("save_ini_as"); });