1 /**
2 * This file is a part of Luminance HDR package.
3 * ----------------------------------------------------------------------
4 * Copyright (C) 2006,2007 Giuseppe Rota
5 * Copytight (C) 2011 Davide Anastasia
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * ----------------------------------------------------------------------
21 *
22 * Original Work
23 * @author Giuseppe Rota <grota@users.sourceforge.net>
24 * Improvements, bugfixing
25 * @author Franco Comida <fcomida@users.sourceforge.net>
26 * Implement class deriving from QSettings (override Singleton pattern with
27 * QSettings functionalities)
28 * @author Davide Anastasia <davideanastasia@users.sourceforge.net>
29 *
30 */
31
32 #include <QtGlobal>
33 #include <QApplication>
34 #include <QDate>
35 #include <QDebug>
36 #include <QDir>
37 #include <QFile>
38 #include <QLocale>
39 #include <QMessageBox>
40 #include <QString>
41 #include <QStyleFactory>
42
43 #include "Common/LuminanceOptions.h"
44 #include "Common/config.h"
45
46 #if defined(Q_OS_WIN)
47 const QString LuminanceOptions::LUMINANCE_HDR_HOME_FOLDER = "LuminanceHDR";
48 #elif defined(Q_OS_MACOS)
49 const QString LuminanceOptions::LUMINANCE_HDR_HOME_FOLDER =
50 ".config/.LuminanceHDR";
51 #else
52 const QString LuminanceOptions::LUMINANCE_HDR_HOME_FOLDER =
53 QStringLiteral(".config/luminance-hdr");
54 #endif
55
56 const static QString MAC_THEME = QStringLiteral("Macintosh");
57
58 bool LuminanceOptions::isCurrentPortableMode = false;
59
checkHomeFolder()60 void LuminanceOptions::checkHomeFolder() {
61 if (isCurrentPortableMode) {
62 return;
63 }
64
65 QDir dir(QDir::homePath());
66 if (!dir.exists(LUMINANCE_HDR_HOME_FOLDER)) {
67 dir.mkdir(LUMINANCE_HDR_HOME_FOLDER);
68 }
69 }
70
LuminanceOptions()71 LuminanceOptions::LuminanceOptions() : QObject() { initSettings(); }
72
~LuminanceOptions()73 LuminanceOptions::~LuminanceOptions() { delete m_settingHolder; }
74
conditionallyDoUpgrade()75 void LuminanceOptions::conditionallyDoUpgrade() {
76 LuminanceOptions options;
77 int currentVersion = options.value(KEY_OPTIONS_VERSION, 0).toInt();
78
79 // check if update needed
80 if (currentVersion < LUMINANCEVERSION_NUM) {
81 if (currentVersion < 2030099) {
82 options.setRawWhiteBalanceMethod(1);
83 #ifdef DEMOSAICING_GPL3
84 options.setRawUserQuality(10); // AMaZE
85 #endif
86 }
87 if (currentVersion < 2040099) {
88 options.setAlignImageStackOptions(
89 sanitizeAISparams(options.getAlignImageStackOptions()));
90 }
91
92 options.setValue(KEY_WARNING_WOW64,
93 0); // remind the user again with a new version
94 options.setValue(KEY_OPTIONS_VERSION, LUMINANCEVERSION_NUM);
95 }
96 }
97
doShowWindowsOnWindows64Message()98 bool LuminanceOptions::doShowWindowsOnWindows64Message() {
99 int currentTimes = value(KEY_WARNING_WOW64, 0).toInt() + 1;
100 bool result = currentTimes <= 3;
101 if (result) setValue(KEY_WARNING_WOW64, currentTimes);
102
103 return result;
104 }
105
setPortableMode(bool isPortable)106 void LuminanceOptions::setPortableMode(bool isPortable) {
107 if (LuminanceOptions::isCurrentPortableMode != isPortable) {
108 QSettings *oldSettings = m_settingHolder;
109 LuminanceOptions::isCurrentPortableMode = isPortable;
110 initSettings();
111 foreach (const QString &key, oldSettings->allKeys()) {
112 m_settingHolder->setValue(key, oldSettings->value(key));
113 }
114 delete oldSettings;
115
116 #ifdef Q_OS_MACOS
117 QString settingsDirName =
118 QGuiApplication::applicationDirPath() + QStringLiteral("/../../../.LuminanceHDR");
119 QFile settingsDir(settingsDirName);
120 if (!settingsDir.exists()) {
121 QDir settingsPath(QGuiApplication::applicationDirPath() + QStringLiteral("/../../../"));
122 settingsPath.mkpath(settingsDirName);
123 }
124 #endif
125 QString filePath =
126 #ifdef Q_OS_MACOS
127 QGuiApplication::applicationDirPath() + QStringLiteral("/../../../.LuminanceHDR/PortableMode.txt");
128 #else
129 QGuiApplication::applicationDirPath() + QStringLiteral("/PortableMode.txt");
130 #endif
131 QFile file(filePath);
132 if (isPortable && !file.exists()) {
133 if (file.open(QIODevice::WriteOnly)) file.close();
134 } else if (!isPortable && file.exists()) {
135 file.remove();
136 }
137 }
138 }
139
checkForUpdate()140 bool LuminanceOptions::checkForUpdate() {
141 QDate date = value(KEY_UPDATE_CHECKED_ON, QDate(1, 1, 1)).toDate();
142 return date < QDate::currentDate();
143 }
144
setUpdateChecked()145 void LuminanceOptions::setUpdateChecked() {
146 setValue(KEY_UPDATE_CHECKED_ON, QDate::currentDate());
147 }
148
initSettings()149 void LuminanceOptions::initSettings() {
150 if (LuminanceOptions::isCurrentPortableMode) {
151 QString iniFile =
152 #ifdef Q_OS_MACOS
153 QGuiApplication::applicationDirPath() + QStringLiteral("/../../../.LuminanceHDR/settings.ini");
154 iniFile = QDir::cleanPath(iniFile);
155 #else
156 QGuiApplication::applicationDirPath() + QStringLiteral("/settings.ini");
157 #endif
158 m_settingHolder =
159 new QSettings( iniFile, QSettings::IniFormat);
160 }
161 else {
162 m_settingHolder = new QSettings();
163 }
164 }
165
setValue(const QString & key,const QVariant & value)166 void LuminanceOptions::setValue(const QString &key, const QVariant &value) {
167 m_settingHolder->setValue(key, value);
168 }
169
value(const QString & key,const QVariant & defaultValue) const170 QVariant LuminanceOptions::value(const QString &key,
171 const QVariant &defaultValue) const {
172 return m_settingHolder->value(key, defaultValue);
173 }
174
getDatabaseFileName()175 QString LuminanceOptions::getDatabaseFileName() {
176 QString filename;
177 if (LuminanceOptions::isCurrentPortableMode) {
178 filename = QGuiApplication::applicationDirPath();
179 #ifdef Q_OS_MACOS
180 filename += QLatin1String("/../../../.LuminanceHDR");
181 filename = QDir::cleanPath(filename);
182 #endif
183 } else {
184 filename = QDir(QDir::homePath()).absolutePath() + "/" +
185 LUMINANCE_HDR_HOME_FOLDER;
186 }
187 filename += QLatin1String("/saved_parameters.db");
188
189 return filename;
190 }
191
getFftwWisdomFileName()192 QString LuminanceOptions::getFftwWisdomFileName() {
193 QString filename;
194 if (LuminanceOptions::isCurrentPortableMode) {
195 filename = QGuiApplication::applicationDirPath();
196 } else {
197 filename = QDir(QDir::homePath()).absolutePath() + "/" +
198 LUMINANCE_HDR_HOME_FOLDER;
199 }
200 filename += QLatin1String("/lhdrwisdom.fftw");
201
202 return filename;
203 }
204
getGuiTheme()205 QString LuminanceOptions::getGuiTheme() {
206 #ifdef Q_OS_MACOS
207 return m_settingHolder->value(KEY_GUI_THEME, MAC_THEME).toString();
208 #else
209 return m_settingHolder->value(KEY_GUI_THEME, "Fusion").toString();
210 #endif
211 }
212
setGuiTheme(const QString & s)213 void LuminanceOptions::setGuiTheme(const QString &s) {
214 if (s == MAC_THEME) {
215 setGuiDarkMode(false);
216 }
217
218 m_settingHolder->setValue(KEY_GUI_THEME, s);
219 }
220
isGuiDarkMode() const221 bool LuminanceOptions::isGuiDarkMode() const {
222 return m_settingHolder->value(KEY_GUI_DARKMODE, false).toBool();
223 }
224
setGuiDarkMode(bool b)225 void LuminanceOptions::setGuiDarkMode(bool b) {
226 m_settingHolder->setValue(KEY_GUI_DARKMODE, b);
227 }
228
applyTheme(bool)229 void LuminanceOptions::applyTheme(bool /*init*/) {
230 QString theme = LuminanceOptions().getGuiTheme();
231 if (theme.compare(QLatin1String("Macintosh")) != 0 && isGuiDarkMode()) {
232 // QPalette darkPalette;
233 QPalette darkPalette = QApplication::palette();
234
235 darkPalette.setColor(QPalette::Window, QColor(53, 53, 53));
236 darkPalette.setColor(QPalette::WindowText, Qt::white);
237 darkPalette.setColor(QPalette::Disabled, QPalette::WindowText,
238 Qt::lightGray);
239 darkPalette.setColor(QPalette::Base, QColor(25, 25, 25));
240 darkPalette.setColor(QPalette::AlternateBase, QColor(53, 53, 53));
241 darkPalette.setColor(QPalette::ToolTipBase, Qt::white);
242 darkPalette.setColor(QPalette::ToolTipText, Qt::black);
243 darkPalette.setColor(QPalette::Text, Qt::white);
244 darkPalette.setColor(QPalette::Disabled, QPalette::Text, Qt::lightGray);
245 darkPalette.setColor(QPalette::Button, QColor(53, 53, 53));
246 darkPalette.setColor(QPalette::ButtonText, Qt::white);
247 darkPalette.setColor(QPalette::Disabled, QPalette::ButtonText,
248 Qt::lightGray);
249 darkPalette.setColor(QPalette::BrightText, Qt::red);
250 // darkPalette.setColor(QPalette::Link, QColor(42, 130, 218));
251 darkPalette.setColor(QPalette::Link, QColor(0, 120, 220));
252
253 // darkPalette.setColor(QPalette::Highlight, QColor(42, 130, 218));
254 darkPalette.setColor(QPalette::Highlight, QColor(0, 120, 220));
255 darkPalette.setColor(QPalette::HighlightedText, Qt::black);
256
257 QApplication::setPalette(darkPalette);
258
259 // QApplication::setStyleSheet("QToolTip { color: #ffffff;
260 // background-color:
261 // #2a82da; border: 1px solid white; }");
262 } else {
263 QApplication::setPalette(QApplication::palette());
264 }
265
266 QApplication::setStyle(
267 QStyleFactory::create(LuminanceOptions().getGuiTheme()));
268 }
269
270 // write system default language the first time around (discard "_country")
getGuiLang()271 QString LuminanceOptions::getGuiLang() {
272 return m_settingHolder
273 ->value(KEY_GUI_LANG, QLocale::system().name().left(2))
274 .toString();
275 }
276
setGuiLang(const QString & s)277 void LuminanceOptions::setGuiLang(const QString &s) {
278 m_settingHolder->setValue(KEY_GUI_LANG, s);
279 }
280
isRawFourColorRGB() const281 bool LuminanceOptions::isRawFourColorRGB() const {
282 return m_settingHolder->value(KEY_FOUR_COLOR_RGB, false).toBool();
283 }
284
setRawFourColorRGB(bool b)285 void LuminanceOptions::setRawFourColorRGB(bool b) {
286 m_settingHolder->setValue(KEY_FOUR_COLOR_RGB, b);
287 }
288
isRawDoNotUseFujiRotate() const289 bool LuminanceOptions::isRawDoNotUseFujiRotate() const {
290 return m_settingHolder->value(KEY_DO_NOT_USE_FUJI_ROTATE, false).toBool();
291 }
292
setRawDoNotUseFujiRotate(bool b)293 void LuminanceOptions::setRawDoNotUseFujiRotate(bool b) {
294 m_settingHolder->setValue(KEY_DO_NOT_USE_FUJI_ROTATE, b);
295 }
296
getRawAber0() const297 double LuminanceOptions::getRawAber0() const {
298 return m_settingHolder->value(KEY_ABER_0, 1.0).toDouble();
299 }
300
setRawAber0(double v)301 void LuminanceOptions::setRawAber0(double v) {
302 m_settingHolder->setValue(KEY_ABER_0, v);
303 }
304
getRawAber1() const305 double LuminanceOptions::getRawAber1() const {
306 return m_settingHolder->value(KEY_ABER_1, 1.0).toDouble();
307 }
308
setRawAber1(double v)309 void LuminanceOptions::setRawAber1(double v) {
310 m_settingHolder->setValue(KEY_ABER_1, v);
311 }
312
getRawAber2() const313 double LuminanceOptions::getRawAber2() const {
314 return m_settingHolder->value(KEY_ABER_2, 1.0).toDouble();
315 }
316
setRawAber2(double v)317 void LuminanceOptions::setRawAber2(double v) {
318 m_settingHolder->setValue(KEY_ABER_2, v);
319 }
320
getRawAber3() const321 double LuminanceOptions::getRawAber3() const {
322 return m_settingHolder->value(KEY_ABER_3, 1.0).toDouble();
323 }
324
setRawAber3(double v)325 void LuminanceOptions::setRawAber3(double v) {
326 m_settingHolder->setValue(KEY_ABER_3, v);
327 }
328
getRawGamm0() const329 double LuminanceOptions::getRawGamm0() const {
330 return m_settingHolder->value(KEY_GAMM_0, 1.0 / 2.4).toDouble();
331 }
332
setRawGamm0(double v)333 void LuminanceOptions::setRawGamm0(double v) {
334 m_settingHolder->setValue(KEY_GAMM_0, v);
335 }
336
getRawGamm1() const337 double LuminanceOptions::getRawGamm1() const {
338 return m_settingHolder->value(KEY_GAMM_1, 12.92).toDouble();
339 }
340
setRawGamm1(double v)341 void LuminanceOptions::setRawGamm1(double v) {
342 m_settingHolder->setValue(KEY_GAMM_1, v);
343 }
344
getRawTemperatureKelvin() const345 int LuminanceOptions::getRawTemperatureKelvin() const {
346 return m_settingHolder->value(KEY_TK, 6500).toInt();
347 }
348
setRawTemperatureKelvin(int v)349 void LuminanceOptions::setRawTemperatureKelvin(int v) {
350 m_settingHolder->setValue(KEY_TK, v);
351 }
352
getRawGreen() const353 float LuminanceOptions::getRawGreen() const {
354 return m_settingHolder->value(KEY_GREEN, 1.0f).toFloat();
355 }
356
setRawGreen(float v)357 void LuminanceOptions::setRawGreen(float v) {
358 m_settingHolder->setValue(KEY_GREEN, v);
359 }
360
getRawUserMul0() const361 float LuminanceOptions::getRawUserMul0() const {
362 return m_settingHolder->value(KEY_USER_MUL_0, 1.0f).toFloat();
363 }
364
setRawUserMul0(float v)365 void LuminanceOptions::setRawUserMul0(float v) {
366 m_settingHolder->setValue(KEY_USER_MUL_0, v);
367 }
368
getRawUserMul1() const369 float LuminanceOptions::getRawUserMul1() const {
370 return m_settingHolder->value(KEY_USER_MUL_1, 1.0f).toFloat();
371 }
372
setRawUserMul1(float v)373 void LuminanceOptions::setRawUserMul1(float v) {
374 m_settingHolder->setValue(KEY_USER_MUL_1, v);
375 }
376
getRawUserMul2() const377 float LuminanceOptions::getRawUserMul2() const {
378 return m_settingHolder->value(KEY_USER_MUL_2, 1.0f).toFloat();
379 }
380
setRawUserMul2(float v)381 void LuminanceOptions::setRawUserMul2(float v) {
382 m_settingHolder->setValue(KEY_USER_MUL_2, v);
383 }
384
getRawUserMul3() const385 float LuminanceOptions::getRawUserMul3() const {
386 return m_settingHolder->value(KEY_USER_MUL_3, 1.0f).toFloat();
387 }
388
setRawUserMul3(float v)389 void LuminanceOptions::setRawUserMul3(float v) {
390 m_settingHolder->setValue(KEY_USER_MUL_3, v);
391 }
392
isRawAutoBrightness() const393 bool LuminanceOptions::isRawAutoBrightness() const {
394 return m_settingHolder->value(KEY_AUTO_BRIGHT, false).toBool();
395 }
396
setRawAutoBrightness(bool b)397 void LuminanceOptions::setRawAutoBrightness(bool b) {
398 m_settingHolder->setValue(KEY_AUTO_BRIGHT, b);
399 }
400
getRawBrightness() const401 float LuminanceOptions::getRawBrightness() const {
402 return m_settingHolder->value(KEY_BRIGHTNESS, 1.0f).toFloat();
403 }
404
setRawBrightness(float f)405 void LuminanceOptions::setRawBrightness(float f) {
406 m_settingHolder->setValue(KEY_BRIGHTNESS, f);
407 }
408
getRawNoiseReductionThreshold() const409 float LuminanceOptions::getRawNoiseReductionThreshold() const {
410 return m_settingHolder->value(KEY_THRESHOLD, 100.0f).toFloat();
411 }
412
setRawNoiseReductionThreshold(float v)413 void LuminanceOptions::setRawNoiseReductionThreshold(float v) {
414 m_settingHolder->setValue(KEY_THRESHOLD, v);
415 }
416
getRawHalfSize() const417 int LuminanceOptions::getRawHalfSize() const {
418 return m_settingHolder->value(KEY_HALF_SIZE, 0).toInt();
419 }
420
setRawHalfSize(int v)421 void LuminanceOptions::setRawHalfSize(int v) {
422 m_settingHolder->setValue(KEY_HALF_SIZE, v);
423 }
424
getRawWhiteBalanceMethod() const425 int LuminanceOptions::getRawWhiteBalanceMethod() const {
426 return m_settingHolder->value(KEY_WB_METHOD, 1).toInt();
427 }
428
setRawWhiteBalanceMethod(int v)429 void LuminanceOptions::setRawWhiteBalanceMethod(int v) {
430 m_settingHolder->setValue(KEY_WB_METHOD, v);
431 }
432
getRawOutputColor() const433 int LuminanceOptions::getRawOutputColor() const {
434 return m_settingHolder->value(KEY_OUTPUT_COLOR, 1).toInt();
435 }
436
437 // double check those!
getRawOutputProfile() const438 QString LuminanceOptions::getRawOutputProfile() const {
439 // QFile::encodeName(this->value(KEY_OUTPUT_PROFILE).toString()).constData();
440 return QFile::encodeName(
441 m_settingHolder->value(KEY_OUTPUT_PROFILE).toString());
442 }
443
setRawOutputProfile(const QString & v)444 void LuminanceOptions::setRawOutputProfile(const QString &v) {
445 m_settingHolder->setValue(KEY_OUTPUT_PROFILE, v);
446 }
447
getRawCameraProfile() const448 QString LuminanceOptions::getRawCameraProfile() const {
449 // QFile::encodeName(this->value(KEY_CAMERA_PROFILE).toString()).constData();
450 return QFile::encodeName(
451 m_settingHolder->value(KEY_CAMERA_PROFILE).toString());
452 }
453
setRawCameraProfile(const QString & v)454 void LuminanceOptions::setRawCameraProfile(const QString &v) {
455 m_settingHolder->setValue(KEY_CAMERA_PROFILE, v);
456 }
457
getRawUserFlip() const458 int LuminanceOptions::getRawUserFlip() const {
459 return m_settingHolder->value(KEY_USER_FLIP, 0).toInt();
460 }
461
462 #ifdef DEMOSAICING_GPL3
463 #define USER_QUALITY 10 // using AMaZE interpolation
464 #elif DEMOSAICING_GPL2
465 #define USER_QUALITY 5 // using AHDv2
466 #else
467 #define USER_QUALITY 3 // using AHD
468 #endif
469
getRawUserQuality() const470 int LuminanceOptions::getRawUserQuality() const {
471 return m_settingHolder->value(KEY_USER_QUAL, USER_QUALITY).toInt();
472 }
473
setRawUserQuality(int v)474 void LuminanceOptions::setRawUserQuality(int v) {
475 m_settingHolder->setValue(KEY_USER_QUAL, v);
476 }
477
getRawUserSaturation() const478 int LuminanceOptions::getRawUserSaturation() const {
479 return m_settingHolder->value(KEY_USER_SAT, 20000).toInt();
480 }
481
setRawUserSaturation(int v)482 void LuminanceOptions::setRawUserSaturation(int v) {
483 m_settingHolder->setValue(KEY_USER_SAT, v);
484 }
485
getRawMedPasses() const486 int LuminanceOptions::getRawMedPasses() const {
487 return m_settingHolder->value(KEY_MED_PASSES, 0).toInt();
488 }
489
setRawMedPasses(int v)490 void LuminanceOptions::setRawMedPasses(int v) {
491 m_settingHolder->setValue(KEY_MED_PASSES, v);
492 }
493
getRawHighlightsMode() const494 int LuminanceOptions::getRawHighlightsMode() const {
495 return m_settingHolder->value(KEY_HIGHLIGHTS, 0).toInt();
496 }
497
setRawHighlightsMode(int v)498 void LuminanceOptions::setRawHighlightsMode(int v) {
499 m_settingHolder->setValue(KEY_HIGHLIGHTS, v);
500 }
501
getRawLevel() const502 int LuminanceOptions::getRawLevel() const {
503 return m_settingHolder->value(KEY_LEVEL, 0).toInt();
504 }
505
setRawLevel(int v)506 void LuminanceOptions::setRawLevel(int v) {
507 m_settingHolder->setValue(KEY_LEVEL, v);
508 }
509
getRawAutoBrightnessThreshold() const510 float LuminanceOptions::getRawAutoBrightnessThreshold() const {
511 return m_settingHolder->value(KEY_AUTO_BRIGHT_THR, 0.001f).toFloat();
512 }
513
setRawAutoBrightnessThreshold(float v)514 void LuminanceOptions::setRawAutoBrightnessThreshold(float v) {
515 m_settingHolder->setValue(KEY_AUTO_BRIGHT_THR, v);
516 }
517
getRawMaximumThreshold() const518 float LuminanceOptions::getRawMaximumThreshold() const {
519 return m_settingHolder->value(KEY_ADJUST_MAXIMUM_THR, 0.0f).toFloat();
520 }
521
setRawMaximumThreshold(float v)522 void LuminanceOptions::setRawMaximumThreshold(float v) {
523 m_settingHolder->setValue(KEY_ADJUST_MAXIMUM_THR, v);
524 }
525
isRawUseBlack() const526 bool LuminanceOptions::isRawUseBlack() const {
527 return m_settingHolder->value(KEY_USE_BLACK, false).toBool();
528 }
529
setRawUseBlack(bool b)530 void LuminanceOptions::setRawUseBlack(bool b) {
531 m_settingHolder->setValue(KEY_USE_BLACK, b);
532 }
533
getRawUserBlack() const534 int LuminanceOptions::getRawUserBlack() const {
535 return m_settingHolder->value(KEY_USER_BLACK, 0).toInt();
536 }
537
setRawUserBlack(int v)538 void LuminanceOptions::setRawUserBlack(int v) {
539 m_settingHolder->setValue(KEY_USER_BLACK, v);
540 }
541
isRawUseSaturation() const542 bool LuminanceOptions::isRawUseSaturation() const {
543 return m_settingHolder->value(KEY_USE_SAT, false).toBool();
544 }
545
setRawUseSaturation(bool b)546 void LuminanceOptions::setRawUseSaturation(bool b) {
547 m_settingHolder->setValue(KEY_USE_SAT, b);
548 }
549
isRawUseNoiseReduction() const550 bool LuminanceOptions::isRawUseNoiseReduction() const {
551 return m_settingHolder->value(KEY_USE_NOISE, true).toBool();
552 }
553
setRawUseNoiseReduction(bool b)554 void LuminanceOptions::setRawUseNoiseReduction(bool b) {
555 m_settingHolder->setValue(KEY_USE_NOISE, b);
556 }
557
isRawUseChromaAber() const558 bool LuminanceOptions::isRawUseChromaAber() const {
559 return m_settingHolder->value(KEY_USE_CHROMA, false).toBool();
560 }
561
setRawUseChromaAber(bool b)562 void LuminanceOptions::setRawUseChromaAber(bool b) {
563 m_settingHolder->setValue(KEY_USE_CHROMA, b);
564 }
565
getBatchHdrPathInput(const QString & defaultPath)566 QString LuminanceOptions::getBatchHdrPathInput(const QString &defaultPath) {
567 return m_settingHolder->value(KEY_BATCH_HDR_PATH_INPUT, defaultPath)
568 .toString();
569 }
570
setBatchHdrPathInput(const QString & qstr)571 void LuminanceOptions::setBatchHdrPathInput(const QString &qstr) {
572 m_settingHolder->setValue(KEY_BATCH_HDR_PATH_INPUT, qstr);
573 }
574
getBatchHdrPathOutput(const QString & defaultPath)575 QString LuminanceOptions::getBatchHdrPathOutput(const QString &defaultPath) {
576 return m_settingHolder->value(KEY_BATCH_HDR_PATH_OUTPUT, defaultPath)
577 .toString();
578 }
579
setBatchHdrPathOutput(const QString & qstr)580 void LuminanceOptions::setBatchHdrPathOutput(const QString &qstr) {
581 m_settingHolder->setValue(KEY_BATCH_HDR_PATH_OUTPUT, qstr);
582 }
583
getBatchTmPathHdrInput()584 QString LuminanceOptions::getBatchTmPathHdrInput() {
585 return m_settingHolder->value(KEY_BATCH_TM_PATH_INPUT, QDir::currentPath())
586 .toString();
587 }
588
setBatchTmPathHdrInput(const QString & s)589 void LuminanceOptions::setBatchTmPathHdrInput(const QString &s) {
590 m_settingHolder->setValue(KEY_BATCH_TM_PATH_INPUT, s);
591 }
592
getBatchTmPathTmoSettings()593 QString LuminanceOptions::getBatchTmPathTmoSettings() {
594 return m_settingHolder
595 ->value(KEY_BATCH_TM_PATH_TMO_SETTINGS, QDir::currentPath())
596 .toString();
597 }
598
setBatchTmPathTmoSettings(const QString & s)599 void LuminanceOptions::setBatchTmPathTmoSettings(const QString &s) {
600 m_settingHolder->setValue(KEY_BATCH_TM_PATH_TMO_SETTINGS, s);
601 }
602
getBatchTmPathLdrOutput()603 QString LuminanceOptions::getBatchTmPathLdrOutput() {
604 return m_settingHolder->value(KEY_BATCH_TM_PATH_OUTPUT, QDir::currentPath())
605 .toString();
606 }
607
setBatchTmPathLdrOutput(const QString & s)608 void LuminanceOptions::setBatchTmPathLdrOutput(const QString &s) {
609 m_settingHolder->setValue(KEY_BATCH_TM_PATH_OUTPUT, s);
610 }
611
getBatchTmNumThreads()612 int LuminanceOptions::getBatchTmNumThreads() {
613 return m_settingHolder->value(KEY_BATCH_TM_NUM_THREADS, 1).toInt();
614 }
615
setBatchTmNumThreads(int v)616 void LuminanceOptions::setBatchTmNumThreads(int v) {
617 m_settingHolder->setValue(KEY_BATCH_TM_NUM_THREADS, v);
618 }
619
620 namespace {
621 #ifdef QT_DEBUG
622 struct PrintTempDir {
PrintTempDir__anon83eab6bb0111::PrintTempDir623 explicit PrintTempDir(const QString &str) : str_(str) {}
624
~PrintTempDir__anon83eab6bb0111::PrintTempDir625 ~PrintTempDir() { qDebug() << "Temporary directory: " << str_; }
626
627 private:
628 const QString &str_;
629 };
630 #endif // QT_DEBUG
631 }
632
getTempDir()633 QString LuminanceOptions::getTempDir() {
634 QString os_temp_dir_name = QDir::temp().absolutePath();
635 QString temp_dir_name =
636 m_settingHolder
637 ->value(KEY_TEMP_RESULT_PATH, QDir::temp().absolutePath())
638 .toString();
639 #ifdef QT_DEBUG
640 PrintTempDir print_temp_dir(temp_dir_name);
641 #endif
642 if (temp_dir_name == os_temp_dir_name) {
643 // temporary directory is equal to the OS's
644 return temp_dir_name;
645 }
646
647 QDir temp_dir(temp_dir_name);
648 if (!temp_dir.exists()) {
649 // directory doesn't exist!
650 qDebug() << "Candidate temporary directory does not exist";
651 // reset to OS temporary directory;
652 temp_dir_name = os_temp_dir_name;
653 remove(KEY_TEMP_RESULT_PATH);
654 return temp_dir_name;
655 }
656
657 // directory exists...
658 // let's check whether I can create a file or not!
659 QFile file(temp_dir.filePath(QStringLiteral("test_write.txt")));
660 if (!file.open(QIODevice::ReadWrite)) {
661 // directory is not writtable
662 qDebug() << "Candidate temporary directory is not writtable";
663 // reset to OS temporary directory;
664 temp_dir_name = os_temp_dir_name;
665 remove(KEY_TEMP_RESULT_PATH);
666 // return temp_dir_name;
667 }
668
669 return temp_dir_name;
670 }
671
setTempDir(const QString & path)672 void LuminanceOptions::setTempDir(const QString &path) {
673 m_settingHolder->setValue(KEY_TEMP_RESULT_PATH, path);
674 }
675
getDefaultPathHdrIn()676 QString LuminanceOptions::getDefaultPathHdrIn() {
677 return m_settingHolder->value(KEY_RECENT_PATH_LOAD_HDR, QDir::currentPath())
678 .toString();
679 }
680
setDefaultPathHdrIn(const QString & path)681 void LuminanceOptions::setDefaultPathHdrIn(const QString &path) {
682 m_settingHolder->setValue(KEY_RECENT_PATH_LOAD_HDR, path);
683 }
684
getDefaultPathHdrOut()685 QString LuminanceOptions::getDefaultPathHdrOut() {
686 return m_settingHolder->value(KEY_RECENT_PATH_SAVE_HDR, QDir::currentPath())
687 .toString();
688 }
689
setDefaultPathHdrOut(const QString & path)690 void LuminanceOptions::setDefaultPathHdrOut(const QString &path) {
691 m_settingHolder->setValue(KEY_RECENT_PATH_SAVE_HDR, path);
692 }
693
getDefaultPathLdrIn()694 QString LuminanceOptions::getDefaultPathLdrIn() {
695 return m_settingHolder->value(KEY_RECENT_PATH_LOAD_LDR, QDir::currentPath())
696 .toString();
697 }
698
setDefaultPathLdrIn(const QString & path)699 void LuminanceOptions::setDefaultPathLdrIn(const QString &path) {
700 m_settingHolder->setValue(KEY_RECENT_PATH_LOAD_LDR, path);
701 }
702
getDefaultPathLdrOut()703 QString LuminanceOptions::getDefaultPathLdrOut() {
704 return m_settingHolder
705 ->value(KEY_RECENT_PATH_SAVE_LDR, getDefaultPathHdrOut())
706 .toString();
707 }
708
setDefaultPathLdrOut(const QString & path)709 void LuminanceOptions::setDefaultPathLdrOut(const QString &path) {
710 m_settingHolder->setValue(KEY_RECENT_PATH_SAVE_LDR, path);
711 }
712
isShowMissingEVsWarning()713 bool LuminanceOptions::isShowMissingEVsWarning() {
714 return m_settingHolder->value(KEY_WIZARD_SHOW_MISSING_EVS_WARNING, true)
715 .toBool();
716 }
717
setShowMissingEVsWarning(const bool b)718 void LuminanceOptions::setShowMissingEVsWarning(const bool b) {
719 m_settingHolder->setValue(KEY_WIZARD_SHOW_MISSING_EVS_WARNING, b);
720 }
721
getDefaultPathTmoSettings()722 QString LuminanceOptions::getDefaultPathTmoSettings() {
723 return m_settingHolder
724 ->value(KEY_RECENT_PATH_LOAD_SAVE_TMO_SETTINGS, QDir::currentPath())
725 .toString();
726 }
727
setDefaultPathTmoSettings(const QString & path)728 void LuminanceOptions::setDefaultPathTmoSettings(const QString &path) {
729 m_settingHolder->setValue(KEY_RECENT_PATH_LOAD_SAVE_TMO_SETTINGS, path);
730 }
731
getDefaultResponseCurveFilename()732 QString LuminanceOptions::getDefaultResponseCurveFilename() {
733 return m_settingHolder
734 ->value(KEY_RECENT_RESPONSE_CURVE_FILENAME, "")
735 .toString();
736 }
737
setDefaultResponseCurveFilename(const QString & filename)738 void LuminanceOptions::setDefaultResponseCurveFilename(const QString &filename) {
739 m_settingHolder->setValue(KEY_RECENT_RESPONSE_CURVE_FILENAME, filename);
740 }
741
742 /*
743 settings->beginGroup(GROUP_EXTERNALTOOLS);
744 //bug 2001032, remove spurious default QString "-a aligned_" value set by ver
745 1.9.2
746 if (!settings->contains(KEY_EXTERNAL_AIS_OPTIONS) ||
747 settings->value(KEY_EXTERNAL_AIS_OPTIONS).toString()=="-v -a aligned_")
748 settings->m_settingHolder->setValue(KEY_EXTERNAL_AIS_OPTIONS, QStringList()
749 << "-v" << "-a" << "aligned_");
750 align_image_stack_options=settings->value(KEY_EXTERNAL_AIS_OPTIONS).toStringList();
751 settings->endGroup();
752 */
getAlignImageStackOptions()753 QStringList LuminanceOptions::getAlignImageStackOptions() {
754 // return m_settingHolder->value(KEY_EXTERNAL_AIS_OPTIONS,
755 // QStringList() << "-v" <<
756 // "aligned_").toStringList();
757 return m_settingHolder
758 ->value(KEY_EXTERNAL_AIS_OPTIONS, QStringList() << QStringLiteral("-v"))
759 .toStringList();
760 }
761
sanitizeAISparams(QStringList temp_ais_options,bool verbose)762 QStringList LuminanceOptions::sanitizeAISparams(QStringList temp_ais_options,
763 bool verbose) {
764 bool align_opt_was_ok = true;
765
766 // check that we don't have '-a "aligned_"'
767 int idx_a = temp_ais_options.indexOf(QStringLiteral("-a"));
768
769 if (idx_a != -1) {
770 if (idx_a != temp_ais_options.size() - 1 &&
771 !temp_ais_options.at(idx_a + 1).startsWith(QLatin1String("-"))) {
772 temp_ais_options.removeAt(idx_a + 1);
773 }
774 temp_ais_options.removeAt(idx_a);
775
776 align_opt_was_ok = false;
777 }
778
779 // check if we have '-v'
780 if (temp_ais_options.indexOf(QStringLiteral("-v")) < 0) {
781 temp_ais_options.insert(0, QStringLiteral("-v"));
782 align_opt_was_ok = false;
783 }
784
785 if (verbose && !align_opt_was_ok) {
786 QMessageBox::information(
787 0, QObject::tr("Option -v -a..."),
788 QObject::tr(
789 "LuminanceHDR requires align_image_stack to be executed "
790 "with the \"-v\" and without the \"-a\" options. Command "
791 "line options have been corrected."));
792 }
793 return temp_ais_options;
794 }
795
setAlignImageStackOptions(const QStringList & qstrlist,bool verbose)796 void LuminanceOptions::setAlignImageStackOptions(const QStringList &qstrlist,
797 bool verbose) {
798 m_settingHolder->setValue(KEY_EXTERNAL_AIS_OPTIONS,
799 sanitizeAISparams(qstrlist, verbose));
800 }
801
isShowFattalWarning()802 bool LuminanceOptions::isShowFattalWarning() {
803 return m_settingHolder->value(KEY_TMOWARNING_FATTALSMALL, true).toBool();
804 }
805
setShowFattalWarning(const bool b)806 void LuminanceOptions::setShowFattalWarning(const bool b) {
807 m_settingHolder->setValue(KEY_TMOWARNING_FATTALSMALL, b);
808 }
809
getMainWindowToolBarMode()810 int LuminanceOptions::getMainWindowToolBarMode() {
811 return m_settingHolder->value(KEY_TOOLBAR_MODE, Qt::ToolButtonTextUnderIcon)
812 .toInt();
813 }
814
setMainWindowToolBarMode(int mode)815 void LuminanceOptions::setMainWindowToolBarMode(int mode) {
816 m_settingHolder->setValue(KEY_TOOLBAR_MODE, mode);
817 }
818
isPreviewPanelActive()819 bool LuminanceOptions::isPreviewPanelActive() {
820 return m_settingHolder->value(KEY_TMOWINDOW_SHOWPREVIEWPANEL, true)
821 .toBool();
822 }
823
setPreviewPanelActive(bool status)824 void LuminanceOptions::setPreviewPanelActive(bool status) {
825 m_settingHolder->setValue(KEY_TMOWINDOW_SHOWPREVIEWPANEL, status);
826 }
827
isRealtimePreviewsActive()828 bool LuminanceOptions::isRealtimePreviewsActive() {
829 return m_settingHolder->value(KEY_TMOWINDOW_REALTIMEPREVIEWS_ACTIVE, false)
830 .toBool();
831 }
832
setRealtimePreviewsActive(bool status)833 void LuminanceOptions::setRealtimePreviewsActive(bool status) {
834 m_settingHolder->setValue(KEY_TMOWINDOW_REALTIMEPREVIEWS_ACTIVE, status);
835 }
836
getPreviewWidth()837 int LuminanceOptions::getPreviewWidth() {
838 return m_settingHolder->value(KEY_TMOWINDOW_PREVIEWS_WIDTH, 400).toInt();
839 }
840
setPreviewWidth(int v)841 void LuminanceOptions::setPreviewWidth(int v) {
842 m_settingHolder->setValue(KEY_TMOWINDOW_PREVIEWS_WIDTH, v);
843 }
844
getCameraProfileFileName()845 QString LuminanceOptions::getCameraProfileFileName() {
846 return m_settingHolder->value(KEY_COLOR_CAMERA_PROFILE_FILENAME, "")
847 .toString();
848 }
849
setCameraProfileFileName(const QString & fname)850 void LuminanceOptions::setCameraProfileFileName(const QString &fname) {
851 m_settingHolder->setValue(KEY_COLOR_CAMERA_PROFILE_FILENAME, fname);
852 }
853
getMonitorProfileFileName()854 QString LuminanceOptions::getMonitorProfileFileName() {
855 return m_settingHolder->value(KEY_COLOR_MONITOR_PROFILE_FILENAME)
856 .toString();
857 }
858
setMonitorProfileFileName(const QString & fname)859 void LuminanceOptions::setMonitorProfileFileName(const QString &fname) {
860 m_settingHolder->setValue(KEY_COLOR_MONITOR_PROFILE_FILENAME, fname);
861 }
862
getPrinterProfileFileName()863 QString LuminanceOptions::getPrinterProfileFileName() {
864 return m_settingHolder->value(KEY_COLOR_PRINTER_PROFILE_FILENAME)
865 .toString();
866 }
867
setPrinterProfileFileName(const QString & fname)868 void LuminanceOptions::setPrinterProfileFileName(const QString &fname) {
869 m_settingHolder->setValue(KEY_COLOR_PRINTER_PROFILE_FILENAME, fname);
870 }
871
getPreviewPanelMode()872 int LuminanceOptions::getPreviewPanelMode() // 0 means on the right, 1 on the
873 // bottom
874 {
875 return m_settingHolder->value(KEY_PREVIEW_PANEL_MODE).toInt();
876 }
877
setPreviewPanelMode(int mode)878 void LuminanceOptions::setPreviewPanelMode(int mode) {
879 m_settingHolder->setValue(KEY_PREVIEW_PANEL_MODE, mode);
880 }
881
setExportDir(const QString & dir)882 void LuminanceOptions::setExportDir(const QString &dir) {
883 m_settingHolder->setValue(KEY_EXPORT_FILE_PATH, dir);
884 }
885
getExportDir()886 QString LuminanceOptions::getExportDir() {
887 QString path = m_settingHolder->value(KEY_EXPORT_FILE_PATH).toString();
888 if (path.isEmpty()) {
889 path = QDir::homePath();
890 } else {
891 QDir dir(path);
892 if (!dir.exists()) {
893 path = QDir::homePath();
894 }
895 }
896 return path;
897 }
898