First attempt at making Settings class device aware

diff --git a/src/devicesettings.cpp b/src/devicesettings.cpp
new file mode 100644 (file)
index 0000000..e3ef29b
--- /dev/null
+++ b/src/devicesettings.cpp
@@ -0,0 +1,181 @@
+// -*- c++ -*-
+
+/*!
+ * This file is part of CameraPlus.
+ *
+ * Copyright (C) 2012-2013 Mohammed Sameer <msameer@foolab.org>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "devicesettings.h"
+#include <QDebug>
+
+#define IMAGE_RESOLUTION_KEY        "imageResolution"
+#define IMAGE_ASPECT_RATIO_KEY      "imageAspectRatio"
+#define VIDEO_RESOLUTION_KEY        "videoResolution"
+#define VIDEO_ASPECT_RATIO_KEY      "videoAspectRatio"
+#define IMAGE_SCENE_MODE_KEY        "imageSceneMode"
+#define VIDEO_SCENE_MODE_KEY        "videoSceneMode"
+#define IMAGE_COLOR_FILTER_KEY      "imageColorFilter"
+#define VIDEO_COLOR_FILTER_KEY      "videoColorFilter"
+#define IMAGE_WHITE_BALANCE_KEY     "imageWhiteBalance"
+#define VIDEO_WHITE_BALANCE_KEY     "videoWhiteBalance"
+#define IMAGE_EV_COMP_KEY           "imageEvComp"
+#define VIDEO_EV_COMP_KEY           "videoEvComp"
+#define IMAGE_FLASH_MODE_KEY        "imageFlashMode"
+#define VIDEO_TORCH_ON_KEY          "videoTorchOn"
+#define IMAGE_ISO_KEY               "imageIso"
+
+DeviceSettings::DeviceSettings(const QHash<QString, QVariant>& defaultSettings) :
+  m_settings(defaultSettings) {
+
+}
+
+DeviceSettings::~DeviceSettings() {
+
+}
+
+QVariant DeviceSettings::value(const QString& key) const {
+  if (!m_settings.contains(key)) {
+    qFatal("%s not found", qPrintable(key));
+
+    return QVariant();
+  }
+
+  return m_settings[key];
+}
+
+QVariant DeviceSettings::defaultImageResolution() const {
+  return value(IMAGE_RESOLUTION_KEY);
+}
+
+QVariant DeviceSettings::defaultVideoResolution() const {
+  return value(VIDEO_RESOLUTION_KEY);
+}
+
+QVariant DeviceSettings::defaultImageAspectRatio() const {
+  return value(IMAGE_ASPECT_RATIO_KEY);
+}
+
+QVariant DeviceSettings::defaultVideoAspectRatio() const {
+  return value(VIDEO_ASPECT_RATIO_KEY);
+}
+
+QVariant DeviceSettings::defaultImageSceneMode() const {
+  return value(IMAGE_SCENE_MODE_KEY);
+}
+
+QVariant DeviceSettings::defaultVideoSceneMode() const {
+  return value(VIDEO_SCENE_MODE_KEY);
+}
+
+QVariant DeviceSettings::defaultImageColorFilter() const {
+  return value(IMAGE_COLOR_FILTER_KEY);
+}
+
+QVariant DeviceSettings::defaultVideoColorFilter() const {
+  return value(VIDEO_COLOR_FILTER_KEY);
+}
+
+QVariant DeviceSettings::defaultImageWhiteBalance() const {
+  return value(IMAGE_WHITE_BALANCE_KEY);
+}
+
+QVariant DeviceSettings::defaultVideoWhiteBalance() const {
+  return value(VIDEO_WHITE_BALANCE_KEY);
+}
+
+QVariant DeviceSettings::defaultImageEvComp() const {
+  return value(IMAGE_EV_COMP_KEY);
+}
+
+QVariant DeviceSettings::defaultVideoEvComp() const {
+  return value(VIDEO_EV_COMP_KEY);
+}
+
+QVariant DeviceSettings::defaultImageFlashMode() const {
+  return value(IMAGE_FLASH_MODE_KEY);
+}
+
+QVariant DeviceSettings::defaultImageIso() const {
+  return value(IMAGE_ISO_KEY);
+}
+
+QVariant DeviceSettings::defaultVideoTorchOn() const {
+  return value(VIDEO_TORCH_ON_KEY);
+}
+
+PrimaryDeviceSettings::PrimaryDeviceSettings() :
+  DeviceSettings(settings()) {
+
+}
+
+QString PrimaryDeviceSettings::id() const {
+  return "primary";
+}
+
+QHash<QString, QVariant> PrimaryDeviceSettings::settings() const {
+  QHash<QString, QVariant> hash;
+
+  hash[IMAGE_RESOLUTION_KEY] = "high";
+  hash[IMAGE_ASPECT_RATIO_KEY] = "16:9";
+  hash[VIDEO_RESOLUTION_KEY] = "high";
+  hash[VIDEO_ASPECT_RATIO_KEY] = "16:9";
+  hash[IMAGE_SCENE_MODE_KEY] = 6;
+  hash[VIDEO_SCENE_MODE_KEY] = 6;
+  hash[IMAGE_COLOR_FILTER_KEY] = 0;
+  hash[VIDEO_COLOR_FILTER_KEY] = 0;
+  hash[IMAGE_WHITE_BALANCE_KEY] = 0;
+  hash[VIDEO_WHITE_BALANCE_KEY] = 0;
+  hash[IMAGE_EV_COMP_KEY] = 0.0;
+  hash[VIDEO_EV_COMP_KEY] = 0.0;
+  hash[IMAGE_FLASH_MODE_KEY] = 0;
+  hash[VIDEO_TORCH_ON_KEY] = false;
+  hash[IMAGE_ISO_KEY] = 0;
+
+  return hash;
+}
+
+SecondaryDeviceSettings::SecondaryDeviceSettings() :
+  DeviceSettings(settings()) {
+
+}
+
+QString SecondaryDeviceSettings::id() const {
+  return "secondary";
+}
+
+QHash<QString, QVariant> SecondaryDeviceSettings::settings() const {
+  QHash<QString, QVariant> hash;
+
+  hash[IMAGE_RESOLUTION_KEY] = "low";
+  hash[IMAGE_ASPECT_RATIO_KEY] = "4:3";
+  hash[VIDEO_RESOLUTION_KEY] = "low";
+  hash[VIDEO_ASPECT_RATIO_KEY] = "4:3";
+  hash[IMAGE_SCENE_MODE_KEY] = 6;
+  hash[VIDEO_SCENE_MODE_KEY] = 6;
+  hash[IMAGE_COLOR_FILTER_KEY] = 0;
+  hash[VIDEO_COLOR_FILTER_KEY] = 0;
+  hash[IMAGE_WHITE_BALANCE_KEY] = 0;
+  hash[VIDEO_WHITE_BALANCE_KEY] = 0;
+  hash[IMAGE_EV_COMP_KEY] = 0.0;
+  hash[VIDEO_EV_COMP_KEY] = 0.0;
+  hash[IMAGE_FLASH_MODE_KEY] = 0;
+  hash[VIDEO_TORCH_ON_KEY] = false;
+  hash[IMAGE_ISO_KEY] = 0;
+
+  return hash;
+}

diff --git a/src/devicesettings.h b/src/devicesettings.h
new file mode 100644 (file)
index 0000000..26a7e41
--- /dev/null
+++ b/src/devicesettings.h
@@ -0,0 +1,81 @@
+// -*- c++ -*-
+
+/*!
+ * This file is part of CameraPlus.
+ *
+ * Copyright (C) 2012-2013 Mohammed Sameer <msameer@foolab.org>
+ *
+ * This library 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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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 this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef DEVICE_SETTINGS_H
+#define DEVICE_SETTINGS_H
+
+#include <QString>
+#include <QVariant>
+#include <QHash>
+
+class DeviceSettings {
+public:
+  virtual ~DeviceSettings();
+
+  virtual QString id() const = 0;
+
+  QVariant defaultImageResolution() const;
+  QVariant defaultVideoResolution() const;
+  QVariant defaultImageAspectRatio() const;
+  QVariant defaultVideoAspectRatio() const;
+  QVariant defaultImageSceneMode() const;
+  QVariant defaultVideoSceneMode() const;
+  QVariant defaultImageColorFilter() const;
+  QVariant defaultVideoColorFilter() const;
+  QVariant defaultImageWhiteBalance() const;
+  QVariant defaultVideoWhiteBalance() const;
+  QVariant defaultImageEvComp() const;
+  QVariant defaultVideoEvComp() const;
+  QVariant defaultImageFlashMode() const;
+  QVariant defaultImageIso() const;
+  QVariant defaultVideoTorchOn() const;
+
+protected:
+  DeviceSettings(const QHash<QString, QVariant>& defaultSettings);
+
+private:
+  QVariant value(const QString& key) const;
+
+  const QHash<QString, QVariant> m_settings;
+};
+
+class PrimaryDeviceSettings : public DeviceSettings {
+public:
+  PrimaryDeviceSettings();
+
+  QString id() const;
+
+private:
+  QHash<QString, QVariant> settings() const;
+};
+
+class SecondaryDeviceSettings : public DeviceSettings {
+public:
+  SecondaryDeviceSettings();
+
+  QString id() const;
+
+private:
+  QHash<QString, QVariant> settings() const;
+};
+
+#endif /* DEVICE_SETTINGS_H */

diff --git a/src/settings.cpp b/src/settings.cpp
index 1d099a0..7d7950c 100644 (file)
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -21,23 +21,14 @@
 #include "settings.h"
 #include <QSettings>
 #include <QDir>
+#include "devicesettings.h"
 
 #define PATH QString("%1%2.config%2/cameraplus.conf").arg(QDir::homePath()).arg(QDir::separator())
 
 #define DEFAULT_MODE                    1
-#define DEFAULT_SCENE_MODE              6 // Auto
 #define DEFAULT_USE_GPS                 true
 #define DEFAULT_USE_GEOTAGS             true
-#define DEFAULT_COLOR_FILTER            0
-#define DEFAULT_WHITE_BALANCE           0
-#define DEFAULT_EV_COMP                 0.0
-#define DEFAULT_FLASH_MODE              0
-#define DEFAULT_IMAGE_ISO               0
-#define DEFAULT_IMAGE_RESOLUTION        "high"
-#define DEFAULT_IMAGE_ASPECT_RATIO      "16:9"
-#define DEFAULT_VIDEO_RESOLUTION        "high"
 #define DEFAULT_SOUND_ENABLED           true
-#define DEFAULT_VIDEO_TORCH_ON          false
 #define DEFAULT_SHOW_TOOL_BAR           false
 #define DEFAULT_VIDEO_MUTE              false
 #define DEFAULT_GRID_ENABLED            false
@@ -47,12 +38,14 @@
 
 Settings::Settings(QObject *parent) :
   QObject(parent),
-  m_settings(new QSettings(PATH, QSettings::IniFormat, this)) {
+  m_settings(new QSettings(PATH, QSettings::IniFormat, this)),
+  m_device(0) {
 
 }
 
 Settings::~Settings() {
   delete m_settings; m_settings = 0;
+  delete m_device; m_device = 0;
 }
 
 int Settings::mode() const {
@@ -103,257 +96,312 @@ void Settings::setUseGeotags(bool enable) {
   }
 }
 
-int Settings::imageSceneMode() const {
-  return m_settings->value("image/sceneMode", DEFAULT_SCENE_MODE).toInt();
+bool Settings::isSoundEnabled() const {
+  return m_settings->value("camera/soundEnabled", DEFAULT_SOUND_ENABLED).toBool();
+}
+
+void Settings::setSoundEnabled(bool enabled) {
+  if (isSoundEnabled() != enabled) {
+    m_settings->setValue("camera/soundEnabled", enabled);
+    emit soundEnabledChanged();
+  }
+}
+
+bool Settings::isToolBarShown() const {
+  return m_settings->value("camera/showToolBar", DEFAULT_SHOW_TOOL_BAR).toBool();
+}
+
+void Settings::setToolBarShown(bool shown) {
+  if (isToolBarShown() != shown) {
+    m_settings->setValue("camera/showToolBar", shown);
+
+    emit toolBarShownChanged();
+  }
+}
+
+bool Settings::isVideoMuted() const {
+  return m_settings->value("video/mute", DEFAULT_VIDEO_MUTE).toBool();
+}
+
+void Settings::setVideoMuted(bool muted) {
+  if (isVideoMuted() != muted) {
+    m_settings->setValue("video/mute", muted);
+    emit videoMutedChanged();
+  }
+}
+
+bool Settings::isGridEnabled() const {
+  return m_settings->value("camera/gridEnabled", DEFAULT_GRID_ENABLED).toBool();
+}
+
+void Settings::setGridEnabled(bool enabled) {
+  if (enabled != isGridEnabled()) {
+    m_settings->setValue("camera/gridEnabled", enabled);
+    emit gridEnabledChanged();
+  }
+}
+
+bool Settings::isFaceDetectionEnabled() const {
+  return m_settings->value("image/faceDetectionEnabled", DEFAULT_FACE_DETECTION_ENABLED).toBool();
+}
+
+void Settings::setFaceDetectionEnabled(bool enabled) {
+  if (isFaceDetectionEnabled() != enabled) {
+    m_settings->setValue("image/faceDetectionEnabled", enabled);
+    emit faceDetectionEnabledChanged();
+  }
+}
+
+bool Settings::isZoomAsShutterEnabled() const {
+  return m_settings->value("camera/zoomAsShutter", DEFAULT_ZOOM_AS_SHUTTER).toBool();
+}
+
+void Settings::setZoomAsShutterEnabled(bool enabled) {
+  if (isZoomAsShutterEnabled() != enabled) {
+    m_settings->setValue("camera/zoomAsShutter", enabled);
+
+    emit zoomAsShutterChanged();
+  }
+}
+
+int Settings::device() const {
+  return m_settings->value("camera/device", DEFAULT_DEVICE).toInt();
+}
+
+void Settings::setDevice(int device) {
+  if (device != Settings::device()) {
+    m_settings->setValue("camera/device", device);
+
+    delete m_device; m_device = 0;
+    emit deviceChanged();
+
+    if (mode() == DEFAULT_MODE) {
+      // image
+      emit imageSceneModeChanged();
+      emit imageColorFilterChanged();
+      emit imageWhiteBalanceChanged();
+      emit imageEvCompChanged();
+      emit imageFlashModeChanged();
+      emit imageIsoChanged();
+      emit imageAspectRatioChanged();
+      emit imageResolutionChanged();
+    }
+    else {
+      // video
+      emit videoSceneModeChanged();
+      emit videoColorFilterChanged();
+      emit videoWhiteBalanceChanged();
+      emit videoEvCompChanged();
+      emit videoAspectRatioChanged();
+      emit videoResolutionChanged();
+      emit videoTorchOnChanged();
+    }
+  }
+}
+
+DeviceSettings *Settings::deviceSettings() {
+  if (m_device) {
+    return m_device;
+  }
+
+  int device = Settings::device();
+
+  if (device == 0) {
+    m_device = new PrimaryDeviceSettings;
+  }
+  else {
+    m_device = new SecondaryDeviceSettings;
+  }
+
+  return m_device;
+}
+
+QVariant Settings::deviceValue(const char *key, const QVariant& defaultValue) {
+  QString k = QString("%1/%2").arg(deviceSettings()->id()).arg(key);
+
+  return m_settings->value(k, defaultValue);
+}
+
+void Settings::setDeviceValue(const char *key, const QVariant& value) {
+  QString k = QString("%1/%2").arg(deviceSettings()->id()).arg(key);
+
+  m_settings->setValue(k, value);
+}
+
+// Device dependant settings
+
+int Settings::imageSceneMode() {
+  return deviceValue("image/sceneMode", deviceSettings()->defaultImageSceneMode()).toInt();
 }
 
 void Settings::setImageSceneMode(int mode) {
   if (mode != imageSceneMode()) {
-    m_settings->setValue("image/sceneMode", mode);
+    setDeviceValue("image/sceneMode", mode);
   }
 
+  // We always emit the signal to reset scene and all scene associated values
   emit imageSceneModeChanged();
 }
 
-int Settings::imageColorFilter() const {
-  return m_settings->value("image/colorFilter", DEFAULT_COLOR_FILTER).toInt();
+int Settings::imageColorFilter() {
+  return deviceValue("image/colorFilter", deviceSettings()->defaultImageColorFilter()).toInt();
 }
 
 void Settings::setImageColorFilter(int filter) {
   if (filter != imageColorFilter()) {
-    m_settings->setValue("image/colorFilter", filter);
+    setDeviceValue("image/colorFilter", filter);
 
     emit imageColorFilterChanged();
   }
 }
 
-int Settings::imageWhiteBalance() const {
-  return m_settings->value("image/whiteBalance", DEFAULT_WHITE_BALANCE).toInt();
+int Settings::imageWhiteBalance() {
+  return deviceValue("image/whiteBalance", deviceSettings()->defaultImageWhiteBalance()).toInt();
 }
 
 void Settings::setImageWhiteBalance(int wb) {
   if (wb != imageWhiteBalance()) {
-    m_settings->setValue("image/whiteBalance", wb);
+    setDeviceValue("image/whiteBalance", wb);
 
     emit imageWhiteBalanceChanged();
   }
 }
 
-qreal Settings::imageEvComp() const {
-  return m_settings->value("image/evComp", DEFAULT_EV_COMP).toReal();
+qreal Settings::imageEvComp() {
+  return deviceValue("image/evComp", deviceSettings()->defaultImageEvComp()).toReal();
 }
 
 void Settings::setImageEvComp(qreal ev) {
   if (!qFuzzyCompare(ev, imageEvComp())) {
-    m_settings->setValue("image/evComp", ev);
+    setDeviceValue("image/evComp", ev);
 
     emit imageEvCompChanged();
   }
 }
 
-int Settings::videoSceneMode() const {
-  return m_settings->value("video/sceneMode", DEFAULT_SCENE_MODE).toInt();
+int Settings::videoSceneMode() {
+  return deviceValue("video/sceneMode", deviceSettings()->defaultVideoSceneMode()).toInt();
 }
 
 void Settings::setVideoSceneMode(int mode) {
   if (mode != videoSceneMode()) {
-    m_settings->setValue("video/sceneMode", mode);
+    setDeviceValue("video/sceneMode", mode);
   }
 
   emit videoSceneModeChanged();
 }
 
-int Settings::videoColorFilter() const {
-  return m_settings->value("video/colorFilter", DEFAULT_COLOR_FILTER).toInt();
+int Settings::videoColorFilter() {
+  return deviceValue("video/colorFilter", deviceSettings()->defaultVideoColorFilter()).toInt();
 }
 
 void Settings::setVideoColorFilter(int filter) {
   if (filter != videoColorFilter()) {
-    m_settings->setValue("video/colorFilter", filter);
+    setDeviceValue("video/colorFilter", filter);
 
     emit videoColorFilterChanged();
   }
 }
 
-int Settings::videoWhiteBalance() const {
-  return m_settings->value("video/whiteBalance", DEFAULT_WHITE_BALANCE).toInt();
+int Settings::videoWhiteBalance() {
+  return deviceValue("video/whiteBalance", deviceSettings()->defaultVideoWhiteBalance()).toInt();
 }
 
 void Settings::setVideoWhiteBalance(int wb) {
   if (wb != videoWhiteBalance()) {
-    m_settings->setValue("video/whiteBalance", wb);
+    setDeviceValue("video/whiteBalance", wb);
 
     emit videoWhiteBalanceChanged();
   }
 }
 
-qreal Settings::videoEvComp() const {
-  return m_settings->value("video/evComp", DEFAULT_EV_COMP).toReal();
+qreal Settings::videoEvComp() {
+  return deviceValue("video/evComp", deviceSettings()->defaultVideoEvComp()).toReal();
 }
 
 void Settings::setVideoEvComp(qreal ev) {
   if (!qFuzzyCompare(ev, videoEvComp())) {
-    m_settings->setValue("video/evComp", ev);
+    setDeviceValue("video/evComp", ev);
 
     emit videoEvCompChanged();
   }
 }
 
-int Settings::imageFlashMode() const {
-  return m_settings->value("image/flashMode", DEFAULT_FLASH_MODE).toInt();
+int Settings::imageFlashMode() {
+  return deviceValue("image/flashMode", deviceSettings()->defaultImageFlashMode()).toInt();
 }
 
 void Settings::setImageFlashMode(int mode) {
   if (mode != imageFlashMode()) {
-    m_settings->setValue("image/flashMode", mode);
+    setDeviceValue("image/flashMode", mode);
 
     emit imageFlashModeChanged();
   }
 }
 
-int Settings::imageIso() const {
-  return m_settings->value("image/iso", DEFAULT_IMAGE_ISO).toInt();
+int Settings::imageIso() {
+  return deviceValue("image/iso", deviceSettings()->defaultImageIso()).toInt();
 }
 
 void Settings::setImageIso(int iso) {
   if (imageIso() != iso) {
-    m_settings->setValue("image/iso", iso);
+    setDeviceValue("image/iso", iso);
     emit imageIsoChanged();
   }
 }
 
-QString Settings::imageAspectRatio() const {
-  return m_settings->value("image/aspectRatio", DEFAULT_IMAGE_ASPECT_RATIO).toString();
+QString Settings::imageAspectRatio() {
+  return deviceValue("image/aspectRatio", deviceSettings()->defaultImageAspectRatio()).toString();
 }
 
 void Settings::setImageAspectRatio(const QString& aspectRatio) {
   if (aspectRatio != imageAspectRatio()) {
-    m_settings->setValue("image/aspectRatio", aspectRatio);
+    setDeviceValue("image/aspectRatio", aspectRatio);
     emit imageAspectRatioChanged();
   }
 }
 
-QString Settings::imageResolution() const {
-  return m_settings->value("image/resolution", DEFAULT_IMAGE_RESOLUTION).toString();
+QString Settings::imageResolution() {
+  return deviceValue("image/resolution", deviceSettings()->defaultImageResolution()).toString();
 }
 
 void Settings::setImageResolution(const QString& resolution) {
   if (resolution != imageResolution()) {
-    m_settings->setValue("image/resolution", resolution);
+    setDeviceValue("image/resolution", resolution);
     emit imageResolutionChanged();
   }
 }
 
-QString Settings::videoAspectRatio() const {
-  // This is not used for anything so we will return an empty string for now
-  // which will make the backend return all resolutions.
-
-  return QString();
+QString Settings::videoAspectRatio() {
+  return deviceValue("video/aspectRatio", deviceSettings()->defaultVideoAspectRatio()).toString();
 }
 
-void Settings::setVideoAspectRatio(const QString& aspectRatio) {
-  Q_UNUSED(aspectRatio);
 
-  // This is not used for anything so we will just ignore it.
+void Settings::setVideoAspectRatio(const QString& aspectRatio) {
+  if (Settings::videoAspectRatio() != aspectRatio) {
+    setDeviceValue("video/aspectRatio", aspectRatio);
+    emit videoAspectRatioChanged();
+  }
 }
 
-QString Settings::videoResolution() const {
-  return m_settings->value("video/resolution", DEFAULT_VIDEO_RESOLUTION).toString();
+QString Settings::videoResolution() {
+  return deviceValue("video/resolution", deviceSettings()->defaultVideoResolution()).toString();
 }
 
 void Settings::setVideoResolution(const QString& resolution) {
   if (resolution != videoResolution()) {
-    m_settings->setValue("video/resolution", resolution);
+    setDeviceValue("video/resolution", resolution);
     emit videoResolutionChanged();
   }
 }
 
-bool Settings::isSoundEnabled() const {
-  return m_settings->value("camera/soundEnabled", DEFAULT_SOUND_ENABLED).toBool();
-}
-
-void Settings::setSoundEnabled(bool enabled) {
-  if (isSoundEnabled() != enabled) {
-    m_settings->setValue("camera/soundEnabled", enabled);
-    emit soundEnabledChanged();
-  }
-}
-
-bool Settings::isVideoTorchOn() const {
-  return m_settings->value("video/torchOn", DEFAULT_VIDEO_TORCH_ON).toBool();
+bool Settings::isVideoTorchOn() {
+  return deviceValue("video/torchOn", deviceSettings()->defaultVideoTorchOn()).toBool();
 }
 
 void Settings::setVideoTorchOn(bool on) {
   if (isVideoTorchOn() != on) {
-    m_settings->setValue("video/torchOn", on);
+    setDeviceValue("video/torchOn", on);
     emit videoTorchOnChanged();
   }
 }
-
-bool Settings::isToolBarShown() const {
-  return m_settings->value("camera/showToolBar", DEFAULT_SHOW_TOOL_BAR).toBool();
-}
-
-void Settings::setToolBarShown(bool shown) {
-  if (isToolBarShown() != shown) {
-    m_settings->setValue("camera/showToolBar", shown);
-
-    emit toolBarShownChanged();
-  }
-}
-
-bool Settings::isVideoMuted() const {
-  return m_settings->value("video/mute", DEFAULT_VIDEO_MUTE).toBool();
-}
-
-void Settings::setVideoMuted(bool muted) {
-  if (isVideoMuted() != muted) {
-    m_settings->setValue("video/mute", muted);
-    emit videoMutedChanged();
-  }
-}
-
-bool Settings::isGridEnabled() const {
-  return m_settings->value("camera/gridEnabled", DEFAULT_GRID_ENABLED).toBool();
-}
-
-void Settings::setGridEnabled(bool enabled) {
-  if (enabled != isGridEnabled()) {
-    m_settings->setValue("camera/gridEnabled", enabled);
-    emit gridEnabledChanged();
-  }
-}
-
-bool Settings::isFaceDetectionEnabled() const {
-  return m_settings->value("image/faceDetectionEnabled", DEFAULT_FACE_DETECTION_ENABLED).toBool();
-}
-
-void Settings::setFaceDetectionEnabled(bool enabled) {
-  if (isFaceDetectionEnabled() != enabled) {
-    m_settings->setValue("image/faceDetectionEnabled", enabled);
-    emit faceDetectionEnabledChanged();
-  }
-}
-
-bool Settings::isZoomAsShutterEnabled() {
-  return m_settings->value("camera/zoomAsShutter", DEFAULT_ZOOM_AS_SHUTTER).toBool();
-}
-
-void Settings::setZoomAsShutterEnabled(bool enabled) {
-  if (isZoomAsShutterEnabled() != enabled) {
-    m_settings->setValue("camera/zoomAsShutter", enabled);
-
-    emit zoomAsShutterChanged();
-  }
-}
-
-int Settings::device() const {
-  return m_settings->value("camera/device", DEFAULT_DEVICE).toInt();
-}
-
-void Settings::setDevice(int device) {
-  if (device != Settings::device()) {
-    m_settings->setValue("camera/device", device);
-    emit deviceChanged();
-  }
-}

diff --git a/src/settings.h b/src/settings.h
index b27dea6..2ec2558 100644 (file)
--- a/src/settings.h
+++ b/src/settings.h
@@ -26,6 +26,7 @@
 #include <QObject>
 
 class QSettings;
+class DeviceSettings;
 
 class Settings : public QObject {
   Q_OBJECT
@@ -81,52 +82,52 @@ public:
   bool useGeotags() const;
   void setUseGeotags(bool enable);
 
-  int imageSceneMode() const;
+  int imageSceneMode();
   void setImageSceneMode(int mode);
 
-  int imageColorFilter() const;
+  int imageColorFilter();
   void setImageColorFilter(int filter);
 
-  int imageWhiteBalance() const;
+  int imageWhiteBalance();
   void setImageWhiteBalance(int wb);
 
-  qreal imageEvComp() const;
+  qreal imageEvComp();
   void setImageEvComp(qreal ev);
 
-  int videoSceneMode() const;
+  int videoSceneMode();
   void setVideoSceneMode(int mode);
 
-  int videoColorFilter() const;
+  int videoColorFilter();
   void setVideoColorFilter(int filter);
 
-  int videoWhiteBalance() const;
+  int videoWhiteBalance();
   void setVideoWhiteBalance(int wb);
 
-  qreal videoEvComp() const;
+  qreal videoEvComp();
   void setVideoEvComp(qreal ev);
 
-  int imageFlashMode() const;
+  int imageFlashMode();
   void setImageFlashMode(int mode);
 
-  int imageIso() const;
+  int imageIso();
   void setImageIso(int iso);
 
-  QString imageAspectRatio() const;
+  QString imageAspectRatio();
   void setImageAspectRatio(const QString& aspectRatio);
 
-  QString imageResolution() const;
+  QString imageResolution();
   void setImageResolution(const QString& resolution);
 
-  QString videoAspectRatio() const;
+  QString videoAspectRatio();
   void setVideoAspectRatio(const QString& aspectRatio);
 
-  QString videoResolution() const;
+  QString videoResolution();
   void setVideoResolution(const QString& resolution);
 
   bool isSoundEnabled() const;
   void setSoundEnabled(bool enabled);
 
-  bool isVideoTorchOn() const;
+  bool isVideoTorchOn();
   void setVideoTorchOn(bool on);
 
   bool isToolBarShown() const;
@@ -141,7 +142,7 @@ public:
   bool isFaceDetectionEnabled() const;
   void setFaceDetectionEnabled(bool enabled);
 
-  bool isZoomAsShutterEnabled();
+  bool isZoomAsShutterEnabled() const;
   void setZoomAsShutterEnabled(bool enabled);
 
   int device() const;
@@ -176,7 +177,12 @@ signals:
   void deviceChanged();
 
 private:
+  DeviceSettings *deviceSettings();
+  QVariant deviceValue(const char *key, const QVariant& defaultValue);
+  void setDeviceValue(const char *key, const QVariant& value);
+
   QSettings *m_settings;
+  DeviceSettings *m_device;
 };
 
 #endif /* SETTINGS_H */

diff --git a/src/src.pro b/src/src.pro
index 6dc0dd0..9238f70 100644 (file)
--- a/src/src.pro
+++ b/src/src.pro
@@ -22,13 +22,13 @@ SOURCES += main.cpp \
            trackerstore.cpp focusrectangle.cpp sharehelper.cpp \
            deletehelper.cpp galleryhelper.cpp postcapturemodel.cpp \
            gridlines.cpp platformsettings.cpp dbusservice.cpp \
-           mountprotector.cpp
+           mountprotector.cpp devicesettings.cpp
 
 HEADERS += settings.h filenaming.h cameraresources.h \
            trackerstore.h focusrectangle.h sharehelper.h \
            deletehelper.h galleryhelper.h postcapturemodel.h \
            gridlines.h platformsettings.h dbusservice.h \
-           mountprotector.h
+           mountprotector.h devicesettings.h
 
 RESOURCES += ../qml/qml.qrc