From c29e228ae08be6f386cd2e8970f290102de1c6b6 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sun, 1 Aug 2021 11:27:22 +1200
Subject: [PATCH 01/30] - Add image list display type, you provide a comma
 delimited list of fully qualified path names to display

---
 README.md             |  3 ++-
 src/main.cpp          | 14 +++++++++++---
 src/pathtraverser.cpp | 21 +++++++++++++++++++++
 src/pathtraverser.h   | 10 ++++++++++
 4 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 0246fe4..64441b7 100644
--- a/README.md
+++ b/README.md
@@ -17,10 +17,11 @@ This project is maintained by myself during my spare time. If you like and use i
 ## Usage
 
 ```
-slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-O overlay_string] [-v] [--verbose] [--stretch]
+slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur_radius] [-p image_folder|-i imageFile,...] [-r] [-O overlay_string] [-v] [--verbose] [--stretch]
 ```
 
 * `image_folder`: where to search for images (.jpg files)
+* `-i imageFile,...`: comma delimited list of full paths to image files to display
 * `-r` for recursive traversal of `image_folder`
 * `-s` for shuffle instead of random image rotation
 * `-S` for sorted rotation (files ordered by name, first images then subfolders)
diff --git a/src/main.cpp b/src/main.cpp
index accc571..871cb9f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -35,6 +35,7 @@ int main(int argc, char *argv[])
   bool fitAspectAxisToWindow = false;
   std::string valid_aspects = "alp"; // all, landscape, portait
   std::string overlay = "";
+  std::string imageList = ""; // comma delimited list of images to show
   int debugInt = 0;
   int stretchInt = 0;
   static struct option long_options[] =
@@ -43,7 +44,7 @@ int main(int argc, char *argv[])
     {"stretch", no_argument,       &stretchInt, 1},
   };
   int option_index = 0;
-  while ((opt = getopt_long(argc, argv, "b:p:t:o:O:a:rsSv", long_options, &option_index)) != -1) {
+  while ((opt = getopt_long(argc, argv, "b:p:t:o:O:a:i:rsSv", long_options, &option_index)) != -1) {
     switch (opt) {
       case 0:
           /* If this option set a flag, do nothing else now. */
@@ -88,6 +89,9 @@ int main(int argc, char *argv[])
       case 'v':
         debugMode = true;
         break;
+      case 'i':
+        imageList = optarg;
+        break;
       default: /* '?' */
         usage(argv[0]);
         return 1;
@@ -102,7 +106,7 @@ int main(int argc, char *argv[])
     fitAspectAxisToWindow = true;
   }
 
-  if (path.empty())
+  if (path.empty() && imageList.empty())
   {
     std::cout << "Error: Path expected." << std::endl;
     usage(argv[0]);
@@ -110,7 +114,11 @@ int main(int argc, char *argv[])
   }
 
   std::unique_ptr<PathTraverser> pathTraverser;
-  if (recursive)
+  if (!imageList.empty())
+  {
+    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(imageList));
+  }
+  else if (recursive)
   {
     pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path));
   }
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index a6f3317..bb20a0f 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -61,3 +61,24 @@ const std::string DefaultPathTraverser::getImagePath(const std::string image) co
 {
   return directory.filePath(QString(image.c_str())).toStdString();
 }
+
+
+ImageListPathTraverser::ImageListPathTraverser(const std::string &imageListString):
+  PathTraverser("")
+{
+  QString str = QString(imageListString.c_str());
+  imageList = str.split(QLatin1Char(','));
+}
+
+ImageListPathTraverser::~ImageListPathTraverser() {}
+
+
+QStringList ImageListPathTraverser::getImages() const
+{
+  return imageList;
+}
+
+const std::string ImageListPathTraverser::getImagePath(const std::string image) const
+{
+  return image;
+}
\ No newline at end of file
diff --git a/src/pathtraverser.h b/src/pathtraverser.h
index 743278c..8d32e08 100644
--- a/src/pathtraverser.h
+++ b/src/pathtraverser.h
@@ -41,4 +41,14 @@ class DefaultPathTraverser : public PathTraverser
     QDir directory;
 };
 
+class ImageListPathTraverser : public PathTraverser
+{
+  public:
+    ImageListPathTraverser(const std::string &imageListString);
+    virtual ~ImageListPathTraverser();
+    QStringList getImages() const;
+    virtual const std::string getImagePath(const std::string image) const;
+  private:
+    QStringList imageList;
+};
 #endif // PATHTRAVERSER_H

From 5eaf7ee539659d12d3b38ad2bd99d80817d8af4f Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sun, 1 Aug 2021 13:05:43 +1200
Subject: [PATCH 02/30] - Add support for per folder image display options. The
 file called options.json contains json keys to control image options when
 displaying files in this folder. Currently a singled option,
 fitAspectAxisToWindow, is supported - Remove duplicated image rotation
 reading code, have the image selector logic just pass this up via the per
 image options

---
 README.md             | 11 ++++++-
 src/imageselector.cpp | 51 +++++++++++++++++++------------
 src/imageselector.h   | 26 ++++++++++------
 src/imageswitcher.cpp |  5 +--
 src/main.cpp          | 14 ++++-----
 src/mainwindow.cpp    | 51 ++++---------------------------
 src/mainwindow.h      |  8 ++---
 src/pathtraverser.cpp | 71 +++++++++++++++++++++++++++++++++++++------
 src/pathtraverser.h   | 15 ++++++---
 9 files changed, 149 insertions(+), 103 deletions(-)

diff --git a/README.md b/README.md
index 64441b7..34d10f5 100644
--- a/README.md
+++ b/README.md
@@ -46,7 +46,16 @@ slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur
     * `<dir>`directory of the current image
     * `<path>`path to the current image without filename
   * Example: `slide -p ./images -O "20|60|Time: <time>;;;Picture taken at <exifdatetime>"`
-      
+
+## Folder Options file
+When using the default or recursive folder mode we support having per folder display options. The options are stored in a file called "options.json" and currently support the following option
+```
+{
+    "fitAspectAxisToWindow": false
+}
+```
+* `fitAspectAxisToWindow` : apply the --stretch option to files in this folder
+
 ## Dependencies
 
 * qt5-qmake
diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 5271291..803a867 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -12,8 +12,8 @@
 #include <algorithm>    // std::shuffle
 #include <random>       // std::default_random_engine
 
-ImageSelector::ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspectIn):
-  pathTraverser(pathTraverser), aspect(aspectIn)
+ImageSelector::ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspectIn, bool fitAspectAxisToWindowIn):
+  pathTraverser(pathTraverser), aspect(aspectIn), fitAspectAxisToWindow(fitAspectAxisToWindowIn)
 {
 }
 
@@ -50,12 +50,11 @@ int ImageSelector::getImageRotation(const std::string &fileName)
   return degrees;
 }
 
-bool ImageSelector::imageValidForAspect(const std::string &fileName)
+bool ImageSelector::imageValidForAspect(const std::string &fileName, const int rotation)
 {
   QPixmap p( fileName.c_str() );
   int imageWidth = p.width();
   int imageHeight = p.height();
-  int rotation = getImageRotation(fileName);
   if ( rotation == 90 || rotation == 270 )
   {
     std::swap(imageWidth,imageHeight);
@@ -83,15 +82,15 @@ bool ImageSelector::imageValidForAspect(const std::string &fileName)
 }
 
 
-RandomImageSelector::RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect):
-  ImageSelector(pathTraverser, aspect)
+RandomImageSelector::RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow):
+  ImageSelector(pathTraverser, aspect, fitAspectAxisToWindow)
 {
   srand (time(NULL));
 }
 
 RandomImageSelector::~RandomImageSelector(){}
 
-std::string RandomImageSelector::getNextImage()
+const std::string RandomImageSelector::getNextImage(ImageOptions_t &options)
 {
   std:: string filename;
   try
@@ -101,7 +100,8 @@ std::string RandomImageSelector::getNextImage()
       QStringList images = pathTraverser->getImages();
       unsigned int selectedImage = selectRandom(images);
       filename = pathTraverser->getImagePath(images.at(selectedImage).toStdString());
-      if (!imageValidForAspect(filename))
+      options.rotation = getImageRotation(filename);
+      if (!imageValidForAspect(filename, options.rotation))
       {
         filename.clear();
       }
@@ -113,6 +113,9 @@ std::string RandomImageSelector::getNextImage()
     std::cerr << "Error: " << err << std::endl;
   }
   std::cout << "updating image: " << filename << std::endl;
+  options.aspect = aspect;
+  options.fitAspectAxisToWindow = fitAspectAxisToWindow;
+  pathTraverser->UpdateOptionsForImage(filename, options);
   return filename;
 }
 
@@ -129,8 +132,8 @@ unsigned int RandomImageSelector::selectRandom(const QStringList& images) const
   return rand() % images.size();
 }
 
-ShuffleImageSelector::ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect):
-  ImageSelector(pathTraverser, aspect),
+ShuffleImageSelector::ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow):
+  ImageSelector(pathTraverser, aspect, fitAspectAxisToWindow),
   current_image_shuffle(-1),
   images()
 {
@@ -141,7 +144,7 @@ ShuffleImageSelector::~ShuffleImageSelector()
 {
 }
 
-std::string ShuffleImageSelector::getNextImage()
+const std::string ShuffleImageSelector::getNextImage(ImageOptions_t &options)
 {
   if (images.size() == 0 || current_image_shuffle >= images.size())
   {
@@ -164,24 +167,28 @@ std::string ShuffleImageSelector::getNextImage()
       std::cout << "file not found: " << filename << std::endl;
     }
     current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
-    return getNextImage();
+    return getNextImage(options);
   }
-  if (!imageValidForAspect(filename))
+  options.rotation = getImageRotation(filename);
+  if (!imageValidForAspect(filename, options.rotation))
   {
     if(debugMode)
     {
       std::cout << "image has invalid aspect: " << filename << "(images left:" << (images.size()-current_image_shuffle) << ")" << std::endl;
     }
     current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
-    return getNextImage();
+    return getNextImage(options);
   }
   std::cout << "updating image: " << filename << std::endl;
   current_image_shuffle = current_image_shuffle + 1;
+  options.aspect = aspect;
+  options.fitAspectAxisToWindow = fitAspectAxisToWindow;
+  pathTraverser->UpdateOptionsForImage(filename, options);
   return filename;
 }
 
-SortedImageSelector::SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect):
-  ImageSelector(pathTraverser, aspect),
+SortedImageSelector::SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow):
+  ImageSelector(pathTraverser, aspect, fitAspectAxisToWindow),
   images()
 {
   srand (time(NULL));
@@ -203,7 +210,7 @@ bool operator<(const QString& lhs, const QString& rhs) noexcept{
 
 }
 
-std::string SortedImageSelector::getNextImage()
+const std::string SortedImageSelector::getNextImage(ImageOptions_t &options)
 {
   if (images.size() == 0)
   {
@@ -229,17 +236,21 @@ std::string SortedImageSelector::getNextImage()
     {
       std::cout << "file not found: " << filename << std::endl;
     }
-    return getNextImage();
+    return getNextImage(options);
   }
-  if (!imageValidForAspect(filename))
+  options.rotation = getImageRotation(filename);
+  if (!imageValidForAspect(filename, options.rotation))
   {
     if(debugMode)
     {
       std::cout << "image has invalid aspect: " << filename << std::endl;
     }
-    return getNextImage();
+    return getNextImage(options);
   }
 
   std::cout << "updating image: " << filename << std::endl;
+  options.aspect = aspect;
+  options.fitAspectAxisToWindow = fitAspectAxisToWindow;
+  pathTraverser->UpdateOptionsForImage(filename, options);
   return filename;
 }
diff --git a/src/imageselector.h b/src/imageselector.h
index 645f5af..1c4093b 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -8,28 +8,36 @@
 class MainWindow;
 class PathTraverser;
 
+struct ImageOptions_t
+{
+    char aspect;
+    bool fitAspectAxisToWindow;
+    int rotation;
+};
+
 class ImageSelector
 {
 public:
-    ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspectIn);
+    ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspectIn, bool fitAspectAxisToWindow);
     virtual ~ImageSelector();
-    virtual std::string getNextImage() = 0;
+    virtual const std::string getNextImage(ImageOptions_t &options) = 0;
     void setDebugMode(bool debugModeIn) { debugMode = debugModeIn;}
 
 protected:
     int getImageRotation(const std::string &fileName);
-    bool imageValidForAspect(const std::string &fileName);
+    bool imageValidForAspect(const std::string &fileName, const int rotation);
     std::unique_ptr<PathTraverser>& pathTraverser;
     char aspect;
+    bool fitAspectAxisToWindow = false;
     bool debugMode = false;
 };
 
 class RandomImageSelector : public ImageSelector
 {
 public:
-    RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect);
+    RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow);
     virtual ~RandomImageSelector();
-    virtual std::string getNextImage();
+    virtual const std::string getNextImage(ImageOptions_t &options);
 
 private:
     unsigned int selectRandom(const QStringList& images) const;
@@ -38,9 +46,9 @@ private:
 class ShuffleImageSelector : public ImageSelector
 {
 public:
-    ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect);
+    ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow);
     virtual ~ShuffleImageSelector();
-    virtual std::string getNextImage();
+    virtual const std::string getNextImage(ImageOptions_t &options);
 
 private:
     int current_image_shuffle;
@@ -50,9 +58,9 @@ private:
 class SortedImageSelector : public ImageSelector
 {
 public:
-    SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect);
+    SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow);
     virtual ~SortedImageSelector();
-    virtual std::string getNextImage();
+    virtual const std::string getNextImage(ImageOptions_t &options);
 
 private:
     QStringList images;
diff --git a/src/imageswitcher.cpp b/src/imageswitcher.cpp
index 5e57331..1a0b8e2 100644
--- a/src/imageswitcher.cpp
+++ b/src/imageswitcher.cpp
@@ -21,7 +21,8 @@ ImageSwitcher::ImageSwitcher(MainWindow& w, unsigned int timeout, std::unique_pt
 
 void ImageSwitcher::updateImage()
 {
-    std::string filename(selector->getNextImage());
+    ImageOptions_t options;
+    std::string filename(selector->getNextImage(options));
     if (filename == "")
     {
       window.warn("No image found.");
@@ -29,7 +30,7 @@ void ImageSwitcher::updateImage()
     }
     else
     {
-      window.setImage(filename);
+      window.setImage(filename, options);
       timerNoContent.stop(); // we have loaded content so stop the fast polling
     }
 }
diff --git a/src/main.cpp b/src/main.cpp
index 871cb9f..7d25f5b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -116,29 +116,29 @@ int main(int argc, char *argv[])
   std::unique_ptr<PathTraverser> pathTraverser;
   if (!imageList.empty())
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(imageList));
+    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(imageList, debugMode));
   }
   else if (recursive)
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path));
+    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path, debugMode));
   }
   else
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(path));
+    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(path, debugMode));
   }
 
   std::unique_ptr<ImageSelector> selector;
   if (sorted)
   {
-    selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser, aspect));
+    selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser, aspect, fitAspectAxisToWindow));
   }
   else if (shuffle)
   {
-    selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser, aspect));
+    selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser, aspect, fitAspectAxisToWindow));
   }
   else
   {
-    selector = std::unique_ptr<ImageSelector>(new RandomImageSelector(pathTraverser, aspect));
+    selector = std::unique_ptr<ImageSelector>(new RandomImageSelector(pathTraverser, aspect, fitAspectAxisToWindow));
   }
   selector->setDebugMode(debugMode);
   if(debugMode)
@@ -149,9 +149,7 @@ int main(int argc, char *argv[])
   Overlay o(overlay);
   o.setDebugMode(debugMode);
   w.setOverlay(&o);
-  w.setAspect(aspect);
   w.setDebugMode(debugMode);
-  w.setFitAspectAxisToWindow(fitAspectAxisToWindow);
   w.show();
 
   ImageSwitcher switcher(w, rotationSeconds * 1000, selector);
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 804a212..ae927dd 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -53,47 +53,13 @@ void MainWindow::resizeEvent(QResizeEvent* event)
    updateImage(true);
 }
 
-void MainWindow::setImage(std::string path)
+void MainWindow::setImage(const std::string& path, const ImageOptions_t& options)
 {
     currentImage = path;
+    imageOptions = options;
     updateImage(false);
 }
 
-int MainWindow::getImageRotation()
-{
-    if (currentImage == "")
-        return 0;
-
-    int orientation = 0;
-    ExifData *exifData = exif_data_new_from_file(currentImage.c_str());
-    if (exifData)
-    {
-      ExifByteOrder byteOrder = exif_data_get_byte_order(exifData);
-      ExifEntry *exifEntry = exif_data_get_entry(exifData, EXIF_TAG_ORIENTATION);
-
-      if (exifEntry)
-      {
-        orientation = exif_get_short(exifEntry->data, byteOrder);
-      }
-      exif_data_free(exifData);
-    }
-
-    int degrees = 0;
-    switch(orientation) {
-        case 8:
-        degrees = 270;
-        break;
-        case 3:
-        degrees = 180;
-        break;
-        case 6:
-        degrees = 90;
-        break;
-    }
-
-    return degrees;
-}
-
 void MainWindow::updateImage(bool immediately)
 {
     if (currentImage == "")
@@ -184,11 +150,6 @@ void MainWindow::setOverlay(Overlay* o)
   overlay = o;
 }
 
-void MainWindow::setAspect(char aspectIn)
-{
-  aspect = aspectIn;
-}
-
 QPixmap MainWindow::getBlurredBackground(const QPixmap& originalSize, const QPixmap& scaled)
 {
     if (scaled.width() < width()) {
@@ -206,21 +167,21 @@ QPixmap MainWindow::getBlurredBackground(const QPixmap& originalSize, const QPix
 QPixmap MainWindow::getRotatedPixmap(const QPixmap& p)
 {
     QMatrix matrix;
-    matrix.rotate(getImageRotation());
+    matrix.rotate(imageOptions.rotation);
     return p.transformed(matrix);
 }
 
 QPixmap MainWindow::getScaledPixmap(const QPixmap& p)
 {
-  if (fitAspectAxisToWindow)
+  if (imageOptions.fitAspectAxisToWindow)
   {
-    if ( aspect == 'p')
+    if (imageOptions.aspect == 'p')
     {
       // potrait mode, make height of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToHeight(height(), Qt::SmoothTransformation);
       return pTemp.copy(0,0,width(),height());
     }
-    else if ( aspect == 'l')
+    else if (imageOptions.aspect == 'l')
     {
       // landscape mode, make width of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToWidth(width(), Qt::SmoothTransformation);
diff --git a/src/mainwindow.h b/src/mainwindow.h
index d83f436..464c648 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -3,6 +3,7 @@
 
 #include <QMainWindow>
 #include <QPixmap>
+#include "imageselector.h"
 
 namespace Ui {
 class MainWindow;
@@ -20,23 +21,20 @@ public:
     void keyPressEvent(QKeyEvent* event);
     void resizeEvent(QResizeEvent* event);
     ~MainWindow();
-    void setImage(std::string path);
+    void setImage(const std::string& path, const ImageOptions_t &options);
     void setBlurRadius(unsigned int blurRadius);
     void setBackgroundOpacity(unsigned int opacity);
     void warn(std::string text);
     void setOverlay(Overlay* overlay);
-    void setAspect(char aspectIn);
     void setDebugMode(bool debugModeIn) {debugMode = debugModeIn;}
-    void setFitAspectAxisToWindow(bool fitAspectAxisToWindowIn) { fitAspectAxisToWindow = fitAspectAxisToWindowIn; }
 private:
     Ui::MainWindow *ui;
 
     std::string currentImage;
     unsigned int blurRadius = 20;
     unsigned int backgroundOpacity = 150;
-    char aspect = 'a';
+    ImageOptions_t imageOptions;
     bool debugMode = false;
-    bool fitAspectAxisToWindow = false;
 
     Overlay* overlay;
 
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index bb20a0f..488381f 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -4,11 +4,16 @@
 #include <QTimer>
 #include <QApplication>
 #include <QDir>
+#include <QFileInfo>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
 #include <iostream>
 #include <stdlib.h>     /* srand, rand */
+#define UNUSED(x) (void)(x)
 
-PathTraverser::PathTraverser(const std::string path):
-  path(path)
+PathTraverser::PathTraverser(const std::string path, bool debugModeIn):
+  path(path), debugMode(debugModeIn)
 {}
 
 PathTraverser::~PathTraverser() {}
@@ -20,8 +25,38 @@ QStringList PathTraverser::getImageFormats() const {
   return imageFormats;
 }
 
-RecursivePathTraverser::RecursivePathTraverser(const std::string path):
-  PathTraverser(path)
+void PathTraverser::LoadOptionsForDirectory(const std::string &directoryPath, ImageOptions_t &options) const
+{
+  QDir directory(directoryPath.c_str());
+  QString jsonFile = directory.filePath(QString("options.json"));
+  if(directory.exists(jsonFile))
+  {
+    if(debugMode)
+    {
+      std::cout << "Found options file" << std::endl;
+    }
+    QString val;
+    QFile file;
+    file.setFileName(jsonFile);
+    file.open(QIODevice::ReadOnly | QIODevice::Text);
+    val = file.readAll();
+    file.close();
+    QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
+    QJsonObject jsonDoc = d.object();
+    if(jsonDoc.contains("fitAspectAxisToWindow") && jsonDoc["fitAspectAxisToWindow"].isBool())
+    {
+      options.fitAspectAxisToWindow = jsonDoc["fitAspectAxisToWindow"].toBool();
+      if(debugMode)
+      {
+        std::cout << "Fit Aspect:" << options.fitAspectAxisToWindow << std::endl;
+      }
+    }
+    // read json
+  }
+}
+
+RecursivePathTraverser::RecursivePathTraverser(const std::string path,bool debugMode):
+  PathTraverser(path,debugMode)
 {}
 
 RecursivePathTraverser::~RecursivePathTraverser() {}
@@ -44,8 +79,14 @@ const std::string RecursivePathTraverser::getImagePath(const std::string image)
   return image;
 }
 
-DefaultPathTraverser::DefaultPathTraverser(const std::string path):
-  PathTraverser(path),
+void RecursivePathTraverser::UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const
+{
+  QDir d = QFileInfo(filename.c_str()).absoluteDir();
+  LoadOptionsForDirectory(d.absolutePath().toStdString(), options);
+}
+
+DefaultPathTraverser::DefaultPathTraverser(const std::string path,bool debugMode):
+  PathTraverser(path,debugMode),
   directory(path.c_str())
 {}
 
@@ -62,9 +103,14 @@ const std::string DefaultPathTraverser::getImagePath(const std::string image) co
   return directory.filePath(QString(image.c_str())).toStdString();
 }
 
+void DefaultPathTraverser::UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const
+{
+  UNUSED(filename);
+  LoadOptionsForDirectory(directory.absolutePath().toStdString(), options);
+}
 
-ImageListPathTraverser::ImageListPathTraverser(const std::string &imageListString):
-  PathTraverser("")
+ImageListPathTraverser::ImageListPathTraverser(const std::string &imageListString,bool debugMode):
+  PathTraverser("",debugMode)
 {
   QString str = QString(imageListString.c_str());
   imageList = str.split(QLatin1Char(','));
@@ -81,4 +127,11 @@ QStringList ImageListPathTraverser::getImages() const
 const std::string ImageListPathTraverser::getImagePath(const std::string image) const
 {
   return image;
-}
\ No newline at end of file
+}
+
+void ImageListPathTraverser::UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const
+{
+  // no per file options modification supported
+  UNUSED(filename);
+  UNUSED(options);
+}
diff --git a/src/pathtraverser.h b/src/pathtraverser.h
index 8d32e08..976969d 100644
--- a/src/pathtraverser.h
+++ b/src/pathtraverser.h
@@ -4,6 +4,7 @@
 #include <iostream>
 #include <QDir>
 #include <QStringList>
+#include "imageselector.h"
 
 static const QStringList supportedFormats={"jpg","jpeg","png","tif","tiff"};
 
@@ -11,32 +12,37 @@ class MainWindow;
 class PathTraverser
 {
   public:
-    PathTraverser(const std::string path);
+    PathTraverser(const std::string path, bool debugModeIn);
     virtual ~PathTraverser();
     virtual QStringList getImages() const = 0;
     virtual const std::string getImagePath(const std::string image) const = 0;
+    virtual void UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const = 0;
 
   protected:
     const std::string path;
+    bool debugMode = false;
     QStringList getImageFormats() const;
+    void LoadOptionsForDirectory(const std::string &directoryPath, ImageOptions_t &options) const;
 };
 
 class RecursivePathTraverser : public PathTraverser
 {
   public:
-    RecursivePathTraverser(const std::string path);
+    RecursivePathTraverser(const std::string path, bool debugModeIn);
     virtual ~RecursivePathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
+    virtual void UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const;
 };
 
 class DefaultPathTraverser : public PathTraverser
 {
   public:
-    DefaultPathTraverser(const std::string path);
+    DefaultPathTraverser(const std::string path, bool debugModeIn);
     virtual ~DefaultPathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
+    virtual void UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const;
   private:
     QDir directory;
 };
@@ -44,10 +50,11 @@ class DefaultPathTraverser : public PathTraverser
 class ImageListPathTraverser : public PathTraverser
 {
   public:
-    ImageListPathTraverser(const std::string &imageListString);
+    ImageListPathTraverser(const std::string &imageListString, bool debugModeIn);
     virtual ~ImageListPathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
+    virtual void UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const;
   private:
     QStringList imageList;
 };

From ceaae5fcc9722a0935f0a73481dca8007d63e60d Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sun, 1 Aug 2021 13:49:35 +1200
Subject: [PATCH 03/30] - fixup code from master merge

---
 src/mainwindow.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index c8a23f9..3919354 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -152,7 +152,7 @@ void MainWindow::setOverlay(Overlay* o)
 
 QPixmap MainWindow::getBlurredBackground(const QPixmap& originalSize, const QPixmap& scaled)
 {
-    if (fitAspectAxisToWindow) {
+    if (imageOptions.fitAspectAxisToWindow) {
       // our scaled version will just fill the whole screen, us it directly
       return scaled.copy();
     } else if (scaled.width() < width()) {

From e09c4d4f9faa728eaf2d219767cb3598d212d8fb Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Tue, 3 Aug 2021 09:18:34 +1200
Subject: [PATCH 04/30] - fix build after merge

---
 src/imageselector.cpp | 6 +++---
 src/imageselector.h   | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index c39e6a5..3a4347d 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -50,7 +50,7 @@ int ImageSelector::getImageRotation(const std::string& fileName)
   return degrees;
 }
 
-bool ImageSelector::imageMatchesFilter(const std::string& fileName, int rotation)
+bool ImageSelector::imageMatchesFilter(const std::string& fileName, const int rotation)
 {
   if(!QFileInfo::exists(QString(fileName.c_str())))
   {
@@ -200,8 +200,8 @@ void ShuffleImageSelector::reloadImagesIfNoneLeft()
   }
 }
 
-SortedImageSelector::SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect):
-  ImageSelector(pathTraverser, aspect),
+SortedImageSelector::SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow):
+  ImageSelector(pathTraverser, aspect, fitAspectAxisToWindow),
   images()
 {
   srand (time(NULL));
diff --git a/src/imageselector.h b/src/imageselector.h
index 50207a3..38f7b2e 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -26,7 +26,7 @@ public:
 protected:
     int getImageRotation(const std::string &fileName);
     bool imageValidForAspect(const std::string &fileName, const int rotation);
-    bool imageMatchesFilter(const std::string& fileName);
+    bool imageMatchesFilter(const std::string& fileName, const int rotation);
     std::unique_ptr<PathTraverser>& pathTraverser;
     char aspect;
     bool fitAspectAxisToWindow = false;

From 096a68636cff2f3ef4637cc492ce8328d644a767 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Tue, 3 Aug 2021 14:14:11 +1200
Subject: [PATCH 05/30] - Change display options to be passed down from the
 window, and have the imageselector pass a struct back that contains image
 metadata - Added ImageDisplayOptions_t to control user controllable options
 for how we show an image (aspect filtering, stretching) - Added
 ImageDetails_t to encapsulate image metadata along with its image options

---
 src/imageselector.cpp | 232 +++++++++++++++++++++++-------------------
 src/imageselector.h   |  32 +++---
 src/imagestructs.h    |  28 +++++
 src/imageswitcher.cpp |   7 +-
 src/main.cpp          |  33 ++++--
 src/mainwindow.cpp    |  27 +++--
 src/mainwindow.h      |   9 +-
 src/pathtraverser.cpp |   8 +-
 src/pathtraverser.h   |  10 +-
 9 files changed, 225 insertions(+), 161 deletions(-)
 create mode 100644 src/imagestructs.h

diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 3a4347d..29c722a 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -12,131 +12,165 @@
 #include <algorithm>    // std::shuffle
 #include <random>       // std::default_random_engine
 
-ImageSelector::ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspectIn, bool fitAspectAxisToWindowIn):
-  pathTraverser(pathTraverser), aspect(aspectIn), fitAspectAxisToWindow(fitAspectAxisToWindowIn)
+ImageSelector::ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser):
+  pathTraverser(pathTraverser)
 {
 }
 
 ImageSelector::~ImageSelector(){}
 
-int ImageSelector::getImageRotation(const std::string& fileName)
+int ReadExifTag(ExifData* exifData, ExifTag tag, bool shortRead = false)
 {
-  int orientation = 0;
+  int value = -1;
+  ExifByteOrder byteOrder = exif_data_get_byte_order(exifData);
+  ExifEntry *exifEntry = exif_data_get_entry(exifData, tag);
+
+  if (exifEntry)
+  {
+    if (shortRead)
+    {
+      value = exif_get_short(exifEntry->data, byteOrder);
+    }
+    else
+    {
+      value = exif_get_long(exifEntry->data, byteOrder);
+    }
+  }
+  return value;
+}
+
+void ImageSelector::populateImageDetails(const std::string&fileName, ImageDetails_t &imageDetails, const ImageDisplayOptions_t &baseOptions)
+{
+  int orientation = -1;
+  int imageWidth = -1;
+  int imageHeight = -1;
   ExifData *exifData = exif_data_new_from_file(fileName.c_str());
   if (exifData)
   {
-    ExifByteOrder byteOrder = exif_data_get_byte_order(exifData);
-    ExifEntry *exifEntry = exif_data_get_entry(exifData, EXIF_TAG_ORIENTATION);
+    orientation = ReadExifTag(exifData, EXIF_TAG_ORIENTATION, true);
+
+    /*
+    // It looks like you can't trust Exif dimensions, so just forcefully load the file below
+    // try to get the image dimensions from exifData so we don't need to fully load the file
+    imageWidth = ReadExifTag(exifData, EXIF_TAG_IMAGE_WIDTH);
+    if ( imageWidth == -1)
+      imageWidth = ReadExifTag(exifData, EXIF_TAG_PIXEL_X_DIMENSION);
+
+    imageHeight = ReadExifTag(exifData, EXIF_TAG_RELATED_IMAGE_WIDTH); // means height, height is related to width
+    if ( imageHeight == -1)
+      imageHeight = ReadExifTag(exifData, EXIF_TAG_PIXEL_Y_DIMENSION);*/
 
-    if (exifEntry)
-    {
-      orientation = exif_get_short(exifEntry->data, byteOrder);
-    }
     exif_data_free(exifData);
   }
 
   int degrees = 0;
   switch(orientation) {
       case 8:
-      degrees = 270;
-      break;
+        degrees = 270;
+        break;
       case 3:
-      degrees = 180;
-      break;
+        degrees = 180;
+        break;
       case 6:
-      degrees = 90;
-      break;
+        degrees = 90;
+        break;
+      default:
+        break;
   }
-  return degrees;
-}
 
-bool ImageSelector::imageMatchesFilter(const std::string& fileName, const int rotation)
-{
-  if(!QFileInfo::exists(QString(fileName.c_str())))
+  if (imageWidth <=0 || imageHeight <=0) 
   {
-    if(debugMode)
-    {
-      std::cout << "file not found: " << fileName << std::endl;
-    }
-    return false;
+    // fallback to QPixmap to determine image size
+    QPixmap p( fileName.c_str() );
+    imageWidth = p.width();
+    imageHeight = p.height();
   }
 
-  if(!imageValidForAspect(fileName, rotation)) {
-    if(debugMode)
-    {
-      std::cout << "image aspect ratio doesn't match filter '" << aspect << "' : " << fileName << std::endl;
-    }
-    return false;
-  }
-
-  return true;
-}
-
-bool ImageSelector::imageValidForAspect(const std::string &fileName, const int rotation)
-{
-  QPixmap p( fileName.c_str() );
-  int imageWidth = p.width();
-  int imageHeight = p.height();
-  if ( rotation == 90 || rotation == 270 )
+  // if the image is rotated then swap height/width here to show displayed sizes
+  if( degrees == 90 || degrees == 270 )
   {
     std::swap(imageWidth,imageHeight);
   }
 
-  switch(aspect)
-  {
-    case 'a':
-      // allow all
-      break;
-    case 'l':
-      if ( imageWidth < imageHeight ) 
-      {
-        return false;
-      }
-      break;
-    case 'p':
-      if ( imageHeight < imageWidth ) 
-      {
-        return false;
-      }
-      break;
+  // setup the imageDetails structure
+  imageDetails.filename = fileName;
+
+  imageDetails.width = imageWidth;
+  imageDetails.height = imageHeight;
+  imageDetails.rotation = degrees;
+  if (imageWidth > imageHeight) {
+    imageDetails.aspect = EImageAspect_Landscape;
+  } else if (imageHeight > imageWidth) {
+    imageDetails.aspect = EImageAspect_Portrait;
+  } else {
+    imageDetails.aspect = EImageAspect_Any;
   }
+  imageDetails.options = baseOptions;
+}
+
+bool ImageSelector::imageMatchesFilter(const ImageDetails_t& imageDetails)
+{
+  if(!QFileInfo::exists(QString(imageDetails.filename.c_str())))
+  {
+    if(debugMode)
+    {
+      std::cout << "file not found: " << imageDetails.filename << std::endl;
+    }
+    return false;
+  }
+
+  if(!imageValidForAspect(imageDetails)) 
+  {
+    if(debugMode)
+    {
+      std::cout << "image aspect ratio doesn't match filter '" << imageDetails.options.onlyAspect << "' : " << imageDetails.filename << std::endl;
+    }
+    return false;
+  }
+
   return true;
 }
 
+bool ImageSelector::imageValidForAspect(const ImageDetails_t& imageDetails)
+{
+  if (imageDetails.options.onlyAspect == EImageAspect_Any ||
+      imageDetails.aspect == imageDetails.options.onlyAspect)
+  {
+    return true;
+  }
+  return false;
+}
 
-RandomImageSelector::RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow):
-  ImageSelector(pathTraverser, aspect, fitAspectAxisToWindow)
+
+RandomImageSelector::RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser):
+  ImageSelector(pathTraverser)
 {
   srand (time(NULL));
 }
 
 RandomImageSelector::~RandomImageSelector(){}
 
-const std::string RandomImageSelector::getNextImage(ImageOptions_t &options)
+const ImageDetails_t RandomImageSelector::getNextImage(const ImageDisplayOptions_t &baseOptions)
 {
-  std:: string filename;
+  ImageDetails_t imageDetails;
   try
   {
     QStringList images = pathTraverser->getImages();
     unsigned int selectedImage = selectRandom(images);
-    filename = pathTraverser->getImagePath(images.at(selectedImage).toStdString());
-    options.rotation = getImageRotation(filename);
-    while(!imageMatchesFilter(filename, options.rotation))
+    populateImageDetails(pathTraverser->getImagePath(images.at(selectedImage).toStdString()), imageDetails, baseOptions);
+    while(!imageMatchesFilter(imageDetails))
     {
       unsigned int selectedImage = selectRandom(images);
-      filename = pathTraverser->getImagePath(images.at(selectedImage).toStdString());
-      options.rotation = getImageRotation(filename);
+      populateImageDetails(pathTraverser->getImagePath(images.at(selectedImage).toStdString()), imageDetails, baseOptions);
     }
   }
   catch(const std::string& err) 
   {
     std::cerr << "Error: " << err << std::endl;
   }
-  std::cout << "updating image: " << filename << std::endl;
-  options.aspect = aspect;
-  options.fitAspectAxisToWindow = fitAspectAxisToWindow;
-  pathTraverser->UpdateOptionsForImage(filename, options);
-  return filename;
+  std::cout << "updating image: " << imageDetails.filename << std::endl;
+  pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
+  return imageDetails;
 }
 
 unsigned int RandomImageSelector::selectRandom(const QStringList& images) const
@@ -152,8 +186,8 @@ unsigned int RandomImageSelector::selectRandom(const QStringList& images) const
   return rand() % images.size();
 }
 
-ShuffleImageSelector::ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow):
-  ImageSelector(pathTraverser, aspect, fitAspectAxisToWindow),
+ShuffleImageSelector::ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser):
+  ImageSelector(pathTraverser),
   current_image_shuffle(-1),
   images()
 {
@@ -164,27 +198,24 @@ ShuffleImageSelector::~ShuffleImageSelector()
 {
 }
 
-const std::string ShuffleImageSelector::getNextImage(ImageOptions_t &options)
+const ImageDetails_t ShuffleImageSelector::getNextImage(const ImageDisplayOptions_t &baseOptions)
 {
   reloadImagesIfNoneLeft();
+  ImageDetails_t imageDetails;
   if (images.size() == 0)
   {
-    return "";
+    return imageDetails;
   }
-  std::string filename = pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString());
+  populateImageDetails(pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString()), imageDetails, baseOptions);
   current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
-  options.rotation = getImageRotation(filename);
-  while(!imageMatchesFilter(filename, options.rotation)) {
+  while(!imageMatchesFilter(imageDetails)) {
     reloadImagesIfNoneLeft();
-    std::string filename = pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString());
-    options.rotation = getImageRotation(filename);
+    populateImageDetails(pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString()), imageDetails,baseOptions);
     current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
   }
-  std::cout << "updating image: " << filename << std::endl;
-  options.aspect = aspect;
-  options.fitAspectAxisToWindow = fitAspectAxisToWindow;
-  pathTraverser->UpdateOptionsForImage(filename, options);
-  return filename;
+  std::cout << "updating image: " << imageDetails.filename << std::endl;
+  pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
+  return imageDetails;
 }
 
 void ShuffleImageSelector::reloadImagesIfNoneLeft()
@@ -200,8 +231,8 @@ void ShuffleImageSelector::reloadImagesIfNoneLeft()
   }
 }
 
-SortedImageSelector::SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow):
-  ImageSelector(pathTraverser, aspect, fitAspectAxisToWindow),
+SortedImageSelector::SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser):
+  ImageSelector(pathTraverser),
   images()
 {
   srand (time(NULL));
@@ -223,26 +254,23 @@ bool operator<(const QString& lhs, const QString& rhs) noexcept{
 
 }
 
-const std::string SortedImageSelector::getNextImage(ImageOptions_t &options)
+const ImageDetails_t SortedImageSelector::getNextImage(const ImageDisplayOptions_t &baseOptions)
 {
   reloadImagesIfEmpty();
+  ImageDetails_t imageDetails;
   if (images.size() == 0)
   {
-    return "";
+    return imageDetails;
   }
-  std::string filename = pathTraverser->getImagePath(images.takeFirst().toStdString());
-  options.rotation = getImageRotation(filename);
-  while(!imageMatchesFilter(filename, options.rotation)) {
+  populateImageDetails(pathTraverser->getImagePath(images.takeFirst().toStdString()), imageDetails, baseOptions);
+  while(!imageMatchesFilter(imageDetails)) {
     reloadImagesIfEmpty();
-    filename = pathTraverser->getImagePath(images.takeFirst().toStdString());
-    options.rotation = getImageRotation(filename);
+    populateImageDetails(pathTraverser->getImagePath(images.takeFirst().toStdString()), imageDetails, baseOptions);
   }
 
-  std::cout << "updating image: " << filename << std::endl;
-  options.aspect = aspect;
-  options.fitAspectAxisToWindow = fitAspectAxisToWindow;
-  pathTraverser->UpdateOptionsForImage(filename, options);
-  return filename;
+  std::cout << "updating image: " << imageDetails.filename << std::endl;
+  pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
+  return imageDetails;
 }
 
 void SortedImageSelector::reloadImagesIfEmpty()
diff --git a/src/imageselector.h b/src/imageselector.h
index 38f7b2e..6d4c5f1 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -4,41 +4,33 @@
 #include <iostream>
 #include <memory>
 #include <QStringList>
+#include "imagestructs.h"
 
 class MainWindow;
 class PathTraverser;
 
-struct ImageOptions_t
-{
-    char aspect;
-    bool fitAspectAxisToWindow;
-    int rotation;
-};
-
 class ImageSelector
 {
 public:
-    ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspectIn, bool fitAspectAxisToWindow);
+    ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
     virtual ~ImageSelector();
-    virtual const std::string getNextImage(ImageOptions_t &options) = 0;
+    virtual const ImageDetails_t getNextImage(const ImageDisplayOptions_t &baseOptions) = 0;
     void setDebugMode(bool debugModeIn) { debugMode = debugModeIn;}
 
 protected:
-    int getImageRotation(const std::string &fileName);
-    bool imageValidForAspect(const std::string &fileName, const int rotation);
-    bool imageMatchesFilter(const std::string& fileName, const int rotation);
+    void populateImageDetails(const std::string&filename, ImageDetails_t &imageDetails, const ImageDisplayOptions_t &baseOptions);
+    bool imageValidForAspect(const ImageDetails_t& imageDetails);
+    bool imageMatchesFilter(const ImageDetails_t& imageDetails);
     std::unique_ptr<PathTraverser>& pathTraverser;
-    char aspect;
-    bool fitAspectAxisToWindow = false;
     bool debugMode = false;
 };
 
 class RandomImageSelector : public ImageSelector
 {
 public:
-    RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow);
+    RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
     virtual ~RandomImageSelector();
-    virtual const std::string getNextImage(ImageOptions_t &options);
+    virtual const ImageDetails_t getNextImage(const ImageDisplayOptions_t &baseOptions);
 
 private:
     unsigned int selectRandom(const QStringList& images) const;
@@ -47,9 +39,9 @@ private:
 class ShuffleImageSelector : public ImageSelector
 {
 public:
-    ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow);
+    ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
     virtual ~ShuffleImageSelector();
-    virtual const std::string getNextImage(ImageOptions_t &options);
+    virtual const ImageDetails_t getNextImage(const ImageDisplayOptions_t &baseOptions);
 
 private:
     void reloadImagesIfNoneLeft();
@@ -60,9 +52,9 @@ private:
 class SortedImageSelector : public ImageSelector
 {
 public:
-    SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser, char aspect, bool fitAspectAxisToWindow);
+    SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
     virtual ~SortedImageSelector();
-    virtual const std::string getNextImage(ImageOptions_t &options);
+    virtual const ImageDetails_t getNextImage(const ImageDisplayOptions_t &baseOptions);
 
 private:
     void reloadImagesIfEmpty();
diff --git a/src/imagestructs.h b/src/imagestructs.h
new file mode 100644
index 0000000..8356bf2
--- /dev/null
+++ b/src/imagestructs.h
@@ -0,0 +1,28 @@
+#ifndef IMAGESTRUCTS_H
+#define IMAGESTRUCTS_H
+
+#include <string>
+
+// possible aspect ratios of an image
+enum EImageAspect { EImageAspect_Landscape = 0, EImageAspect_Portrait, EImageAspect_Any };
+
+// options to consider when displaying an image
+struct ImageDisplayOptions_t
+{
+    EImageAspect onlyAspect = EImageAspect_Any;
+    bool fitAspectAxisToWindow = false;
+};
+
+// details of a particular image
+struct ImageDetails_t
+{
+    int width = 0;
+    int height = 0;
+    int rotation = 0;
+    EImageAspect aspect = EImageAspect_Any;
+    std::string filename;
+    ImageDisplayOptions_t options;
+};
+
+
+#endif // IMAGESTRUCTS_H
\ No newline at end of file
diff --git a/src/imageswitcher.cpp b/src/imageswitcher.cpp
index 1a0b8e2..89b5ab6 100644
--- a/src/imageswitcher.cpp
+++ b/src/imageswitcher.cpp
@@ -21,16 +21,15 @@ ImageSwitcher::ImageSwitcher(MainWindow& w, unsigned int timeout, std::unique_pt
 
 void ImageSwitcher::updateImage()
 {
-    ImageOptions_t options;
-    std::string filename(selector->getNextImage(options));
-    if (filename == "")
+    ImageDetails_t imageDetails = selector->getNextImage(window.getBaseOptions());
+    if (imageDetails.filename == "")
     {
       window.warn("No image found.");
       timerNoContent.start(timeoutNoContent);
     }
     else
     {
-      window.setImage(filename, options);
+      window.setImage(imageDetails);
       timerNoContent.stop(); // we have loaded content so stop the fast polling
     }
 }
diff --git a/src/main.cpp b/src/main.cpp
index 7d25f5b..ae116ff 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -31,8 +31,7 @@ int main(int argc, char *argv[])
   bool shuffle = false;
   bool sorted = false;
   bool debugMode = false;
-  char aspect = 'a';
-  bool fitAspectAxisToWindow = false;
+  ImageDisplayOptions_t baseDisplayOptions;
   std::string valid_aspects = "alp"; // all, landscape, portait
   std::string overlay = "";
   std::string imageList = ""; // comma delimited list of images to show
@@ -57,11 +56,26 @@ int main(int argc, char *argv[])
         path = optarg;
         break;
       case 'a':
-        aspect = optarg[0];
-        if ( valid_aspects.find(aspect) == std::string::npos )
+        if ( valid_aspects.find(optarg[0]) == std::string::npos )
         {
           std::cout << "Invalid Aspect option, defaulting to all" << std::endl;
-          aspect = 'a';
+          baseDisplayOptions.onlyAspect = EImageAspect_Any;
+        }
+        else
+        {
+          switch(optarg[0])
+          {
+            case 'l':
+              baseDisplayOptions.onlyAspect = EImageAspect_Landscape;
+              break;
+            case 'p':
+              baseDisplayOptions.onlyAspect = EImageAspect_Portrait;
+              break;
+            default:
+            case 'a':
+              baseDisplayOptions.onlyAspect = EImageAspect_Any;
+              break;
+          }
         }
         break;
       case 't':
@@ -103,7 +117,7 @@ int main(int argc, char *argv[])
   }
   if(stretchInt==1)
   {
-    fitAspectAxisToWindow = true;
+    baseDisplayOptions.fitAspectAxisToWindow = true;
   }
 
   if (path.empty() && imageList.empty())
@@ -130,15 +144,15 @@ int main(int argc, char *argv[])
   std::unique_ptr<ImageSelector> selector;
   if (sorted)
   {
-    selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser, aspect, fitAspectAxisToWindow));
+    selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser));
   }
   else if (shuffle)
   {
-    selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser, aspect, fitAspectAxisToWindow));
+    selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser));
   }
   else
   {
-    selector = std::unique_ptr<ImageSelector>(new RandomImageSelector(pathTraverser, aspect, fitAspectAxisToWindow));
+    selector = std::unique_ptr<ImageSelector>(new RandomImageSelector(pathTraverser));
   }
   selector->setDebugMode(debugMode);
   if(debugMode)
@@ -150,6 +164,7 @@ int main(int argc, char *argv[])
   o.setDebugMode(debugMode);
   w.setOverlay(&o);
   w.setDebugMode(debugMode);
+  w.setBaseOptions(baseDisplayOptions);
   w.show();
 
   ImageSwitcher switcher(w, rotationSeconds * 1000, selector);
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index fe2cc40..b4dbd27 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -108,16 +108,15 @@ void MainWindow::resizeEvent(QResizeEvent* event)
    updateImage(true);
 }
 
-void MainWindow::setImage(const std::string& path, const ImageOptions_t& options)
+void MainWindow::setImage(const ImageDetails_t &imageDetails)
 {
-    currentImage = path;
-    imageOptions = options;
+    currentImage = imageDetails;
     updateImage(false);
 }
 
 void MainWindow::updateImage(bool immediately)
 {
-    if (currentImage == "")
+    if (currentImage.filename == "")
       return;
 
     QLabel *label = this->findChild<QLabel*>("image");
@@ -129,7 +128,7 @@ void MainWindow::updateImage(bool immediately)
       this->setPalette(palette);
     }
 
-    QPixmap p( currentImage.c_str() );
+    QPixmap p( currentImage.filename.c_str() );
     if(debugMode)
     {
       std::cout << "size:" << p.width() << "x" << p.height() << std::endl;
@@ -142,10 +141,10 @@ void MainWindow::updateImage(bool immediately)
     
     if (overlay != NULL)
     {
-      drawText(background, overlay->getMarginTopLeft(), overlay->getFontsizeTopLeft(), overlay->getRenderedTopLeft(currentImage).c_str(), Qt::AlignTop|Qt::AlignLeft);
-      drawText(background, overlay->getMarginTopRight(), overlay->getFontsizeTopRight(), overlay->getRenderedTopRight(currentImage).c_str(), Qt::AlignTop|Qt::AlignRight);
-      drawText(background, overlay->getMarginBottomLeft(), overlay->getFontsizeBottomLeft(), overlay->getRenderedBottomLeft(currentImage).c_str(), Qt::AlignBottom|Qt::AlignLeft);
-      drawText(background, overlay->getMarginBottomRight(), overlay->getFontsizeBottomRight(), overlay->getRenderedBottomRight(currentImage).c_str(), Qt::AlignBottom|Qt::AlignRight);
+      drawText(background, overlay->getMarginTopLeft(), overlay->getFontsizeTopLeft(), overlay->getRenderedTopLeft(currentImage.filename).c_str(), Qt::AlignTop|Qt::AlignLeft);
+      drawText(background, overlay->getMarginTopRight(), overlay->getFontsizeTopRight(), overlay->getRenderedTopRight(currentImage.filename).c_str(), Qt::AlignTop|Qt::AlignRight);
+      drawText(background, overlay->getMarginBottomLeft(), overlay->getFontsizeBottomLeft(), overlay->getRenderedBottomLeft(currentImage.filename).c_str(), Qt::AlignBottom|Qt::AlignLeft);
+      drawText(background, overlay->getMarginBottomRight(), overlay->getFontsizeBottomRight(), overlay->getRenderedBottomRight(currentImage.filename).c_str(), Qt::AlignBottom|Qt::AlignRight);
       if (debugMode)
       {
         // draw a thumbnail version of the source image in the bottom left, to check for cropping issues
@@ -207,7 +206,7 @@ void MainWindow::setOverlay(Overlay* o)
 
 QPixmap MainWindow::getBlurredBackground(const QPixmap& originalSize, const QPixmap& scaled)
 {
-    if (imageOptions.fitAspectAxisToWindow) {
+    if (currentImage.options.fitAspectAxisToWindow) {
       // our scaled version will just fill the whole screen, us it directly
       return scaled.copy();
     } else if (scaled.width() < width()) {
@@ -225,21 +224,21 @@ QPixmap MainWindow::getBlurredBackground(const QPixmap& originalSize, const QPix
 QPixmap MainWindow::getRotatedPixmap(const QPixmap& p)
 {
     QMatrix matrix;
-    matrix.rotate(imageOptions.rotation);
+    matrix.rotate(currentImage.rotation);
     return p.transformed(matrix);
 }
 
 QPixmap MainWindow::getScaledPixmap(const QPixmap& p)
 {
-  if (imageOptions.fitAspectAxisToWindow)
+  if (currentImage.options.fitAspectAxisToWindow)
   {
-    if (imageOptions.aspect == 'p')
+    if (currentImage.aspect == EImageAspect_Portrait)
     {
       // potrait mode, make height of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToHeight(height(), Qt::SmoothTransformation);
       return pTemp.copy(0,0,width(),height());
     }
-    else if (imageOptions.aspect == 'l')
+    else if (currentImage.aspect == EImageAspect_Landscape)
     {
       // landscape mode, make width of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToWidth(width(), Qt::SmoothTransformation);
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 0bc6247..6c7642b 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -3,6 +3,7 @@
 
 #include <QMainWindow>
 #include <QPixmap>
+#include "imagestructs.h"
 #include "imageselector.h"
 
 namespace Ui {
@@ -22,19 +23,21 @@ public:
     bool event(QEvent* event) override;
     void resizeEvent(QResizeEvent* event) override;
     ~MainWindow();
-    void setImage(const std::string& path, const ImageOptions_t &options);
+    void setImage(const ImageDetails_t &imageDetails);
     void setBlurRadius(unsigned int blurRadius);
     void setBackgroundOpacity(unsigned int opacity);
     void warn(std::string text);
     void setOverlay(Overlay* overlay);
     void setDebugMode(bool debugModeIn) {debugMode = debugModeIn;}
+    void setBaseOptions(const ImageDisplayOptions_t &baseOptionsIn) { baseImageOptions = baseOptionsIn; }
+    const ImageDisplayOptions_t &getBaseOptions() { return baseImageOptions; }
 private:
     Ui::MainWindow *ui;
 
-    std::string currentImage;
     unsigned int blurRadius = 20;
     unsigned int backgroundOpacity = 150;
-    ImageOptions_t imageOptions;
+    ImageDisplayOptions_t baseImageOptions;
+    ImageDetails_t currentImage;
     bool debugMode = false;
 
     Overlay* overlay;
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index 488381f..b8c3b82 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -25,7 +25,7 @@ QStringList PathTraverser::getImageFormats() const {
   return imageFormats;
 }
 
-void PathTraverser::LoadOptionsForDirectory(const std::string &directoryPath, ImageOptions_t &options) const
+void PathTraverser::LoadOptionsForDirectory(const std::string &directoryPath, ImageDisplayOptions_t &options) const
 {
   QDir directory(directoryPath.c_str());
   QString jsonFile = directory.filePath(QString("options.json"));
@@ -79,7 +79,7 @@ const std::string RecursivePathTraverser::getImagePath(const std::string image)
   return image;
 }
 
-void RecursivePathTraverser::UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const
+void RecursivePathTraverser::UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const
 {
   QDir d = QFileInfo(filename.c_str()).absoluteDir();
   LoadOptionsForDirectory(d.absolutePath().toStdString(), options);
@@ -103,7 +103,7 @@ const std::string DefaultPathTraverser::getImagePath(const std::string image) co
   return directory.filePath(QString(image.c_str())).toStdString();
 }
 
-void DefaultPathTraverser::UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const
+void DefaultPathTraverser::UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const
 {
   UNUSED(filename);
   LoadOptionsForDirectory(directory.absolutePath().toStdString(), options);
@@ -129,7 +129,7 @@ const std::string ImageListPathTraverser::getImagePath(const std::string image)
   return image;
 }
 
-void ImageListPathTraverser::UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const
+void ImageListPathTraverser::UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const
 {
   // no per file options modification supported
   UNUSED(filename);
diff --git a/src/pathtraverser.h b/src/pathtraverser.h
index 976969d..60761c5 100644
--- a/src/pathtraverser.h
+++ b/src/pathtraverser.h
@@ -16,13 +16,13 @@ class PathTraverser
     virtual ~PathTraverser();
     virtual QStringList getImages() const = 0;
     virtual const std::string getImagePath(const std::string image) const = 0;
-    virtual void UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const = 0;
+    virtual void UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const = 0;
 
   protected:
     const std::string path;
     bool debugMode = false;
     QStringList getImageFormats() const;
-    void LoadOptionsForDirectory(const std::string &directoryPath, ImageOptions_t &options) const;
+    void LoadOptionsForDirectory(const std::string &directoryPath, ImageDisplayOptions_t &options) const;
 };
 
 class RecursivePathTraverser : public PathTraverser
@@ -32,7 +32,7 @@ class RecursivePathTraverser : public PathTraverser
     virtual ~RecursivePathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
-    virtual void UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const;
+    virtual void UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const;
 };
 
 class DefaultPathTraverser : public PathTraverser
@@ -42,7 +42,7 @@ class DefaultPathTraverser : public PathTraverser
     virtual ~DefaultPathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
-    virtual void UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const;
+    virtual void UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const;
   private:
     QDir directory;
 };
@@ -54,7 +54,7 @@ class ImageListPathTraverser : public PathTraverser
     virtual ~ImageListPathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
-    virtual void UpdateOptionsForImage(const std::string& filename, ImageOptions_t& options) const;
+    virtual void UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const;
   private:
     QStringList imageList;
 };

From e8e4a2a1ce42bc45781a26d366f82ab2a5d0bdc5 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Tue, 3 Aug 2021 17:56:29 +1200
Subject: [PATCH 06/30] - Add new aspect mode EImageAspect_Monitor , match the
 aspect of the monitor - Added code to make sure the QMainWindow matches the
 screen size, dynamic rotation of the monitor caused incorrect screen sizes

---
 src/imagestructs.h    |  2 +-
 src/main.cpp          |  6 ++++-
 src/mainwindow.cpp    | 52 ++++++++++++++++++++++++++++++++++++++++---
 src/mainwindow.h      | 11 +++++++--
 src/pathtraverser.cpp |  1 -
 5 files changed, 64 insertions(+), 8 deletions(-)

diff --git a/src/imagestructs.h b/src/imagestructs.h
index 8356bf2..1338dfd 100644
--- a/src/imagestructs.h
+++ b/src/imagestructs.h
@@ -4,7 +4,7 @@
 #include <string>
 
 // possible aspect ratios of an image
-enum EImageAspect { EImageAspect_Landscape = 0, EImageAspect_Portrait, EImageAspect_Any };
+enum EImageAspect { EImageAspect_Landscape = 0, EImageAspect_Portrait, EImageAspect_Any, EImageAspect_Monitor /* match monitors aspect */ };
 
 // options to consider when displaying an image
 struct ImageDisplayOptions_t
diff --git a/src/main.cpp b/src/main.cpp
index ae116ff..d636a4a 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -32,7 +32,7 @@ int main(int argc, char *argv[])
   bool sorted = false;
   bool debugMode = false;
   ImageDisplayOptions_t baseDisplayOptions;
-  std::string valid_aspects = "alp"; // all, landscape, portait
+  std::string valid_aspects = "alpm"; // all, landscape, portait
   std::string overlay = "";
   std::string imageList = ""; // comma delimited list of images to show
   int debugInt = 0;
@@ -71,6 +71,9 @@ int main(int argc, char *argv[])
             case 'p':
               baseDisplayOptions.onlyAspect = EImageAspect_Portrait;
               break;
+            case 'm':
+              baseDisplayOptions.onlyAspect = EImageAspect_Monitor;
+              break;
             default:
             case 'a':
               baseDisplayOptions.onlyAspect = EImageAspect_Any;
@@ -168,6 +171,7 @@ int main(int argc, char *argv[])
   w.show();
 
   ImageSwitcher switcher(w, rotationSeconds * 1000, selector);
+  w.setImageSwitcher(&switcher);
   switcher.start();
   return a.exec();
 }
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index b4dbd27..5094443 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1,6 +1,7 @@
 #include "mainwindow.h"
 #include "overlay.h"
 #include "ui_mainwindow.h"
+#include "imageswitcher.h"
 #include <QLabel>
 #include <QPixmap>
 #include <QBitmap>
@@ -14,6 +15,7 @@
 #include <QRect>
 #include <QGraphicsScene>
 #include <QGraphicsPixmapItem>
+#include <QDesktopWidget>
 #include <sstream>
 
 MainWindow::MainWindow(QWidget *parent) :
@@ -104,10 +106,43 @@ bool MainWindow::event(QEvent* event)
 
 void MainWindow::resizeEvent(QResizeEvent* event)
 {
-   QMainWindow::resizeEvent(event);
-   updateImage(true);
+  QMainWindow::resizeEvent(event);
+  // the window size in this event may not match the monitor size, so use QDesktopWidget to find the true monitor size
+  QDesktopWidget desktop;
+  QSize screenSize = desktop.screenGeometry(this).size();
+  bool isLandscape = screenSize.width() > screenSize.height();
+  if (imageAspectMatchesMonitor)
+  {
+    baseImageOptions.onlyAspect = isLandscape ? EImageAspect_Landscape : EImageAspect_Portrait; 
+  }
+  if(debugMode)
+  {
+    std::cout << "Got resize:" << this << " " << screenSize.width() << "," << screenSize.height() << " , is landscape? " << (isLandscape ? "y" : "n") << std::endl;
+  }
+  updateImage(true);
+  QTimer::singleShot(5, this, SLOT(checkWindowSize()));
+  if(lastScreenSize != screenSize && switcher != nullptr)
+  {
+    lastScreenSize = screenSize;
+    switcher->updateImage();
+  }
 }
 
+void MainWindow::checkWindowSize()
+{
+  QDesktopWidget desktop;
+  QRect screenSize = desktop.screenGeometry(this);
+  if(size() != screenSize.size())
+  {
+    if(debugMode)
+    {
+      std::cout << "Resizing Window" << screenSize.width() << "," << screenSize.height() << std::endl;
+    }
+    setFixedSize(screenSize.size());
+  }
+}
+
+
 void MainWindow::setImage(const ImageDetails_t &imageDetails)
 {
     currentImage = imageDetails;
@@ -116,6 +151,7 @@ void MainWindow::setImage(const ImageDetails_t &imageDetails)
 
 void MainWindow::updateImage(bool immediately)
 {
+    checkWindowSize();
     if (currentImage.filename == "")
       return;
 
@@ -131,7 +167,7 @@ void MainWindow::updateImage(bool immediately)
     QPixmap p( currentImage.filename.c_str() );
     if(debugMode)
     {
-      std::cout << "size:" << p.width() << "x" << p.height() << std::endl;
+      std::cout << "size:" << p.width() << "x" << p.height() << "(window:" << width() << "," << height() << ")" << std::endl;
     }
 
     QPixmap rotated = getRotatedPixmap(p);
@@ -302,3 +338,13 @@ void MainWindow::warn(std::string text)
   QLabel *label = this->findChild<QLabel*>("image");
   label->setText(text.c_str());
 }
+
+void MainWindow::setBaseOptions(const ImageDisplayOptions_t &baseOptionsIn) 
+{ 
+  baseImageOptions = baseOptionsIn; 
+  if(baseImageOptions.onlyAspect == EImageAspect_Monitor)
+  {
+    imageAspectMatchesMonitor = true;
+    baseImageOptions.onlyAspect = width() >= height() ? EImageAspect_Landscape : EImageAspect_Portrait;
+  }
+}
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 6c7642b..79fb59b 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -12,6 +12,7 @@ class MainWindow;
 class QLabel;
 class QKeyEvent;
 class Overlay;
+class ImageSwitcher;
 
 class MainWindow : public QMainWindow
 {
@@ -29,18 +30,24 @@ public:
     void warn(std::string text);
     void setOverlay(Overlay* overlay);
     void setDebugMode(bool debugModeIn) {debugMode = debugModeIn;}
-    void setBaseOptions(const ImageDisplayOptions_t &baseOptionsIn) { baseImageOptions = baseOptionsIn; }
+    void setBaseOptions(const ImageDisplayOptions_t &baseOptionsIn);
     const ImageDisplayOptions_t &getBaseOptions() { return baseImageOptions; }
+    void setImageSwitcher(ImageSwitcher *switcherIn) { switcher = switcherIn; }
+public slots:
+    void checkWindowSize();
 private:
     Ui::MainWindow *ui;
 
     unsigned int blurRadius = 20;
     unsigned int backgroundOpacity = 150;
     ImageDisplayOptions_t baseImageOptions;
+    bool imageAspectMatchesMonitor = false;
     ImageDetails_t currentImage;
     bool debugMode = false;
+    QSize lastScreenSize = {0,0};
 
-    Overlay* overlay;
+    Overlay* overlay = nullptr;
+    ImageSwitcher *switcher = nullptr;
 
     void drawText(QPixmap& image, int margin, int fontsize, QString text, int alignment);
 
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index b8c3b82..c901f21 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -51,7 +51,6 @@ void PathTraverser::LoadOptionsForDirectory(const std::string &directoryPath, Im
         std::cout << "Fit Aspect:" << options.fitAspectAxisToWindow << std::endl;
       }
     }
-    // read json
   }
 }
 

From ceadcf7a544428d6c5cf6dac9cfeaef0dbe02bf5 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Thu, 5 Aug 2021 11:54:39 +1200
Subject: [PATCH 07/30] - Update docs with new monitor aspect ratio details

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 566c6ac..e1aa39a 100644
--- a/README.md
+++ b/README.md
@@ -26,11 +26,11 @@ slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur
 * `-s` for shuffle instead of random image rotation
 * `-S` for sorted rotation (files ordered by name, first images then subfolders)
 * `rotation_seconds(default=30)`: time until next random image is chosen from the given folder
-* `aspect(default=a)`: the required aspect ratio of the picture to display. Valid values are 'a' (all), 'l' (landscape) and 'p' (portrait)
+* `aspect(default=a)`: the required aspect ratio of the picture to display. Valid values are 'a' (all), 'l' (landscape), 'p' (portrait) and 'm' (monitor). Monitor will match the aspect ratio of the display we are running on.
 * `background_opacity(default=150)`: opacity of the background filling image between 0 (black background) and 255
 * `blur_radius(default=20)`: blur radius of the background filling image
 * `-v` or `--verbose`: Verbose debug output when running, plus a thumbnail of the original image in the bottom left of the screen
-* `--stretch`: When in aspect mode 'l' or 'p' crop the image rather than leaving a blurred background. For example, in landscape mode this will make images as wide as the screen and crop the top and bottom to fit.
+* `--stretch`: When in aspect mode 'l','p' or 'm' crop the image rather than leaving a blurred background. For example, in landscape mode this will make images as wide as the screen and crop the top and bottom to fit.
 * `-O` is used to create a overlay string.
   * It defines overlays for all four edges in the order `top-left;top-right;bottom-left;bottom-right`
   * All edges overlays are separated by `;`

From eac73d618bd072ed56401448b0a76f781d5b8ed3 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Thu, 5 Aug 2021 19:50:07 +1200
Subject: [PATCH 08/30] - Remove _t postfix from struct defns - Remove inline
 header function definitions - Change assorted functions to return structs
 rather than modifying an argument

---
 src/imageselector.cpp | 51 ++++++++++++++++++++++++-------------------
 src/imageselector.h   | 16 +++++++-------
 src/imagestructs.h    | 12 +++++-----
 src/imageswitcher.cpp |  2 +-
 src/main.cpp          | 12 +++++-----
 src/mainwindow.cpp    | 29 ++++++++++++++++++------
 src/mainwindow.h      | 14 ++++++------
 src/overlay.cpp       |  5 +++++
 src/overlay.h         |  2 +-
 src/pathtraverser.cpp | 17 +++++++++------
 src/pathtraverser.h   | 10 ++++-----
 11 files changed, 100 insertions(+), 70 deletions(-)

diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 29c722a..961c1e6 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -19,6 +19,11 @@ ImageSelector::ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser):
 
 ImageSelector::~ImageSelector(){}
 
+void ImageSelector::setDebugMode(bool debugModeIn) 
+{ 
+  debugMode = debugModeIn;
+}
+
 int ReadExifTag(ExifData* exifData, ExifTag tag, bool shortRead = false)
 {
   int value = -1;
@@ -39,8 +44,9 @@ int ReadExifTag(ExifData* exifData, ExifTag tag, bool shortRead = false)
   return value;
 }
 
-void ImageSelector::populateImageDetails(const std::string&fileName, ImageDetails_t &imageDetails, const ImageDisplayOptions_t &baseOptions)
+ImageDetails ImageSelector::populateImageDetails(const std::string&fileName, const ImageDisplayOptions &baseOptions)
 {
+  ImageDetails imageDetails;
   int orientation = -1;
   int imageWidth = -1;
   int imageHeight = -1;
@@ -99,16 +105,17 @@ void ImageSelector::populateImageDetails(const std::string&fileName, ImageDetail
   imageDetails.height = imageHeight;
   imageDetails.rotation = degrees;
   if (imageWidth > imageHeight) {
-    imageDetails.aspect = EImageAspect_Landscape;
+    imageDetails.aspect = ImageAspect_Landscape;
   } else if (imageHeight > imageWidth) {
-    imageDetails.aspect = EImageAspect_Portrait;
+    imageDetails.aspect = ImageAspect_Portrait;
   } else {
-    imageDetails.aspect = EImageAspect_Any;
+    imageDetails.aspect = ImageAspect_Any;
   }
   imageDetails.options = baseOptions;
+  return imageDetails;
 }
 
-bool ImageSelector::imageMatchesFilter(const ImageDetails_t& imageDetails)
+bool ImageSelector::imageMatchesFilter(const ImageDetails& imageDetails)
 {
   if(!QFileInfo::exists(QString(imageDetails.filename.c_str())))
   {
@@ -131,9 +138,9 @@ bool ImageSelector::imageMatchesFilter(const ImageDetails_t& imageDetails)
   return true;
 }
 
-bool ImageSelector::imageValidForAspect(const ImageDetails_t& imageDetails)
+bool ImageSelector::imageValidForAspect(const ImageDetails& imageDetails)
 {
-  if (imageDetails.options.onlyAspect == EImageAspect_Any ||
+  if (imageDetails.options.onlyAspect == ImageAspect_Any ||
       imageDetails.aspect == imageDetails.options.onlyAspect)
   {
     return true;
@@ -150,18 +157,18 @@ RandomImageSelector::RandomImageSelector(std::unique_ptr<PathTraverser>& pathTra
 
 RandomImageSelector::~RandomImageSelector(){}
 
-const ImageDetails_t RandomImageSelector::getNextImage(const ImageDisplayOptions_t &baseOptions)
+const ImageDetails RandomImageSelector::getNextImage(const ImageDisplayOptions &baseOptions)
 {
-  ImageDetails_t imageDetails;
+  ImageDetails imageDetails;
   try
   {
     QStringList images = pathTraverser->getImages();
     unsigned int selectedImage = selectRandom(images);
-    populateImageDetails(pathTraverser->getImagePath(images.at(selectedImage).toStdString()), imageDetails, baseOptions);
+    imageDetails = populateImageDetails(pathTraverser->getImagePath(images.at(selectedImage).toStdString()), baseOptions);
     while(!imageMatchesFilter(imageDetails))
     {
       unsigned int selectedImage = selectRandom(images);
-      populateImageDetails(pathTraverser->getImagePath(images.at(selectedImage).toStdString()), imageDetails, baseOptions);
+      imageDetails = populateImageDetails(pathTraverser->getImagePath(images.at(selectedImage).toStdString()), baseOptions);
     }
   }
   catch(const std::string& err) 
@@ -169,7 +176,7 @@ const ImageDetails_t RandomImageSelector::getNextImage(const ImageDisplayOptions
     std::cerr << "Error: " << err << std::endl;
   }
   std::cout << "updating image: " << imageDetails.filename << std::endl;
-  pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
+  imageDetails.options = pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
   return imageDetails;
 }
 
@@ -198,23 +205,23 @@ ShuffleImageSelector::~ShuffleImageSelector()
 {
 }
 
-const ImageDetails_t ShuffleImageSelector::getNextImage(const ImageDisplayOptions_t &baseOptions)
+const ImageDetails ShuffleImageSelector::getNextImage(const ImageDisplayOptions &baseOptions)
 {
   reloadImagesIfNoneLeft();
-  ImageDetails_t imageDetails;
+  ImageDetails imageDetails;
   if (images.size() == 0)
   {
     return imageDetails;
   }
-  populateImageDetails(pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString()), imageDetails, baseOptions);
+  imageDetails = populateImageDetails(pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString()), baseOptions);
   current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
   while(!imageMatchesFilter(imageDetails)) {
     reloadImagesIfNoneLeft();
-    populateImageDetails(pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString()), imageDetails,baseOptions);
+    imageDetails = populateImageDetails(pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString()),baseOptions);
     current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
   }
   std::cout << "updating image: " << imageDetails.filename << std::endl;
-  pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
+  imageDetails.options = pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
   return imageDetails;
 }
 
@@ -254,22 +261,22 @@ bool operator<(const QString& lhs, const QString& rhs) noexcept{
 
 }
 
-const ImageDetails_t SortedImageSelector::getNextImage(const ImageDisplayOptions_t &baseOptions)
+const ImageDetails SortedImageSelector::getNextImage(const ImageDisplayOptions &baseOptions)
 {
   reloadImagesIfEmpty();
-  ImageDetails_t imageDetails;
+  ImageDetails imageDetails;
   if (images.size() == 0)
   {
     return imageDetails;
   }
-  populateImageDetails(pathTraverser->getImagePath(images.takeFirst().toStdString()), imageDetails, baseOptions);
+  imageDetails = populateImageDetails(pathTraverser->getImagePath(images.takeFirst().toStdString()), baseOptions);
   while(!imageMatchesFilter(imageDetails)) {
     reloadImagesIfEmpty();
-    populateImageDetails(pathTraverser->getImagePath(images.takeFirst().toStdString()), imageDetails, baseOptions);
+    imageDetails = populateImageDetails(pathTraverser->getImagePath(images.takeFirst().toStdString()), baseOptions);
   }
 
   std::cout << "updating image: " << imageDetails.filename << std::endl;
-  pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
+  imageDetails.options = pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
   return imageDetails;
 }
 
diff --git a/src/imageselector.h b/src/imageselector.h
index 6d4c5f1..37182f5 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -14,13 +14,13 @@ class ImageSelector
 public:
     ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
     virtual ~ImageSelector();
-    virtual const ImageDetails_t getNextImage(const ImageDisplayOptions_t &baseOptions) = 0;
-    void setDebugMode(bool debugModeIn) { debugMode = debugModeIn;}
+    virtual const ImageDetails getNextImage(const ImageDisplayOptions &baseOptions) = 0;
+    void setDebugMode(bool debugModeIn);
 
 protected:
-    void populateImageDetails(const std::string&filename, ImageDetails_t &imageDetails, const ImageDisplayOptions_t &baseOptions);
-    bool imageValidForAspect(const ImageDetails_t& imageDetails);
-    bool imageMatchesFilter(const ImageDetails_t& imageDetails);
+    ImageDetails populateImageDetails(const std::string&filename, const ImageDisplayOptions &baseOptions);
+    bool imageValidForAspect(const ImageDetails& imageDetails);
+    bool imageMatchesFilter(const ImageDetails& imageDetails);
     std::unique_ptr<PathTraverser>& pathTraverser;
     bool debugMode = false;
 };
@@ -30,7 +30,7 @@ class RandomImageSelector : public ImageSelector
 public:
     RandomImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
     virtual ~RandomImageSelector();
-    virtual const ImageDetails_t getNextImage(const ImageDisplayOptions_t &baseOptions);
+    virtual const ImageDetails getNextImage(const ImageDisplayOptions &baseOptions);
 
 private:
     unsigned int selectRandom(const QStringList& images) const;
@@ -41,7 +41,7 @@ class ShuffleImageSelector : public ImageSelector
 public:
     ShuffleImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
     virtual ~ShuffleImageSelector();
-    virtual const ImageDetails_t getNextImage(const ImageDisplayOptions_t &baseOptions);
+    virtual const ImageDetails getNextImage(const ImageDisplayOptions &baseOptions);
 
 private:
     void reloadImagesIfNoneLeft();
@@ -54,7 +54,7 @@ class SortedImageSelector : public ImageSelector
 public:
     SortedImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
     virtual ~SortedImageSelector();
-    virtual const ImageDetails_t getNextImage(const ImageDisplayOptions_t &baseOptions);
+    virtual const ImageDetails getNextImage(const ImageDisplayOptions &baseOptions);
 
 private:
     void reloadImagesIfEmpty();
diff --git a/src/imagestructs.h b/src/imagestructs.h
index 1338dfd..672528c 100644
--- a/src/imagestructs.h
+++ b/src/imagestructs.h
@@ -4,24 +4,24 @@
 #include <string>
 
 // possible aspect ratios of an image
-enum EImageAspect { EImageAspect_Landscape = 0, EImageAspect_Portrait, EImageAspect_Any, EImageAspect_Monitor /* match monitors aspect */ };
+enum ImageAspect { ImageAspect_Landscape = 0, ImageAspect_Portrait, ImageAspect_Any, ImageAspect_Monitor /* match monitors aspect */ };
 
 // options to consider when displaying an image
-struct ImageDisplayOptions_t
+struct ImageDisplayOptions
 {
-    EImageAspect onlyAspect = EImageAspect_Any;
+    ImageAspect onlyAspect = ImageAspect_Any;
     bool fitAspectAxisToWindow = false;
 };
 
 // details of a particular image
-struct ImageDetails_t
+struct ImageDetails
 {
     int width = 0;
     int height = 0;
     int rotation = 0;
-    EImageAspect aspect = EImageAspect_Any;
+    ImageAspect aspect = ImageAspect_Any;
     std::string filename;
-    ImageDisplayOptions_t options;
+    ImageDisplayOptions options;
 };
 
 
diff --git a/src/imageswitcher.cpp b/src/imageswitcher.cpp
index 89b5ab6..892bedc 100644
--- a/src/imageswitcher.cpp
+++ b/src/imageswitcher.cpp
@@ -21,7 +21,7 @@ ImageSwitcher::ImageSwitcher(MainWindow& w, unsigned int timeout, std::unique_pt
 
 void ImageSwitcher::updateImage()
 {
-    ImageDetails_t imageDetails = selector->getNextImage(window.getBaseOptions());
+    ImageDetails imageDetails = selector->getNextImage(window.getBaseOptions());
     if (imageDetails.filename == "")
     {
       window.warn("No image found.");
diff --git a/src/main.cpp b/src/main.cpp
index d636a4a..a4a31ef 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -31,7 +31,7 @@ int main(int argc, char *argv[])
   bool shuffle = false;
   bool sorted = false;
   bool debugMode = false;
-  ImageDisplayOptions_t baseDisplayOptions;
+  ImageDisplayOptions baseDisplayOptions;
   std::string valid_aspects = "alpm"; // all, landscape, portait
   std::string overlay = "";
   std::string imageList = ""; // comma delimited list of images to show
@@ -59,24 +59,24 @@ int main(int argc, char *argv[])
         if ( valid_aspects.find(optarg[0]) == std::string::npos )
         {
           std::cout << "Invalid Aspect option, defaulting to all" << std::endl;
-          baseDisplayOptions.onlyAspect = EImageAspect_Any;
+          baseDisplayOptions.onlyAspect = ImageAspect_Any;
         }
         else
         {
           switch(optarg[0])
           {
             case 'l':
-              baseDisplayOptions.onlyAspect = EImageAspect_Landscape;
+              baseDisplayOptions.onlyAspect = ImageAspect_Landscape;
               break;
             case 'p':
-              baseDisplayOptions.onlyAspect = EImageAspect_Portrait;
+              baseDisplayOptions.onlyAspect = ImageAspect_Portrait;
               break;
             case 'm':
-              baseDisplayOptions.onlyAspect = EImageAspect_Monitor;
+              baseDisplayOptions.onlyAspect = ImageAspect_Monitor;
               break;
             default:
             case 'a':
-              baseDisplayOptions.onlyAspect = EImageAspect_Any;
+              baseDisplayOptions.onlyAspect = ImageAspect_Any;
               break;
           }
         }
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 5094443..454d5c0 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -113,7 +113,7 @@ void MainWindow::resizeEvent(QResizeEvent* event)
   bool isLandscape = screenSize.width() > screenSize.height();
   if (imageAspectMatchesMonitor)
   {
-    baseImageOptions.onlyAspect = isLandscape ? EImageAspect_Landscape : EImageAspect_Portrait; 
+    baseImageOptions.onlyAspect = isLandscape ? ImageAspect_Landscape : ImageAspect_Portrait; 
   }
   if(debugMode)
   {
@@ -143,7 +143,7 @@ void MainWindow::checkWindowSize()
 }
 
 
-void MainWindow::setImage(const ImageDetails_t &imageDetails)
+void MainWindow::setImage(const ImageDetails &imageDetails)
 {
     currentImage = imageDetails;
     updateImage(false);
@@ -268,13 +268,13 @@ QPixmap MainWindow::getScaledPixmap(const QPixmap& p)
 {
   if (currentImage.options.fitAspectAxisToWindow)
   {
-    if (currentImage.aspect == EImageAspect_Portrait)
+    if (currentImage.aspect == ImageAspect_Portrait)
     {
       // potrait mode, make height of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToHeight(height(), Qt::SmoothTransformation);
       return pTemp.copy(0,0,width(),height());
     }
-    else if (currentImage.aspect == EImageAspect_Landscape)
+    else if (currentImage.aspect == ImageAspect_Landscape)
     {
       // landscape mode, make width of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToWidth(width(), Qt::SmoothTransformation);
@@ -339,12 +339,27 @@ void MainWindow::warn(std::string text)
   label->setText(text.c_str());
 }
 
-void MainWindow::setBaseOptions(const ImageDisplayOptions_t &baseOptionsIn) 
+void MainWindow::setBaseOptions(const ImageDisplayOptions &baseOptionsIn) 
 { 
   baseImageOptions = baseOptionsIn; 
-  if(baseImageOptions.onlyAspect == EImageAspect_Monitor)
+  if(baseImageOptions.onlyAspect == ImageAspect_Monitor)
   {
     imageAspectMatchesMonitor = true;
-    baseImageOptions.onlyAspect = width() >= height() ? EImageAspect_Landscape : EImageAspect_Portrait;
+    baseImageOptions.onlyAspect = width() >= height() ? ImageAspect_Landscape : ImageAspect_Portrait;
   }
 }
+
+void MainWindow::setImageSwitcher(ImageSwitcher *switcherIn)
+{
+   switcher = switcherIn; 
+}
+
+void MainWindow::setDebugMode(bool debugModeIn) 
+{
+  debugMode = debugModeIn;
+}
+
+const ImageDisplayOptions &MainWindow::getBaseOptions() 
+{
+   return baseImageOptions; 
+}
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 79fb59b..b73fe47 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -24,15 +24,15 @@ public:
     bool event(QEvent* event) override;
     void resizeEvent(QResizeEvent* event) override;
     ~MainWindow();
-    void setImage(const ImageDetails_t &imageDetails);
+    void setImage(const ImageDetails &imageDetails);
     void setBlurRadius(unsigned int blurRadius);
     void setBackgroundOpacity(unsigned int opacity);
     void warn(std::string text);
     void setOverlay(Overlay* overlay);
-    void setDebugMode(bool debugModeIn) {debugMode = debugModeIn;}
-    void setBaseOptions(const ImageDisplayOptions_t &baseOptionsIn);
-    const ImageDisplayOptions_t &getBaseOptions() { return baseImageOptions; }
-    void setImageSwitcher(ImageSwitcher *switcherIn) { switcher = switcherIn; }
+    void setDebugMode(bool debugModeIn);
+    void setBaseOptions(const ImageDisplayOptions &baseOptionsIn);
+    const ImageDisplayOptions &getBaseOptions();
+    void setImageSwitcher(ImageSwitcher *switcherIn);
 public slots:
     void checkWindowSize();
 private:
@@ -40,9 +40,9 @@ private:
 
     unsigned int blurRadius = 20;
     unsigned int backgroundOpacity = 150;
-    ImageDisplayOptions_t baseImageOptions;
+    ImageDisplayOptions baseImageOptions;
     bool imageAspectMatchesMonitor = false;
-    ImageDetails_t currentImage;
+    ImageDetails currentImage;
     bool debugMode = false;
     QSize lastScreenSize = {0,0};
 
diff --git a/src/overlay.cpp b/src/overlay.cpp
index 9d43572..f32c560 100644
--- a/src/overlay.cpp
+++ b/src/overlay.cpp
@@ -19,6 +19,11 @@ Overlay::Overlay(const std::string overlayInput):
 
 Overlay::~Overlay() {}
 
+void Overlay::setDebugMode(const bool debugModeIn) 
+{ 
+  debugMode = debugModeIn; 
+}
+
 void Overlay::parseInput() {
   QString str = QString(overlayInput.c_str());
   QStringList corners = str.split(QLatin1Char(';'));
diff --git a/src/overlay.h b/src/overlay.h
index b1cef0a..5837cba 100644
--- a/src/overlay.h
+++ b/src/overlay.h
@@ -27,7 +27,7 @@ class Overlay
     int getMarginBottomRight();
     int getFontsizeBottomRight();
 
-    void setDebugMode(const bool debugModeIn) { debugMode = debugModeIn; }
+    void setDebugMode(const bool debugModeIn);
 
   private:
     const std::string overlayInput;
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index c901f21..db2ab73 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -25,8 +25,9 @@ QStringList PathTraverser::getImageFormats() const {
   return imageFormats;
 }
 
-void PathTraverser::LoadOptionsForDirectory(const std::string &directoryPath, ImageDisplayOptions_t &options) const
+ImageDisplayOptions PathTraverser::LoadOptionsForDirectory(const std::string &directoryPath, const ImageDisplayOptions &baseOptions) const
 {
+  ImageDisplayOptions options = baseOptions;
   QDir directory(directoryPath.c_str());
   QString jsonFile = directory.filePath(QString("options.json"));
   if(directory.exists(jsonFile))
@@ -52,6 +53,7 @@ void PathTraverser::LoadOptionsForDirectory(const std::string &directoryPath, Im
       }
     }
   }
+  return options;
 }
 
 RecursivePathTraverser::RecursivePathTraverser(const std::string path,bool debugMode):
@@ -78,10 +80,10 @@ const std::string RecursivePathTraverser::getImagePath(const std::string image)
   return image;
 }
 
-void RecursivePathTraverser::UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const
+ImageDisplayOptions RecursivePathTraverser::UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const
 {
   QDir d = QFileInfo(filename.c_str()).absoluteDir();
-  LoadOptionsForDirectory(d.absolutePath().toStdString(), options);
+  return LoadOptionsForDirectory(d.absolutePath().toStdString(), baseOptions);
 }
 
 DefaultPathTraverser::DefaultPathTraverser(const std::string path,bool debugMode):
@@ -102,10 +104,10 @@ const std::string DefaultPathTraverser::getImagePath(const std::string image) co
   return directory.filePath(QString(image.c_str())).toStdString();
 }
 
-void DefaultPathTraverser::UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const
+ImageDisplayOptions DefaultPathTraverser::UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const
 {
   UNUSED(filename);
-  LoadOptionsForDirectory(directory.absolutePath().toStdString(), options);
+  return LoadOptionsForDirectory(directory.absolutePath().toStdString(), baseOptions);
 }
 
 ImageListPathTraverser::ImageListPathTraverser(const std::string &imageListString,bool debugMode):
@@ -128,9 +130,10 @@ const std::string ImageListPathTraverser::getImagePath(const std::string image)
   return image;
 }
 
-void ImageListPathTraverser::UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const
+ImageDisplayOptions ImageListPathTraverser::UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const
 {
   // no per file options modification supported
   UNUSED(filename);
-  UNUSED(options);
+  UNUSED(baseOptions);
+  return ImageDisplayOptions();
 }
diff --git a/src/pathtraverser.h b/src/pathtraverser.h
index 60761c5..7f4d921 100644
--- a/src/pathtraverser.h
+++ b/src/pathtraverser.h
@@ -16,13 +16,13 @@ class PathTraverser
     virtual ~PathTraverser();
     virtual QStringList getImages() const = 0;
     virtual const std::string getImagePath(const std::string image) const = 0;
-    virtual void UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const = 0;
+    virtual ImageDisplayOptions UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const = 0;
 
   protected:
     const std::string path;
     bool debugMode = false;
     QStringList getImageFormats() const;
-    void LoadOptionsForDirectory(const std::string &directoryPath, ImageDisplayOptions_t &options) const;
+    ImageDisplayOptions LoadOptionsForDirectory(const std::string &directoryPath, const ImageDisplayOptions &baseOptions) const;
 };
 
 class RecursivePathTraverser : public PathTraverser
@@ -32,7 +32,7 @@ class RecursivePathTraverser : public PathTraverser
     virtual ~RecursivePathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
-    virtual void UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const;
+    virtual ImageDisplayOptions UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const;
 };
 
 class DefaultPathTraverser : public PathTraverser
@@ -42,7 +42,7 @@ class DefaultPathTraverser : public PathTraverser
     virtual ~DefaultPathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
-    virtual void UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const;
+    virtual ImageDisplayOptions UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const;
   private:
     QDir directory;
 };
@@ -54,7 +54,7 @@ class ImageListPathTraverser : public PathTraverser
     virtual ~ImageListPathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
-    virtual void UpdateOptionsForImage(const std::string& filename, ImageDisplayOptions_t& options) const;
+    virtual ImageDisplayOptions UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& options) const;
   private:
     QStringList imageList;
 };

From a2c452fdcdfbb09d3be78a554835601fac15f059 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Fri, 6 Aug 2021 16:50:54 +1200
Subject: [PATCH 09/30] - Switch to using QGuiApplication::primaryScreen for
 screen size (desktopwidget is deprecated) - connect() to the geometryChanged
 and orientationChanged screen calls to detect changes

---
 src/mainwindow.cpp | 68 ++++++++++++++++++++++++++++++----------------
 1 file changed, 44 insertions(+), 24 deletions(-)

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 454d5c0..3f0ca19 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -15,7 +15,8 @@
 #include <QRect>
 #include <QGraphicsScene>
 #include <QGraphicsPixmapItem>
-#include <QDesktopWidget>
+#include <QApplication>
+#include <QScreen>
 #include <sstream>
 
 MainWindow::MainWindow(QWidget *parent) :
@@ -34,6 +35,16 @@ MainWindow::MainWindow(QWidget *parent) :
     label->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
     update();
 
+    QScreen* screen = QGuiApplication::primaryScreen();
+    if (screen)
+    {
+      connect(screen, SIGNAL(geometryChanged(QRect)), this, SLOT(checkWindowSize()));
+      connect(screen, SIGNAL(orientationChanged(Qt::ScreenOrientation)), this, SLOT(checkWindowSize()));
+      screen->setOrientationUpdateMask(Qt::LandscapeOrientation |
+                                      Qt::PortraitOrientation |
+                                      Qt::InvertedLandscapeOrientation |
+                                      Qt::InvertedPortraitOrientation);
+    }
 }
 
 MainWindow::~MainWindow()
@@ -107,38 +118,47 @@ bool MainWindow::event(QEvent* event)
 void MainWindow::resizeEvent(QResizeEvent* event)
 {
   QMainWindow::resizeEvent(event);
-  // the window size in this event may not match the monitor size, so use QDesktopWidget to find the true monitor size
-  QDesktopWidget desktop;
-  QSize screenSize = desktop.screenGeometry(this).size();
-  bool isLandscape = screenSize.width() > screenSize.height();
-  if (imageAspectMatchesMonitor)
+  // the window size in this event may not match the monitor size, so use QGuiApplication to find the true monitor size
+  QScreen *screen = QGuiApplication::primaryScreen();
+  if (screen != nullptr)
   {
-    baseImageOptions.onlyAspect = isLandscape ? ImageAspect_Landscape : ImageAspect_Portrait; 
-  }
-  if(debugMode)
-  {
-    std::cout << "Got resize:" << this << " " << screenSize.width() << "," << screenSize.height() << " , is landscape? " << (isLandscape ? "y" : "n") << std::endl;
-  }
-  updateImage(true);
-  QTimer::singleShot(5, this, SLOT(checkWindowSize()));
-  if(lastScreenSize != screenSize && switcher != nullptr)
-  {
-    lastScreenSize = screenSize;
-    switcher->updateImage();
+    QSize screenSize = screen->geometry().size();
+    bool isLandscape = screenSize.width() > screenSize.height();
+    if (imageAspectMatchesMonitor)
+    {
+      baseImageOptions.onlyAspect = isLandscape ? ImageAspect_Landscape : ImageAspect_Portrait; 
+    }
+    if(debugMode)
+    {
+      std::cout << "Got resize:" << this << " " << screenSize.width() << "," << screenSize.height() << " , is landscape? " << (isLandscape ? "y" : "n") << std::endl;
+    }
+    updateImage(true);
+    if(lastScreenSize != screenSize && switcher != nullptr)
+    {
+      lastScreenSize = screenSize;
+      if(debugMode)
+      {
+        std::cout << "Updating image due to resize" << std::endl;
+      }
+      switcher->updateImage();
+    }
   }
 }
 
 void MainWindow::checkWindowSize()
 {
-  QDesktopWidget desktop;
-  QRect screenSize = desktop.screenGeometry(this);
-  if(size() != screenSize.size())
+  QScreen *screen = QGuiApplication::primaryScreen();
+  if (screen != nullptr)
   {
-    if(debugMode)
+    QSize screenSize = screen->geometry().size();
+    if(size() != screenSize)
     {
-      std::cout << "Resizing Window" << screenSize.width() << "," << screenSize.height() << std::endl;
+      if(debugMode)
+      {
+        std::cout << "Resizing Window" << screenSize.width() << "," << screenSize.height() << std::endl;
+      }
+      setFixedSize(screenSize);
     }
-    setFixedSize(screenSize.size());
   }
 }
 

From 2e96ea48147e3ad14b07dc85b7eeb79ab4b9a369 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Fri, 6 Aug 2021 17:29:28 +1200
Subject: [PATCH 10/30] - improve support for on the fly rotation of our
 window. Schedule the image update for a future frame so we don't block right
 away and clear the current image. This also fixes loading multiple images
 during a rotation as it takes time for geometry changes to apply to QT

---
 src/imageswitcher.cpp |  6 ++++++
 src/imageswitcher.h   |  1 +
 src/mainwindow.cpp    | 49 +++++++++++++++++++++----------------------
 3 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/src/imageswitcher.cpp b/src/imageswitcher.cpp
index 892bedc..109c98e 100644
--- a/src/imageswitcher.cpp
+++ b/src/imageswitcher.cpp
@@ -41,3 +41,9 @@ void ImageSwitcher::start()
     connect(&timerNoContent, SIGNAL(timeout()), this, SLOT(updateImage()));
     timer.start(timeout);
 }
+
+void ImageSwitcher::scheduleImageUpdate()
+{
+  // update our image in 100msec, to let the system settle
+  QTimer::singleShot(100, this, SLOT(updateImage())); 
+}
\ No newline at end of file
diff --git a/src/imageswitcher.h b/src/imageswitcher.h
index f0f665c..46a79bc 100644
--- a/src/imageswitcher.h
+++ b/src/imageswitcher.h
@@ -14,6 +14,7 @@ class ImageSwitcher : public QObject
 public:
     ImageSwitcher(MainWindow& w, unsigned int timeout, std::unique_ptr<ImageSelector>& selector);
     void start();
+    void scheduleImageUpdate();
 
 public slots:
     void updateImage();
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 3f0ca19..3516333 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -118,31 +118,7 @@ bool MainWindow::event(QEvent* event)
 void MainWindow::resizeEvent(QResizeEvent* event)
 {
   QMainWindow::resizeEvent(event);
-  // the window size in this event may not match the monitor size, so use QGuiApplication to find the true monitor size
-  QScreen *screen = QGuiApplication::primaryScreen();
-  if (screen != nullptr)
-  {
-    QSize screenSize = screen->geometry().size();
-    bool isLandscape = screenSize.width() > screenSize.height();
-    if (imageAspectMatchesMonitor)
-    {
-      baseImageOptions.onlyAspect = isLandscape ? ImageAspect_Landscape : ImageAspect_Portrait; 
-    }
-    if(debugMode)
-    {
-      std::cout << "Got resize:" << this << " " << screenSize.width() << "," << screenSize.height() << " , is landscape? " << (isLandscape ? "y" : "n") << std::endl;
-    }
-    updateImage(true);
-    if(lastScreenSize != screenSize && switcher != nullptr)
-    {
-      lastScreenSize = screenSize;
-      if(debugMode)
-      {
-        std::cout << "Updating image due to resize" << std::endl;
-      }
-      switcher->updateImage();
-    }
-  }
+  updateImage(true);
 }
 
 void MainWindow::checkWindowSize()
@@ -158,6 +134,29 @@ void MainWindow::checkWindowSize()
         std::cout << "Resizing Window" << screenSize.width() << "," << screenSize.height() << std::endl;
       }
       setFixedSize(screenSize);
+      updateImage(true);
+    }
+
+    if (imageAspectMatchesMonitor)
+    {
+      bool isLandscape = screenSize.width() > screenSize.height();
+      ImageAspect newAspect = isLandscape ? ImageAspect_Landscape : ImageAspect_Portrait;
+      if (newAspect != baseImageOptions.onlyAspect)
+      {
+        if(debugMode)
+        {
+          std::cout << "Changing image orientation to " << newAspect << std::endl;
+        }
+        baseImageOptions.onlyAspect = newAspect;
+        currentImage.filename = "";
+        warn("Monitor aspect changed, updating image...");
+        repaint(); // force an immediate redraw as we might block for a while loading the next image
+        if (switcher != nullptr)
+        {
+          // pick a new image as our aspect changed, we can't just resize the image
+          switcher->scheduleImageUpdate();
+        }
+      }
     }
   }
 }

From 8ac20f4b43a26de8fab62ec3ecc5f5474a7d76fc Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Tue, 10 Aug 2021 18:20:33 +1200
Subject: [PATCH 11/30] - Add support for loading configuration via a file
 rather than the command line - Added "-c" command line option to look for
 config file "slide.options.json" in. Otherwise looks in
 ~/.config/slide/slide.options.json or /etc/slide/slide.options.json - Added
 code to reload config options at runtime (when the image is scheduled to
 update)

---
 src/imageswitcher.cpp |  21 ++-
 src/imageswitcher.h   |   8 +-
 src/main.cpp          | 308 ++++++++++++++++++++++++++++++++----------
 3 files changed, 261 insertions(+), 76 deletions(-)

diff --git a/src/imageswitcher.cpp b/src/imageswitcher.cpp
index 109c98e..603ae36 100644
--- a/src/imageswitcher.cpp
+++ b/src/imageswitcher.cpp
@@ -9,10 +9,10 @@
 #include <stdlib.h>     /* srand, rand */
 #include <time.h>       /* time */
 
-ImageSwitcher::ImageSwitcher(MainWindow& w, unsigned int timeout, std::unique_ptr<ImageSelector>& selector):
+ImageSwitcher::ImageSwitcher(MainWindow& w, unsigned int timeoutMsec, std::shared_ptr<ImageSelector>& selector):
     QObject::QObject(),
     window(w),
-    timeout(timeout),
+    timeout(timeoutMsec),
     selector(selector),
     timer(this),
     timerNoContent(this)
@@ -21,6 +21,10 @@ ImageSwitcher::ImageSwitcher(MainWindow& w, unsigned int timeout, std::unique_pt
 
 void ImageSwitcher::updateImage()
 {
+    if(reloadConfigIfNeeded)
+    {
+      reloadConfigIfNeeded();
+    }
     ImageDetails imageDetails = selector->getNextImage(window.getBaseOptions());
     if (imageDetails.filename == "")
     {
@@ -46,4 +50,15 @@ void ImageSwitcher::scheduleImageUpdate()
 {
   // update our image in 100msec, to let the system settle
   QTimer::singleShot(100, this, SLOT(updateImage())); 
-}
\ No newline at end of file
+}
+
+void ImageSwitcher::setConfigFileReloader(std::function<void()> reloadConfigIfNeededIn)
+{
+  reloadConfigIfNeeded = reloadConfigIfNeededIn;
+}
+
+void ImageSwitcher::setRotationTime(unsigned int timeoutMsecIn)
+{
+  timeout = timeoutMsecIn;
+  timer.start(timeout);
+}
diff --git a/src/imageswitcher.h b/src/imageswitcher.h
index 46a79bc..553ee74 100644
--- a/src/imageswitcher.h
+++ b/src/imageswitcher.h
@@ -5,6 +5,7 @@
 #include <QTimer>
 #include <iostream>
 #include <memory>
+#include <functional>
 
 class MainWindow;
 class ImageSelector;
@@ -12,19 +13,22 @@ class ImageSwitcher : public QObject
 {
     Q_OBJECT
 public:
-    ImageSwitcher(MainWindow& w, unsigned int timeout, std::unique_ptr<ImageSelector>& selector);
+    ImageSwitcher(MainWindow& w, unsigned int timeoutMsec, std::shared_ptr<ImageSelector>& selector);
     void start();
     void scheduleImageUpdate();
+    void setConfigFileReloader(std::function<void()> reloadConfigIfNeededIn);
+    void setRotationTime(unsigned int timeoutMsec);
 
 public slots:
     void updateImage();
 private:
     MainWindow& window;
     unsigned int timeout;
-    std::unique_ptr<ImageSelector>& selector;
+    std::shared_ptr<ImageSelector>& selector;
     QTimer timer;
     const unsigned int timeoutNoContent = 5 * 1000; // 5 sec
     QTimer timerNoContent;
+    std::function<void()> reloadConfigIfNeeded;
 };
 
 #endif // IMAGESWITCHER_H
diff --git a/src/main.cpp b/src/main.cpp
index a4a31ef..d0d3e63 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -4,6 +4,11 @@
 #include "pathtraverser.h"
 #include "overlay.h"
 #include <QApplication>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QDateTime>
+#include <QFileInfo>
 #include <iostream>
 #include <sys/file.h>
 #include <errno.h>
@@ -15,18 +20,15 @@
 #include <memory>
 
 void usage(std::string programName) {
-    std::cerr << "Usage: " << programName << " [-t rotation_seconds] [-a aspect('l','p','a')] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-s] [-v] [--verbose] [--stretch]" << std::endl;
+    std::cerr << "Usage: " << programName << " [-t rotation_seconds] [-a aspect('l','p','a', 'm')] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-s] [-v] [--verbose] [--stretch] [-c config_file_path]" << std::endl;
 }
 
-int main(int argc, char *argv[])
-{
-  unsigned int rotationSeconds = 30;
+struct Config {
   std::string path = "";
-
-  QApplication a(argc, argv);
-
-  MainWindow w;
-  int opt;
+  std::string configPath = "";
+  unsigned int rotationSeconds = 30;
+  int blurRadius = -1;
+  int backgroundOpacity = -1;
   bool recursive = false;
   bool shuffle = false;
   bool sorted = false;
@@ -35,6 +37,134 @@ int main(int argc, char *argv[])
   std::string valid_aspects = "alpm"; // all, landscape, portait
   std::string overlay = "";
   std::string imageList = ""; // comma delimited list of images to show
+  QDateTime loadTime;
+};
+
+ImageAspect parseAspectFromString(char aspect) {
+  switch(aspect)
+  {
+    case 'l':
+      return ImageAspect_Landscape;
+      break;
+    case 'p':
+      return ImageAspect_Portrait;
+      break;
+    case 'm':
+      return ImageAspect_Monitor;
+      break;
+    default:
+    case 'a':
+      return ImageAspect_Any;
+      break;
+  }
+}
+
+std::string ParseJSONString(QJsonObject jsonDoc, const char *key) {
+  if(jsonDoc.contains(key) && jsonDoc[key].isString())
+  {
+   return jsonDoc[key].toString().toStdString();
+  }
+  return "";
+}
+
+void SetJSONBool(bool &value, QJsonObject jsonDoc, const char *key) {
+  if(jsonDoc.contains(key) && jsonDoc[key].isBool())
+  {
+    value = jsonDoc[key].toBool();
+  }
+}
+
+QString getConfigFilePath(const std::string &configPath) {
+  std::string userConfigFolder = "~/.config/slide/";
+  std::string systemConfigFolder = "/etc/slide";
+  QString baseConfigFilename("slide.options.json");
+  
+  QDir directory(userConfigFolder.c_str());
+  QString jsonFile = "";
+  if (!configPath.empty())
+  { 
+    directory.setPath(configPath.c_str());
+    jsonFile = directory.filePath(baseConfigFilename);    
+  }
+   if(!directory.exists(jsonFile))
+  { 
+    directory.setPath(userConfigFolder.c_str());
+    jsonFile = directory.filePath(baseConfigFilename);    
+  }
+  if(!directory.exists(jsonFile))
+  {
+    directory.setPath(systemConfigFolder.c_str());
+    jsonFile = directory.filePath(baseConfigFilename);
+  }
+
+  if(directory.exists(jsonFile))
+  {
+    return jsonFile;
+  }
+
+  return "";
+}
+
+Config loadConfiguration(const Config &commandLineConfig) {
+  QString jsonFile = getConfigFilePath(commandLineConfig.configPath);
+  QDir directory;
+  if(!directory.exists(jsonFile))
+  {
+    return commandLineConfig; // nothing to load
+  }
+
+  Config userConfig = commandLineConfig;
+
+  if(userConfig.debugMode)
+  {
+    std::cout << "Found options file: " << jsonFile.toStdString() << std::endl;
+  }
+
+  QString val;
+  QFile file;
+  file.setFileName(jsonFile);
+  file.open(QIODevice::ReadOnly | QIODevice::Text);
+  val = file.readAll();
+  file.close();
+  QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
+  QJsonObject jsonDoc = d.object();
+  SetJSONBool(userConfig.baseDisplayOptions.fitAspectAxisToWindow, jsonDoc, "fitAspectAxisToWindow");
+  SetJSONBool(userConfig.recursive, jsonDoc, "recursive");
+  SetJSONBool(userConfig.shuffle, jsonDoc, "shuffle");
+  SetJSONBool(userConfig.debugMode, jsonDoc, "debug");
+
+  std::string aspectString = ParseJSONString(jsonDoc, "aspect");
+  if(!aspectString.empty())
+  {
+    userConfig.baseDisplayOptions.onlyAspect = parseAspectFromString(aspectString[0]);
+  }
+  if(jsonDoc.contains("rotationSeconds") && jsonDoc["rotationSeconds"].isDouble())
+  {
+    userConfig.rotationSeconds = (int)jsonDoc["rotationSeconds"].toDouble();
+  }
+
+  if(jsonDoc.contains("opacity") && jsonDoc["opacity"].isDouble())
+  {
+    userConfig.backgroundOpacity = (int)jsonDoc["opacity"].toDouble();
+  }
+
+  std::string overlayString = ParseJSONString(jsonDoc, "overlay");
+  if(!overlayString.empty())
+  {
+    userConfig.overlay = overlayString;
+  }
+  std::string pathString = ParseJSONString(jsonDoc, "path");
+  if(!pathString.empty())
+  {
+    userConfig.path = pathString;
+  }
+
+  userConfig.loadTime = QDateTime::currentDateTime();
+  return userConfig;
+}
+
+bool parseCommandLine(Config &appConfig, int argc, char *argv[]) {
+  int opt;
   int debugInt = 0;
   int stretchInt = 0;
   static struct option long_options[] =
@@ -43,135 +173,171 @@ int main(int argc, char *argv[])
     {"stretch", no_argument,       &stretchInt, 1},
   };
   int option_index = 0;
-  while ((opt = getopt_long(argc, argv, "b:p:t:o:O:a:i:rsSv", long_options, &option_index)) != -1) {
+  while ((opt = getopt_long(argc, argv, "b:p:t:o:O:a:i:c:rsSv", long_options, &option_index)) != -1) {
     switch (opt) {
       case 0:
           /* If this option set a flag, do nothing else now. */
           if (long_options[option_index].flag != 0)
             break;
-          usage(argv[0]);
-          return 1;
+          return false;
           break;
       case 'p':
-        path = optarg;
+        appConfig.path = optarg;
         break;
       case 'a':
-        if ( valid_aspects.find(optarg[0]) == std::string::npos )
+        if (appConfig.valid_aspects.find(optarg[0]) == std::string::npos)
         {
           std::cout << "Invalid Aspect option, defaulting to all" << std::endl;
-          baseDisplayOptions.onlyAspect = ImageAspect_Any;
+          appConfig.baseDisplayOptions.onlyAspect = ImageAspect_Any;
         }
         else
         {
-          switch(optarg[0])
-          {
-            case 'l':
-              baseDisplayOptions.onlyAspect = ImageAspect_Landscape;
-              break;
-            case 'p':
-              baseDisplayOptions.onlyAspect = ImageAspect_Portrait;
-              break;
-            case 'm':
-              baseDisplayOptions.onlyAspect = ImageAspect_Monitor;
-              break;
-            default:
-            case 'a':
-              baseDisplayOptions.onlyAspect = ImageAspect_Any;
-              break;
-          }
+          appConfig.baseDisplayOptions.onlyAspect = parseAspectFromString(optarg[0]);
         }
         break;
       case 't':
-        rotationSeconds = atoi(optarg);
+        appConfig.rotationSeconds = atoi(optarg);
         break;
       case 'b':
-        w.setBlurRadius(atoi(optarg));
+        appConfig.blurRadius = atoi(optarg);
         break;
       case 'o':
-        w.setBackgroundOpacity(atoi(optarg));
+        appConfig.backgroundOpacity = atoi(optarg);
         break;
       case 'r':
-        recursive = true;
+        appConfig.recursive = true;
         break;
       case 's':
-        shuffle = true;
+        appConfig.shuffle = true;
         std::cout << "Shuffle mode is on." << std::endl;
         break;
       case 'S':
-        sorted = true;
+        appConfig.sorted = true;
         break;
       case 'O':
-        overlay = optarg;
+        appConfig.overlay = optarg;
         break;
       case 'v':
-        debugMode = true;
+        appConfig.debugMode = true;
         break;
       case 'i':
-        imageList = optarg;
+        appConfig.imageList = optarg;
+        break;
+      case 'c':
+        appConfig.configPath = optarg;
         break;
       default: /* '?' */
-        usage(argv[0]);
-        return 1;
+        return false;
     }
   }
+  
   if(debugInt==1)
   {
-    debugMode = true;
+    appConfig.debugMode = true;
   }
   if(stretchInt==1)
   {
-    baseDisplayOptions.fitAspectAxisToWindow = true;
+    appConfig.baseDisplayOptions.fitAspectAxisToWindow = true;
   }
 
-  if (path.empty() && imageList.empty())
+  return true;
+}
+
+void ReloadConfigIfNeeded(Config &appConfig, MainWindow &w, ImageSwitcher &switcher, std::shared_ptr<ImageSelector> &selector)
+{  
+  QString jsonFile = getConfigFilePath(appConfig.configPath);
+  QDir directory;
+  if(!directory.exists(jsonFile))
+  {
+    return;
+  }
+
+  if(appConfig.loadTime <  QFileInfo(jsonFile).lastModified())
+  {
+    appConfig = loadConfiguration(appConfig);
+    w.setBaseOptions(appConfig.baseDisplayOptions);
+    w.setDebugMode(appConfig.debugMode);
+    selector->setDebugMode(appConfig.debugMode);
+    //Overlay o(appConfig.overlay);
+    //w.setOverlay(&o);
+    switcher.setRotationTime(appConfig.rotationSeconds * 1000);
+  }
+}
+
+int main(int argc, char *argv[])
+{
+  QApplication a(argc, argv);
+
+  MainWindow w;
+  Config commandLineAppConfig;
+  if (!parseCommandLine(commandLineAppConfig, argc, argv))
+  {
+    usage(argv[0]);
+    return 1;
+  }
+
+  Config appConfig = loadConfiguration(commandLineAppConfig);
+
+  if (appConfig.path.empty() && appConfig.imageList.empty())
   {
     std::cout << "Error: Path expected." << std::endl;
     usage(argv[0]);
     return 1;
   }
 
-  std::unique_ptr<PathTraverser> pathTraverser;
-  if (!imageList.empty())
+  if (appConfig.blurRadius>= 0)
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(imageList, debugMode));
-  }
-  else if (recursive)
-  {
-    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path, debugMode));
-  }
-  else
-  {
-    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(path, debugMode));
+    w.setBlurRadius(appConfig.blurRadius);
   }
 
-  std::unique_ptr<ImageSelector> selector;
-  if (sorted)
+  if (appConfig.backgroundOpacity>= 0)
   {
-    selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser));
+      w.setBackgroundOpacity(appConfig.backgroundOpacity);
   }
-  else if (shuffle)
+
+  std::unique_ptr<PathTraverser> pathTraverser;
+  if (!appConfig.imageList.empty())
   {
-    selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser));
+    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(appConfig.imageList, appConfig.debugMode));
+  }
+  else if (appConfig.recursive)
+  {
+    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(appConfig.path, appConfig.debugMode));
   }
   else
   {
-    selector = std::unique_ptr<ImageSelector>(new RandomImageSelector(pathTraverser));
+    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(appConfig.path, appConfig.debugMode));
   }
-  selector->setDebugMode(debugMode);
-  if(debugMode)
+
+  std::shared_ptr<ImageSelector> selector;
+  if (appConfig.sorted)
   {
-    std::cout << "Rotation Time: " << rotationSeconds << std::endl;
-    std::cout << "Overlay input: " << overlay << std::endl;
+    selector = std::shared_ptr<ImageSelector>(new SortedImageSelector(pathTraverser));
   }
-  Overlay o(overlay);
-  o.setDebugMode(debugMode);
+  else if (appConfig.shuffle)
+  {
+    selector = std::shared_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser));
+  }
+  else
+  {
+    selector = std::shared_ptr<ImageSelector>(new RandomImageSelector(pathTraverser));
+  }
+  selector->setDebugMode(appConfig.debugMode);
+  if(appConfig.debugMode)
+  {
+    std::cout << "Rotation Time: " << appConfig.rotationSeconds << std::endl;
+    std::cout << "Overlay input: " << appConfig.overlay << std::endl;
+  }
+  Overlay o(appConfig.overlay);
+  o.setDebugMode(appConfig.debugMode);
   w.setOverlay(&o);
-  w.setDebugMode(debugMode);
-  w.setBaseOptions(baseDisplayOptions);
+  w.setBaseOptions(appConfig.baseDisplayOptions);
   w.show();
 
-  ImageSwitcher switcher(w, rotationSeconds * 1000, selector);
+  ImageSwitcher switcher(w, appConfig.rotationSeconds * 1000, selector);
   w.setImageSwitcher(&switcher);
+  std::function<void()> reloader = [&appConfig, &w, &switcher, &selector]() { ReloadConfigIfNeeded(appConfig, w, switcher, selector); };
+  switcher.setConfigFileReloader(reloader);
   switcher.start();
   return a.exec();
 }

From 24a4a075932fada7a8b910879dc1fb7edb3a0cb3 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Wed, 11 Aug 2021 14:01:18 +1200
Subject: [PATCH 12/30] - Change the object ownership semantics to take
 ownership of unique_ptr's rather than references - Add helper functions for
 setting up config - Add support for dynamically updating more config options
 (path related ones in particular)

---
 src/imageselector.cpp |   4 +-
 src/imageselector.h   |   2 +-
 src/imageswitcher.cpp |  13 ++--
 src/imageswitcher.h   |  11 +--
 src/main.cpp          | 162 +++++++++++++++++++++++++-----------------
 src/mainwindow.cpp    |   6 +-
 src/mainwindow.h      |   4 +-
 7 files changed, 121 insertions(+), 81 deletions(-)

diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 961c1e6..7cdaf2d 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -12,8 +12,8 @@
 #include <algorithm>    // std::shuffle
 #include <random>       // std::default_random_engine
 
-ImageSelector::ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser):
-  pathTraverser(pathTraverser)
+ImageSelector::ImageSelector(std::unique_ptr<PathTraverser>& pathTraverserIn):
+  pathTraverser(std::move(pathTraverserIn))
 {
 }
 
diff --git a/src/imageselector.h b/src/imageselector.h
index 37182f5..128f93b 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -21,7 +21,7 @@ protected:
     ImageDetails populateImageDetails(const std::string&filename, const ImageDisplayOptions &baseOptions);
     bool imageValidForAspect(const ImageDetails& imageDetails);
     bool imageMatchesFilter(const ImageDetails& imageDetails);
-    std::unique_ptr<PathTraverser>& pathTraverser;
+    std::unique_ptr<PathTraverser> pathTraverser;
     bool debugMode = false;
 };
 
diff --git a/src/imageswitcher.cpp b/src/imageswitcher.cpp
index 603ae36..4347af2 100644
--- a/src/imageswitcher.cpp
+++ b/src/imageswitcher.cpp
@@ -9,11 +9,11 @@
 #include <stdlib.h>     /* srand, rand */
 #include <time.h>       /* time */
 
-ImageSwitcher::ImageSwitcher(MainWindow& w, unsigned int timeoutMsec, std::shared_ptr<ImageSelector>& selector):
+ImageSwitcher::ImageSwitcher(MainWindow& w, unsigned int timeoutMsec, std::unique_ptr<ImageSelector>& selector):
     QObject::QObject(),
     window(w),
     timeout(timeoutMsec),
-    selector(selector),
+    selector(std::move(selector)),
     timer(this),
     timerNoContent(this)
 {
@@ -23,7 +23,7 @@ void ImageSwitcher::updateImage()
 {
     if(reloadConfigIfNeeded)
     {
-      reloadConfigIfNeeded();
+      reloadConfigIfNeeded(window, this, selector.get());
     }
     ImageDetails imageDetails = selector->getNextImage(window.getBaseOptions());
     if (imageDetails.filename == "")
@@ -52,7 +52,7 @@ void ImageSwitcher::scheduleImageUpdate()
   QTimer::singleShot(100, this, SLOT(updateImage())); 
 }
 
-void ImageSwitcher::setConfigFileReloader(std::function<void()> reloadConfigIfNeededIn)
+void ImageSwitcher::setConfigFileReloader(std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloadConfigIfNeededIn)
 {
   reloadConfigIfNeeded = reloadConfigIfNeededIn;
 }
@@ -62,3 +62,8 @@ void ImageSwitcher::setRotationTime(unsigned int timeoutMsecIn)
   timeout = timeoutMsecIn;
   timer.start(timeout);
 }
+
+void ImageSwitcher::setImageSelector(std::unique_ptr<ImageSelector>& selectorIn)
+{
+  selector = std::move(selectorIn);
+}
diff --git a/src/imageswitcher.h b/src/imageswitcher.h
index 553ee74..ea00e49 100644
--- a/src/imageswitcher.h
+++ b/src/imageswitcher.h
@@ -6,29 +6,30 @@
 #include <iostream>
 #include <memory>
 #include <functional>
+#include "imageselector.h"
 
 class MainWindow;
-class ImageSelector;
 class ImageSwitcher : public QObject
 {
     Q_OBJECT
 public:
-    ImageSwitcher(MainWindow& w, unsigned int timeoutMsec, std::shared_ptr<ImageSelector>& selector);
+    ImageSwitcher(MainWindow& w, unsigned int timeoutMsec, std::unique_ptr<ImageSelector>& selector);
     void start();
     void scheduleImageUpdate();
-    void setConfigFileReloader(std::function<void()> reloadConfigIfNeededIn);
+    void setConfigFileReloader(std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloadConfigIfNeededIn);
     void setRotationTime(unsigned int timeoutMsec);
+    void setImageSelector(std::unique_ptr<ImageSelector>& selector);
 
 public slots:
     void updateImage();
 private:
     MainWindow& window;
     unsigned int timeout;
-    std::shared_ptr<ImageSelector>& selector;
+    std::unique_ptr<ImageSelector> selector;
     QTimer timer;
     const unsigned int timeoutNoContent = 5 * 1000; // 5 sec
     QTimer timerNoContent;
-    std::function<void()> reloadConfigIfNeeded;
+    std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloadConfigIfNeeded;
 };
 
 #endif // IMAGESWITCHER_H
diff --git a/src/main.cpp b/src/main.cpp
index d0d3e63..91c4a9f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -24,22 +24,34 @@ void usage(std::string programName) {
 }
 
 struct Config {
-  std::string path = "";
-  std::string configPath = "";
-  unsigned int rotationSeconds = 30;
-  int blurRadius = -1;
-  int backgroundOpacity = -1;
-  bool recursive = false;
-  bool shuffle = false;
-  bool sorted = false;
-  bool debugMode = false;
-  ImageDisplayOptions baseDisplayOptions;
-  std::string valid_aspects = "alpm"; // all, landscape, portait
-  std::string overlay = "";
-  std::string imageList = ""; // comma delimited list of images to show
-  QDateTime loadTime;
+  public:
+    std::string path = "";
+    std::string configPath = "";
+    unsigned int rotationSeconds = 30;
+    int blurRadius = -1;
+    int backgroundOpacity = -1;
+    bool recursive = false;
+    bool shuffle = false;
+    bool sorted = false;
+    bool debugMode = false;
+    ImageDisplayOptions baseDisplayOptions;
+    static const std::string valid_aspects; 
+    std::string overlay = "";
+    std::string imageList = ""; // comma delimited list of images to show
+    QDateTime loadTime;
+  public:
+    bool PathOptionsChanged(Config &other) {
+      if ( other.recursive != recursive || other.shuffle != shuffle
+      || other.sorted != sorted)
+        return true;
+      if ( other.path != path || other.imageList != imageList )
+        return true;
+      return false;
+    }
 };
 
+const std::string Config::valid_aspects = "alpm"; // all, landscape, portait, monitor
+
 ImageAspect parseAspectFromString(char aspect) {
   switch(aspect)
   {
@@ -243,7 +255,58 @@ bool parseCommandLine(Config &appConfig, int argc, char *argv[]) {
   return true;
 }
 
-void ReloadConfigIfNeeded(Config &appConfig, MainWindow &w, ImageSwitcher &switcher, std::shared_ptr<ImageSelector> &selector)
+void ConfigureWindowFromSettings(MainWindow &w, const Config &appConfig)
+{
+  if (appConfig.blurRadius>= 0)
+  {
+    w.setBlurRadius(appConfig.blurRadius);
+  }
+
+  if (appConfig.backgroundOpacity>= 0)
+  {
+      w.setBackgroundOpacity(appConfig.backgroundOpacity);
+  }
+  std::unique_ptr<Overlay> o = std::unique_ptr<Overlay>(new Overlay(appConfig.overlay));
+  o->setDebugMode(appConfig.debugMode);
+  w.setDebugMode(appConfig.debugMode);
+  w.setOverlay(o);
+  w.setBaseOptions(appConfig.baseDisplayOptions);
+}
+
+std::unique_ptr<ImageSelector> GetSelectorForConfig(const Config &appConfig)
+{
+  std::unique_ptr<PathTraverser> pathTraverser;
+  if (!appConfig.imageList.empty())
+  {
+    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(appConfig.imageList, appConfig.debugMode));
+  }
+  else if (appConfig.recursive)
+  {
+    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(appConfig.path, appConfig.debugMode));
+  }
+  else
+  {
+    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(appConfig.path, appConfig.debugMode));
+  }
+
+  std::unique_ptr<ImageSelector> selector;
+  if (appConfig.sorted)
+  {
+    selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser));
+  }
+  else if (appConfig.shuffle)
+  {
+    selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser));
+  }
+  else
+  {
+    selector = std::unique_ptr<ImageSelector>(new RandomImageSelector(pathTraverser));
+  }
+
+  return selector;
+}
+
+void ReloadConfigIfNeeded(Config &appConfig, MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)
 {  
   QString jsonFile = getConfigFilePath(appConfig.configPath);
   QDir directory;
@@ -254,13 +317,21 @@ void ReloadConfigIfNeeded(Config &appConfig, MainWindow &w, ImageSwitcher &switc
 
   if(appConfig.loadTime <  QFileInfo(jsonFile).lastModified())
   {
+    const std::string oldPath = appConfig.path;
+    const std::string oldImageList = appConfig.imageList;
+
+    Config oldConfig = appConfig;
     appConfig = loadConfiguration(appConfig);
-    w.setBaseOptions(appConfig.baseDisplayOptions);
-    w.setDebugMode(appConfig.debugMode);
+
+    ConfigureWindowFromSettings(w, appConfig);
+    if(appConfig.PathOptionsChanged(oldConfig))
+    {
+      std::unique_ptr<ImageSelector> selector = GetSelectorForConfig(appConfig);
+      switcher->setImageSelector(selector);
+    }
+
     selector->setDebugMode(appConfig.debugMode);
-    //Overlay o(appConfig.overlay);
-    //w.setOverlay(&o);
-    switcher.setRotationTime(appConfig.rotationSeconds * 1000);
+    switcher->setRotationTime(appConfig.rotationSeconds * 1000);
   }
 }
 
@@ -268,7 +339,6 @@ int main(int argc, char *argv[])
 {
   QApplication a(argc, argv);
 
-  MainWindow w;
   Config commandLineAppConfig;
   if (!parseCommandLine(commandLineAppConfig, argc, argv))
   {
@@ -285,58 +355,22 @@ int main(int argc, char *argv[])
     return 1;
   }
 
-  if (appConfig.blurRadius>= 0)
-  {
-    w.setBlurRadius(appConfig.blurRadius);
-  }
-
-  if (appConfig.backgroundOpacity>= 0)
-  {
-      w.setBackgroundOpacity(appConfig.backgroundOpacity);
-  }
-
-  std::unique_ptr<PathTraverser> pathTraverser;
-  if (!appConfig.imageList.empty())
-  {
-    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(appConfig.imageList, appConfig.debugMode));
-  }
-  else if (appConfig.recursive)
-  {
-    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(appConfig.path, appConfig.debugMode));
-  }
-  else
-  {
-    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(appConfig.path, appConfig.debugMode));
-  }
-
-  std::shared_ptr<ImageSelector> selector;
-  if (appConfig.sorted)
-  {
-    selector = std::shared_ptr<ImageSelector>(new SortedImageSelector(pathTraverser));
-  }
-  else if (appConfig.shuffle)
-  {
-    selector = std::shared_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser));
-  }
-  else
-  {
-    selector = std::shared_ptr<ImageSelector>(new RandomImageSelector(pathTraverser));
-  }
-  selector->setDebugMode(appConfig.debugMode);
   if(appConfig.debugMode)
   {
     std::cout << "Rotation Time: " << appConfig.rotationSeconds << std::endl;
     std::cout << "Overlay input: " << appConfig.overlay << std::endl;
   }
-  Overlay o(appConfig.overlay);
-  o.setDebugMode(appConfig.debugMode);
-  w.setOverlay(&o);
-  w.setBaseOptions(appConfig.baseDisplayOptions);
+  
+  MainWindow w;
+  ConfigureWindowFromSettings(w, appConfig);
   w.show();
 
+  std::unique_ptr<ImageSelector> selector = GetSelectorForConfig(appConfig);
+  selector->setDebugMode(appConfig.debugMode);
+  
   ImageSwitcher switcher(w, appConfig.rotationSeconds * 1000, selector);
   w.setImageSwitcher(&switcher);
-  std::function<void()> reloader = [&appConfig, &w, &switcher, &selector]() { ReloadConfigIfNeeded(appConfig, w, switcher, selector); };
+  std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloader = [&appConfig](MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector) { ReloadConfigIfNeeded(appConfig, w, switcher, selector); };
   switcher.setConfigFileReloader(reloader);
   switcher.start();
   return a.exec();
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 3516333..d6478f0 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -194,7 +194,7 @@ void MainWindow::updateImage(bool immediately)
     QPixmap background = getBlurredBackground(rotated, scaled);
     drawForeground(background, scaled);
     
-    if (overlay != NULL)
+    if (overlay != nullptr)
     {
       drawText(background, overlay->getMarginTopLeft(), overlay->getFontsizeTopLeft(), overlay->getRenderedTopLeft(currentImage.filename).c_str(), Qt::AlignTop|Qt::AlignLeft);
       drawText(background, overlay->getMarginTopRight(), overlay->getFontsizeTopRight(), overlay->getRenderedTopRight(currentImage.filename).c_str(), Qt::AlignTop|Qt::AlignRight);
@@ -254,9 +254,9 @@ void MainWindow::drawForeground(QPixmap& background, const QPixmap& foreground)
     pt.drawPixmap((background.width()-foreground.width())/2, (background.height()-foreground.height())/2, foreground);
 }
 
-void MainWindow::setOverlay(Overlay* o)
+void MainWindow::setOverlay(std::unique_ptr<Overlay> &o)
 {
-  overlay = o;
+  overlay = std::move(o);
 }
 
 QPixmap MainWindow::getBlurredBackground(const QPixmap& originalSize, const QPixmap& scaled)
diff --git a/src/mainwindow.h b/src/mainwindow.h
index b73fe47..1a3c8f5 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -28,7 +28,7 @@ public:
     void setBlurRadius(unsigned int blurRadius);
     void setBackgroundOpacity(unsigned int opacity);
     void warn(std::string text);
-    void setOverlay(Overlay* overlay);
+    void setOverlay(std::unique_ptr<Overlay> &overlay);
     void setDebugMode(bool debugModeIn);
     void setBaseOptions(const ImageDisplayOptions &baseOptionsIn);
     const ImageDisplayOptions &getBaseOptions();
@@ -46,7 +46,7 @@ private:
     bool debugMode = false;
     QSize lastScreenSize = {0,0};
 
-    Overlay* overlay = nullptr;
+    std::unique_ptr<Overlay> overlay;
     ImageSwitcher *switcher = nullptr;
 
     void drawText(QPixmap& image, int margin, int fontsize, QString text, int alignment);

From 9a5b78cbfd707a34987ae964334486cedc88b076 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Wed, 11 Aug 2021 14:19:45 +1200
Subject: [PATCH 13/30] - Update documentation with details on the
 configuration file

---
 README.md    | 37 +++++++++++++++++++++++++++++++++++--
 src/main.cpp |  8 +++++++-
 2 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index e1aa39a..3a6178f 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,7 @@ Tested versions:
  * Raspberry Pi 3 running Raspbian Stretch.
  * Raspberry Pi 3 running Raspbian Buster.
  * Raspberry Pi Zero running Raspbian Buster.
+ * Raspberry Pi 4B running Raspbian Buster.
 
 Screen background is filled with a scaled version of the image to prevent pure black background.
 
@@ -17,11 +18,13 @@ This project is maintained by myself during my spare time. If you like and use i
 ## Usage
 
 ```
-slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur_radius] [-p image_folder|-i imageFile,...] [-r] [-O overlay_string] [-v] [--verbose] [--stretch]
+slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur_radius] [-p image_folder|-i imageFile,...] [-r] [-O overlay_string] [-v] [--verbose] [--stretch] [-c path_to_config_json]
 ```
 
 * `image_folder`: where to search for images (.jpg files)
 * `-i imageFile,...`: comma delimited list of full paths to image files to display
+* `-c path_to_config_json`: the path to an optional slide.options.json file containing configuration parameters
+* `-t` how many seconds to display each picture for
 * `-r` for recursive traversal of `image_folder`
 * `-s` for shuffle instead of random image rotation
 * `-S` for sorted rotation (files ordered by name, first images then subfolders)
@@ -49,6 +52,36 @@ slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur
 
 To exit the application, press escape. If you're using a touch display, touch all 4 corners at the same time.
 
+## Configuration file
+Slide supports loading configuration from a JSON formatted file called `slide.options.json`. This file can be specified by the `-c` command line option, we will also attempt to read `~/.config/slide/slide.options.json` and `/etc/slide/slide.options.json` in that order. The first file to load is used and its options will override command line parameters.
+The file format is:
+```
+{
+   "path" : "/path/to/pictures",
+   "aspect" : "m",
+   "overlay" : "20|20|<filename>",
+   "shuffle" : true,
+   "recursive" : true,
+   "sorted" : false,
+   "stretch": false,
+   "rotationSeconds" : 300,
+   "opacity" : 200,
+   "debug" : false
+}
+```
+Supported keys and values in the JSON configuration are:
+* `path` : where to search for images (.jpg files)
+* `aspect` : the same as the command line argument
+* `overlay` : the same as the overlay command line argument
+* `shuffle` : set to true to enable shuffle mode for file display
+* `recursive` : set to true to enable recursive mode for file display
+* `sorted` : set to true to enable shuffle mode for file display
+* `stretch` : set to true to enable, the same as the `--stretch` command line argument
+* `rotationSeconds` : the same as the `-t` command line argument
+* `opacity` : the same as the command line `-o` argument
+* `blur` : the same as the command line `-b` argument
+* `debug` : set to true to enable verbose output from the program
+
 ## Folder Options file
 When using the default or recursive folder mode we support having per folder display options. The options are stored in a file called "options.json" and currently support the following option
 ```
@@ -56,7 +89,7 @@ When using the default or recursive folder mode we support having per folder dis
     "fitAspectAxisToWindow": false
 }
 ```
-* `fitAspectAxisToWindow` : apply the --stretch option to files in this folder
+* `fitAspectAxisToWindow` : apply the `--stretch` option to files in this folder
 
 ## Dependencies
 
diff --git a/src/main.cpp b/src/main.cpp
index 91c4a9f..926243a 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -140,9 +140,10 @@ Config loadConfiguration(const Config &commandLineConfig) {
   file.close();
   QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
   QJsonObject jsonDoc = d.object();
-  SetJSONBool(userConfig.baseDisplayOptions.fitAspectAxisToWindow, jsonDoc, "fitAspectAxisToWindow");
+  SetJSONBool(userConfig.baseDisplayOptions.fitAspectAxisToWindow, jsonDoc, "stretch");
   SetJSONBool(userConfig.recursive, jsonDoc, "recursive");
   SetJSONBool(userConfig.shuffle, jsonDoc, "shuffle");
+  SetJSONBool(userConfig.sorted, jsonDoc, "sorted");
   SetJSONBool(userConfig.debugMode, jsonDoc, "debug");
 
   std::string aspectString = ParseJSONString(jsonDoc, "aspect");
@@ -160,6 +161,11 @@ Config loadConfiguration(const Config &commandLineConfig) {
     userConfig.backgroundOpacity = (int)jsonDoc["opacity"].toDouble();
   }
 
+  if(jsonDoc.contains("blur") && jsonDoc["blur"].isDouble())
+  {
+    userConfig.blurRadius = (int)jsonDoc["blur"].toDouble();
+  }
+
   std::string overlayString = ParseJSONString(jsonDoc, "overlay");
   if(!overlayString.empty())
   {

From 6784a5dcb3dc99c3a5b9cf1b257ecc9ba507aa4e Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Thu, 12 Aug 2021 16:12:13 +1200
Subject: [PATCH 14/30] - Move the folder/app configuration logic into its own
 file

---
 README.md             |  10 ++-
 src/appconfig.cpp     | 181 +++++++++++++++++++++++++++++++++++++++++
 src/appconfig.h       |  52 ++++++++++++
 src/main.cpp          | 183 +++---------------------------------------
 src/pathtraverser.cpp |  45 +++--------
 5 files changed, 260 insertions(+), 211 deletions(-)
 create mode 100644 src/appconfig.cpp
 create mode 100644 src/appconfig.h

diff --git a/README.md b/README.md
index 3a6178f..19e2a6b 100644
--- a/README.md
+++ b/README.md
@@ -83,13 +83,17 @@ Supported keys and values in the JSON configuration are:
 * `debug` : set to true to enable verbose output from the program
 
 ## Folder Options file
-When using the default or recursive folder mode we support having per folder display options. The options are stored in a file called "options.json" and currently support the following option
+When using the default or recursive folder mode we support having per folder display options. The options are stored in a file called "options.json" in the images folder and support a subset of the applications configuration settings:
 ```
 {
-    "fitAspectAxisToWindow": false
+   "stretch": false,
+   "aspect" : "m",
+   "rotationSeconds" : 300,
+   "opacity" : 200,
+   "blur" : 20
 }
 ```
-* `fitAspectAxisToWindow` : apply the `--stretch` option to files in this folder
+See the `Configuration File` section for details of each setting.
 
 ## Dependencies
 
diff --git a/src/appconfig.cpp b/src/appconfig.cpp
new file mode 100644
index 0000000..d27bf7f
--- /dev/null
+++ b/src/appconfig.cpp
@@ -0,0 +1,181 @@
+#include "appconfig.h"
+
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QDateTime>
+#include <QFileInfo>
+#include <QDir>
+
+#include <iostream>
+
+const std::string AppConfig::valid_aspects = "alpm"; // all, landscape, portait, monitor
+
+ImageAspect parseAspectFromString(char aspect) {
+  switch(aspect)
+  {
+    case 'l':
+      return ImageAspect_Landscape;
+      break;
+    case 'p':
+      return ImageAspect_Portrait;
+      break;
+    case 'm':
+      return ImageAspect_Monitor;
+      break;
+    default:
+    case 'a':
+      return ImageAspect_Any;
+      break;
+  }
+}
+
+std::string ParseJSONString(QJsonObject jsonDoc, const char *key) {
+  if(jsonDoc.contains(key) && jsonDoc[key].isString())
+  {
+   return jsonDoc[key].toString().toStdString();
+  }
+  return "";
+}
+
+void SetJSONBool(bool &value, QJsonObject jsonDoc, const char *key) {
+  if(jsonDoc.contains(key) && jsonDoc[key].isBool())
+  {
+    value = jsonDoc[key].toBool();
+  }
+}
+
+Config loadConfiguration(const std::string &configFilePath, const Config &currentConfig, bool debugMode) {
+  QString jsonFile(configFilePath.c_str());
+  QDir directory;
+  if(!directory.exists(jsonFile))
+  {
+    return currentConfig; // nothing to load
+  }
+
+  Config userConfig = currentConfig;
+
+  if(debugMode)
+  {
+    std::cout << "Found options file: " << jsonFile.toStdString() << std::endl;
+  }
+
+  QString val;
+  QFile file;
+  file.setFileName(jsonFile);
+  file.open(QIODevice::ReadOnly | QIODevice::Text);
+  val = file.readAll();
+  file.close();
+  QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
+  QJsonObject jsonDoc = d.object();
+  SetJSONBool(userConfig.baseDisplayOptions.fitAspectAxisToWindow, jsonDoc, "stretch");
+
+  std::string aspectString = ParseJSONString(jsonDoc, "aspect");
+  if(!aspectString.empty())
+  {
+    userConfig.baseDisplayOptions.onlyAspect = parseAspectFromString(aspectString[0]);
+  }
+  if(jsonDoc.contains("rotationSeconds") && jsonDoc["rotationSeconds"].isDouble())
+  {
+    userConfig.rotationSeconds = (int)jsonDoc["rotationSeconds"].toDouble();
+  }
+
+  if(jsonDoc.contains("opacity") && jsonDoc["opacity"].isDouble())
+  {
+    userConfig.backgroundOpacity = (int)jsonDoc["opacity"].toDouble();
+  }
+
+  if(jsonDoc.contains("blur") && jsonDoc["blur"].isDouble())
+  {
+    userConfig.blurRadius = (int)jsonDoc["blur"].toDouble();
+  }
+
+  userConfig.loadTime = QDateTime::currentDateTime();
+  return userConfig;
+}
+
+
+QString getAppConfigFilePath(const std::string &configPath) {
+  std::string userConfigFolder = "~/.config/slide/";
+  std::string systemConfigFolder = "/etc/slide";
+  QString baseConfigFilename("slide.options.json");
+  
+  QDir directory(userConfigFolder.c_str());
+  QString jsonFile = "";
+  if (!configPath.empty())
+  { 
+    directory.setPath(configPath.c_str());
+    jsonFile = directory.filePath(baseConfigFilename);    
+  }
+   if(!directory.exists(jsonFile))
+  { 
+    directory.setPath(userConfigFolder.c_str());
+    jsonFile = directory.filePath(baseConfigFilename);    
+  }
+  if(!directory.exists(jsonFile))
+  {
+    directory.setPath(systemConfigFolder.c_str());
+    jsonFile = directory.filePath(baseConfigFilename);
+  }
+
+  if(directory.exists(jsonFile))
+  {
+    return jsonFile;
+  }
+
+  return "";
+}
+
+AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
+  QString jsonFile = getAppConfigFilePath(commandLineConfig.configPath);
+  QDir directory;
+  if(!directory.exists(jsonFile))
+  {
+    return commandLineConfig;
+  }
+
+  AppConfig loadedConfig = loadConfiguration(jsonFile.toStdString(), commandLineConfig, commandLineConfig.debugMode);
+  
+  QString val;
+  QFile file;
+  file.setFileName(jsonFile);
+  file.open(QIODevice::ReadOnly | QIODevice::Text);
+  val = file.readAll();
+  file.close();
+  QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
+  QJsonObject jsonDoc = d.object();
+
+  SetJSONBool(loadedConfig.recursive, jsonDoc, "recursive");
+  SetJSONBool(loadedConfig.shuffle, jsonDoc, "shuffle");
+  SetJSONBool(loadedConfig.sorted, jsonDoc, "sorted");
+  SetJSONBool(loadedConfig.debugMode, jsonDoc, "debug");
+
+  std::string overlayString = ParseJSONString(jsonDoc, "overlay");
+  if(!overlayString.empty())
+  {
+    loadedConfig.overlay = overlayString;
+  }
+  std::string pathString = ParseJSONString(jsonDoc, "path");
+  if(!pathString.empty())
+  {
+    loadedConfig.path = pathString;
+  }
+  std::string imageListString = ParseJSONString(jsonDoc, "imageList");
+  if(!imageListString.empty())
+  {
+    loadedConfig.imageList = imageListString;
+  }
+
+  loadedConfig.configPath = commandLineConfig.configPath;
+  return loadedConfig;
+}
+
+Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig, bool debugMode) {
+  QDir directory(folderPath.c_str());
+  QString jsonFile = directory.filePath(QString("options.json"));
+  if(directory.exists(jsonFile))
+  {
+      return loadConfiguration(jsonFile.toStdString(), currentConfig, debugMode );
+  }
+  return currentConfig;
+}
\ No newline at end of file
diff --git a/src/appconfig.h b/src/appconfig.h
new file mode 100644
index 0000000..0b4398f
--- /dev/null
+++ b/src/appconfig.h
@@ -0,0 +1,52 @@
+
+#ifndef APPCONFIG_H
+#define APPCONFIG_H
+#include <QDateTime>
+#include "imagestructs.h"
+
+// configuration options that apply to an image/folder of images
+struct Config {
+  public:
+    unsigned int rotationSeconds = 30;
+    int blurRadius = -1;
+    int backgroundOpacity = -1;
+    ImageDisplayOptions baseDisplayOptions;
+    QDateTime loadTime;
+};
+
+// app level configuration
+struct AppConfig : public Config
+{
+    AppConfig() {}
+    AppConfig( const Config &inConfig ) : Config(inConfig) {}
+    std::string path = "";
+    std::string configPath = "";
+
+    std::string overlay = "";
+    std::string imageList = ""; // comma delimited list of images to show
+
+    bool recursive = false;
+    bool shuffle = false;
+    bool sorted = false;
+    bool debugMode = false;
+    static const std::string valid_aspects; 
+
+  public:
+    bool PathOptionsChanged(AppConfig &other) {
+      if ( other.recursive != recursive || other.shuffle != shuffle
+      || other.sorted != sorted)
+        return true;
+      if ( other.path != path || other.imageList != imageList )
+        return true;
+      return false;
+    }
+};
+
+
+AppConfig loadAppConfiguration(const AppConfig &commandLineConfig);
+Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig, bool debugMode);
+
+ImageAspect parseAspectFromString(char aspect);
+QString getAppConfigFilePath(const std::string &configPath);
+
+#endif
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index 926243a..967e3e7 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -3,12 +3,9 @@
 #include "imageswitcher.h"
 #include "pathtraverser.h"
 #include "overlay.h"
+#include "appconfig.h"
+
 #include <QApplication>
-#include <QJsonDocument>
-#include <QJsonObject>
-#include <QJsonValue>
-#include <QDateTime>
-#include <QFileInfo>
 #include <iostream>
 #include <sys/file.h>
 #include <errno.h>
@@ -23,165 +20,7 @@ void usage(std::string programName) {
     std::cerr << "Usage: " << programName << " [-t rotation_seconds] [-a aspect('l','p','a', 'm')] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-s] [-v] [--verbose] [--stretch] [-c config_file_path]" << std::endl;
 }
 
-struct Config {
-  public:
-    std::string path = "";
-    std::string configPath = "";
-    unsigned int rotationSeconds = 30;
-    int blurRadius = -1;
-    int backgroundOpacity = -1;
-    bool recursive = false;
-    bool shuffle = false;
-    bool sorted = false;
-    bool debugMode = false;
-    ImageDisplayOptions baseDisplayOptions;
-    static const std::string valid_aspects; 
-    std::string overlay = "";
-    std::string imageList = ""; // comma delimited list of images to show
-    QDateTime loadTime;
-  public:
-    bool PathOptionsChanged(Config &other) {
-      if ( other.recursive != recursive || other.shuffle != shuffle
-      || other.sorted != sorted)
-        return true;
-      if ( other.path != path || other.imageList != imageList )
-        return true;
-      return false;
-    }
-};
-
-const std::string Config::valid_aspects = "alpm"; // all, landscape, portait, monitor
-
-ImageAspect parseAspectFromString(char aspect) {
-  switch(aspect)
-  {
-    case 'l':
-      return ImageAspect_Landscape;
-      break;
-    case 'p':
-      return ImageAspect_Portrait;
-      break;
-    case 'm':
-      return ImageAspect_Monitor;
-      break;
-    default:
-    case 'a':
-      return ImageAspect_Any;
-      break;
-  }
-}
-
-std::string ParseJSONString(QJsonObject jsonDoc, const char *key) {
-  if(jsonDoc.contains(key) && jsonDoc[key].isString())
-  {
-   return jsonDoc[key].toString().toStdString();
-  }
-  return "";
-}
-
-void SetJSONBool(bool &value, QJsonObject jsonDoc, const char *key) {
-  if(jsonDoc.contains(key) && jsonDoc[key].isBool())
-  {
-    value = jsonDoc[key].toBool();
-  }
-}
-
-QString getConfigFilePath(const std::string &configPath) {
-  std::string userConfigFolder = "~/.config/slide/";
-  std::string systemConfigFolder = "/etc/slide";
-  QString baseConfigFilename("slide.options.json");
-  
-  QDir directory(userConfigFolder.c_str());
-  QString jsonFile = "";
-  if (!configPath.empty())
-  { 
-    directory.setPath(configPath.c_str());
-    jsonFile = directory.filePath(baseConfigFilename);    
-  }
-   if(!directory.exists(jsonFile))
-  { 
-    directory.setPath(userConfigFolder.c_str());
-    jsonFile = directory.filePath(baseConfigFilename);    
-  }
-  if(!directory.exists(jsonFile))
-  {
-    directory.setPath(systemConfigFolder.c_str());
-    jsonFile = directory.filePath(baseConfigFilename);
-  }
-
-  if(directory.exists(jsonFile))
-  {
-    return jsonFile;
-  }
-
-  return "";
-}
-
-Config loadConfiguration(const Config &commandLineConfig) {
-  QString jsonFile = getConfigFilePath(commandLineConfig.configPath);
-  QDir directory;
-  if(!directory.exists(jsonFile))
-  {
-    return commandLineConfig; // nothing to load
-  }
-
-  Config userConfig = commandLineConfig;
-
-  if(userConfig.debugMode)
-  {
-    std::cout << "Found options file: " << jsonFile.toStdString() << std::endl;
-  }
-
-  QString val;
-  QFile file;
-  file.setFileName(jsonFile);
-  file.open(QIODevice::ReadOnly | QIODevice::Text);
-  val = file.readAll();
-  file.close();
-  QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
-  QJsonObject jsonDoc = d.object();
-  SetJSONBool(userConfig.baseDisplayOptions.fitAspectAxisToWindow, jsonDoc, "stretch");
-  SetJSONBool(userConfig.recursive, jsonDoc, "recursive");
-  SetJSONBool(userConfig.shuffle, jsonDoc, "shuffle");
-  SetJSONBool(userConfig.sorted, jsonDoc, "sorted");
-  SetJSONBool(userConfig.debugMode, jsonDoc, "debug");
-
-  std::string aspectString = ParseJSONString(jsonDoc, "aspect");
-  if(!aspectString.empty())
-  {
-    userConfig.baseDisplayOptions.onlyAspect = parseAspectFromString(aspectString[0]);
-  }
-  if(jsonDoc.contains("rotationSeconds") && jsonDoc["rotationSeconds"].isDouble())
-  {
-    userConfig.rotationSeconds = (int)jsonDoc["rotationSeconds"].toDouble();
-  }
-
-  if(jsonDoc.contains("opacity") && jsonDoc["opacity"].isDouble())
-  {
-    userConfig.backgroundOpacity = (int)jsonDoc["opacity"].toDouble();
-  }
-
-  if(jsonDoc.contains("blur") && jsonDoc["blur"].isDouble())
-  {
-    userConfig.blurRadius = (int)jsonDoc["blur"].toDouble();
-  }
-
-  std::string overlayString = ParseJSONString(jsonDoc, "overlay");
-  if(!overlayString.empty())
-  {
-    userConfig.overlay = overlayString;
-  }
-  std::string pathString = ParseJSONString(jsonDoc, "path");
-  if(!pathString.empty())
-  {
-    userConfig.path = pathString;
-  }
-
-  userConfig.loadTime = QDateTime::currentDateTime();
-  return userConfig;
-}
-
-bool parseCommandLine(Config &appConfig, int argc, char *argv[]) {
+bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
   int opt;
   int debugInt = 0;
   int stretchInt = 0;
@@ -261,7 +100,7 @@ bool parseCommandLine(Config &appConfig, int argc, char *argv[]) {
   return true;
 }
 
-void ConfigureWindowFromSettings(MainWindow &w, const Config &appConfig)
+void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
 {
   if (appConfig.blurRadius>= 0)
   {
@@ -279,7 +118,7 @@ void ConfigureWindowFromSettings(MainWindow &w, const Config &appConfig)
   w.setBaseOptions(appConfig.baseDisplayOptions);
 }
 
-std::unique_ptr<ImageSelector> GetSelectorForConfig(const Config &appConfig)
+std::unique_ptr<ImageSelector> GetSelectorForConfig(const AppConfig&appConfig)
 {
   std::unique_ptr<PathTraverser> pathTraverser;
   if (!appConfig.imageList.empty())
@@ -312,9 +151,9 @@ std::unique_ptr<ImageSelector> GetSelectorForConfig(const Config &appConfig)
   return selector;
 }
 
-void ReloadConfigIfNeeded(Config &appConfig, MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)
+void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)
 {  
-  QString jsonFile = getConfigFilePath(appConfig.configPath);
+  QString jsonFile = getAppConfigFilePath(appConfig.configPath);
   QDir directory;
   if(!directory.exists(jsonFile))
   {
@@ -326,8 +165,8 @@ void ReloadConfigIfNeeded(Config &appConfig, MainWindow &w, ImageSwitcher *switc
     const std::string oldPath = appConfig.path;
     const std::string oldImageList = appConfig.imageList;
 
-    Config oldConfig = appConfig;
-    appConfig = loadConfiguration(appConfig);
+    AppConfig oldConfig = appConfig;
+    appConfig = loadAppConfiguration(appConfig);
 
     ConfigureWindowFromSettings(w, appConfig);
     if(appConfig.PathOptionsChanged(oldConfig))
@@ -345,14 +184,14 @@ int main(int argc, char *argv[])
 {
   QApplication a(argc, argv);
 
-  Config commandLineAppConfig;
+  AppConfig commandLineAppConfig;
   if (!parseCommandLine(commandLineAppConfig, argc, argv))
   {
     usage(argv[0]);
     return 1;
   }
 
-  Config appConfig = loadConfiguration(commandLineAppConfig);
+  AppConfig appConfig = loadAppConfiguration(commandLineAppConfig);
 
   if (appConfig.path.empty() && appConfig.imageList.empty())
   {
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index db2ab73..d42385f 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -1,16 +1,13 @@
 #include "pathtraverser.h"
 #include "mainwindow.h"
+#include "appconfig.h"
+
 #include <QDirIterator>
-#include <QTimer>
-#include <QApplication>
 #include <QDir>
 #include <QFileInfo>
-#include <QJsonDocument>
-#include <QJsonObject>
-#include <QJsonValue>
 #include <iostream>
 #include <stdlib.h>     /* srand, rand */
-#define UNUSED(x) (void)(x)
+
 
 PathTraverser::PathTraverser(const std::string path, bool debugModeIn):
   path(path), debugMode(debugModeIn)
@@ -27,33 +24,9 @@ QStringList PathTraverser::getImageFormats() const {
 
 ImageDisplayOptions PathTraverser::LoadOptionsForDirectory(const std::string &directoryPath, const ImageDisplayOptions &baseOptions) const
 {
-  ImageDisplayOptions options = baseOptions;
-  QDir directory(directoryPath.c_str());
-  QString jsonFile = directory.filePath(QString("options.json"));
-  if(directory.exists(jsonFile))
-  {
-    if(debugMode)
-    {
-      std::cout << "Found options file" << std::endl;
-    }
-    QString val;
-    QFile file;
-    file.setFileName(jsonFile);
-    file.open(QIODevice::ReadOnly | QIODevice::Text);
-    val = file.readAll();
-    file.close();
-    QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
-    QJsonObject jsonDoc = d.object();
-    if(jsonDoc.contains("fitAspectAxisToWindow") && jsonDoc["fitAspectAxisToWindow"].isBool())
-    {
-      options.fitAspectAxisToWindow = jsonDoc["fitAspectAxisToWindow"].toBool();
-      if(debugMode)
-      {
-        std::cout << "Fit Aspect:" << options.fitAspectAxisToWindow << std::endl;
-      }
-    }
-  }
-  return options;
+  Config baseConfig;
+  baseConfig.baseDisplayOptions = baseOptions;
+  return getConfigurationForFolder(directoryPath, baseConfig, debugMode).baseDisplayOptions;
 }
 
 RecursivePathTraverser::RecursivePathTraverser(const std::string path,bool debugMode):
@@ -106,7 +79,7 @@ const std::string DefaultPathTraverser::getImagePath(const std::string image) co
 
 ImageDisplayOptions DefaultPathTraverser::UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const
 {
-  UNUSED(filename);
+  Q_UNUSED(filename);
   return LoadOptionsForDirectory(directory.absolutePath().toStdString(), baseOptions);
 }
 
@@ -133,7 +106,7 @@ const std::string ImageListPathTraverser::getImagePath(const std::string image)
 ImageDisplayOptions ImageListPathTraverser::UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const
 {
   // no per file options modification supported
-  UNUSED(filename);
-  UNUSED(baseOptions);
+  Q_UNUSED(filename);
+  Q_UNUSED(baseOptions);
   return ImageDisplayOptions();
 }

From de7af88e53b311d08fa4c4d61bb213ffa81f1d82 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Thu, 12 Aug 2021 17:40:56 +1200
Subject: [PATCH 15/30] - Add support for display time windows for images in
 folder.options    - the times are defined in a JSON array with start and end
 times, if inside the window the image is valid to display

---
 README.md             | 13 ++++++++++++-
 src/appconfig.cpp     | 24 ++++++++++++++++++++++++
 src/imageselector.cpp | 35 ++++++++++++++++++++++++++++++++---
 src/imageselector.h   |  1 +
 src/imagestructs.h    |  9 +++++++++
 5 files changed, 78 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 19e2a6b..84d5602 100644
--- a/README.md
+++ b/README.md
@@ -90,10 +90,21 @@ When using the default or recursive folder mode we support having per folder dis
    "aspect" : "m",
    "rotationSeconds" : 300,
    "opacity" : 200,
-   "blur" : 20
+   "blur" : 20,
+   "times": [
+      {
+          "start": "08:00",
+          "end": "10:00"
+      },
+      {
+          "start": "17:00",
+          "end": "19:00"
+      }
+   ]
 }
 ```
 See the `Configuration File` section for details of each setting.
+* `times` : times is a JSON array of start and end times in which it is valid to display this image. The time is in the format HH:MM:SS and is based on the systems local time. If `start` isn't defined then it defaults to the start of the day, if `end` isn't default it defaults to the end of the day.
 
 ## Dependencies
 
diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index d27bf7f..022e8fc 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -3,7 +3,9 @@
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonValue>
+#include <QJsonArray>
 #include <QDateTime>
+#include <QTime>
 #include <QFileInfo>
 #include <QDir>
 
@@ -90,6 +92,28 @@ Config loadConfiguration(const std::string &configFilePath, const Config &curren
     userConfig.blurRadius = (int)jsonDoc["blur"].toDouble();
   }
 
+  if(jsonDoc.contains("times") && jsonDoc["times"].isArray())
+  {
+      QJsonArray jsonArray = jsonDoc["times"].toArray();
+      foreach (const QJsonValue & value, jsonArray) 
+      {
+        QJsonObject obj = value.toObject();
+        if(obj.contains("start") || obj.contains("end"))
+        {
+            DisplayTimeWindow window;
+            if(obj.contains("start"))
+            {
+                window.startDisplay = QTime::fromString(obj["start"].toString());
+            }
+            if(obj.contains("end"))
+            {
+                window.endDisplay = QTime::fromString(obj["end"].toString());
+            }
+            userConfig.baseDisplayOptions.timeWindows.append(window);
+        }
+     }
+  }
+
   userConfig.loadTime = QDateTime::currentDateTime();
   return userConfig;
 }
diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 7cdaf2d..22bcd75 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -111,10 +111,37 @@ ImageDetails ImageSelector::populateImageDetails(const std::string&fileName, con
   } else {
     imageDetails.aspect = ImageAspect_Any;
   }
-  imageDetails.options = baseOptions;
+
+  imageDetails.options = pathTraverser->UpdateOptionsForImage(imageDetails.filename, baseOptions);
+  
   return imageDetails;
 }
 
+bool ImageSelector::imageInsideTimeWindow(const QVector<DisplayTimeWindow> &timeWindows)
+{
+  if(timeWindows.count() == 0)
+  {
+      return true; // no specified time windows means always display
+  }
+  const QTime currentTime = QTime::currentTime();
+  for(auto &window : timeWindows)
+  {
+    if(currentTime > window.startDisplay && currentTime < window.endDisplay)
+    {
+      return true;
+    }
+  }
+  if(debugMode && timeWindows.count() > 0)
+  {
+    std::cout << "image display time outside windows: " << std::endl;
+    for(auto timeWindow : timeWindows) 
+    {
+      std::cout << "time: " << timeWindow.startDisplay.toString().toStdString() << "-" << timeWindow.endDisplay.toString().toStdString() << std::endl;
+    }
+  }
+  return false;
+}
+
 bool ImageSelector::imageMatchesFilter(const ImageDetails& imageDetails)
 {
   if(!QFileInfo::exists(QString(imageDetails.filename.c_str())))
@@ -135,6 +162,10 @@ bool ImageSelector::imageMatchesFilter(const ImageDetails& imageDetails)
     return false;
   }
 
+  if(!imageInsideTimeWindow(imageDetails.options.timeWindows))
+  {
+    return false;
+  }
   return true;
 }
 
@@ -176,7 +207,6 @@ const ImageDetails RandomImageSelector::getNextImage(const ImageDisplayOptions &
     std::cerr << "Error: " << err << std::endl;
   }
   std::cout << "updating image: " << imageDetails.filename << std::endl;
-  imageDetails.options = pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
   return imageDetails;
 }
 
@@ -221,7 +251,6 @@ const ImageDetails ShuffleImageSelector::getNextImage(const ImageDisplayOptions
     current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
   }
   std::cout << "updating image: " << imageDetails.filename << std::endl;
-  imageDetails.options = pathTraverser->UpdateOptionsForImage(imageDetails.filename, imageDetails.options);
   return imageDetails;
 }
 
diff --git a/src/imageselector.h b/src/imageselector.h
index 128f93b..fa46fd2 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -21,6 +21,7 @@ protected:
     ImageDetails populateImageDetails(const std::string&filename, const ImageDisplayOptions &baseOptions);
     bool imageValidForAspect(const ImageDetails& imageDetails);
     bool imageMatchesFilter(const ImageDetails& imageDetails);
+    bool imageInsideTimeWindow(const QVector<DisplayTimeWindow> &timeWindows);
     std::unique_ptr<PathTraverser> pathTraverser;
     bool debugMode = false;
 };
diff --git a/src/imagestructs.h b/src/imagestructs.h
index 672528c..ce937fc 100644
--- a/src/imagestructs.h
+++ b/src/imagestructs.h
@@ -1,16 +1,25 @@
 #ifndef IMAGESTRUCTS_H
 #define IMAGESTRUCTS_H
 
+#include <QTime>
+#include <QVector>
 #include <string>
 
 // possible aspect ratios of an image
 enum ImageAspect { ImageAspect_Landscape = 0, ImageAspect_Portrait, ImageAspect_Any, ImageAspect_Monitor /* match monitors aspect */ };
 
+struct DisplayTimeWindow
+{
+    QTime startDisplay = QTime(0,0,0,0);
+    QTime endDisplay = QTime(23,59,59,0);
+};
+
 // options to consider when displaying an image
 struct ImageDisplayOptions
 {
     ImageAspect onlyAspect = ImageAspect_Any;
     bool fitAspectAxisToWindow = false;
+    QVector<DisplayTimeWindow> timeWindows;
 };
 
 // details of a particular image

From 66d619f49e8f06a2d830ce28aaa0f334a70be7dc Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sat, 21 Aug 2021 15:58:16 +1200
Subject: [PATCH 16/30] - Add a "scheduler" key to the config file that lets
 you define multiple image selectors and time windows they are valid for

---
 src/appconfig.cpp     | 97 +++++++++++++++++++++++++++++++++++++------
 src/appconfig.h       | 61 ++++++++++++++++-----------
 src/imageselector.cpp | 52 ++++++++++++++++++++++-
 src/imageselector.h   | 20 +++++++++
 src/main.cpp          | 65 ++++++++++++++++++++---------
 5 files changed, 237 insertions(+), 58 deletions(-)

diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index 022e8fc..8a18eae 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -150,6 +150,67 @@ QString getAppConfigFilePath(const std::string &configPath) {
   return "";
 }
 
+QVector<PathEntry> parsePathEntry(QJsonObject &jsonMainDoc, bool baseRecursive, bool baseShuffle, bool baseSorted)
+{
+  QVector<PathEntry> pathEntries;
+  
+  if(jsonMainDoc.contains("scheduler") && jsonMainDoc["scheduler"].isArray()) 
+  {
+    QJsonArray jsonArray = jsonMainDoc["scheduler"].toArray();
+    foreach (const QJsonValue & value, jsonArray) 
+    {
+      PathEntry entry;
+      entry.recursive = baseRecursive;
+      entry.sorted = baseSorted;
+      entry.shuffle = baseShuffle;
+
+      QJsonObject schedulerJson = value.toObject();
+
+      SetJSONBool(entry.recursive, schedulerJson, "recursive");
+      SetJSONBool(entry.shuffle, schedulerJson, "shuffle");
+      SetJSONBool(entry.sorted, schedulerJson, "sorted");
+
+      std::string pathString = ParseJSONString(schedulerJson, "path");
+      if(!pathString.empty()) {
+        entry.path = pathString;
+      }
+      std::string imageListString = ParseJSONString(schedulerJson, "imageList");
+      if(!imageListString.empty()) {
+        entry.imageList = imageListString;
+      }
+      std::string typeString = ParseJSONString(schedulerJson, "type");
+      if(!pathString.empty()) {
+        entry.type = typeString;
+      }
+      SetJSONBool(entry.exclusive, schedulerJson, "exclusive");
+
+      if(schedulerJson.contains("times") && schedulerJson["times"].isArray())
+      {
+          QJsonArray jsonTimesArray = schedulerJson["times"].toArray();
+          foreach (const QJsonValue & timesValue, jsonTimesArray) 
+          {
+            QJsonObject timesJson = timesValue.toObject();
+            if(timesJson.contains("start") || timesJson.contains("end"))
+            {
+                DisplayTimeWindow window;
+                if(timesJson.contains("start"))
+                {
+                    window.startDisplay = QTime::fromString(timesJson["start"].toString());
+                }
+                if(timesJson.contains("end"))
+                {
+                    window.endDisplay = QTime::fromString(timesJson["end"].toString());
+                }
+                entry.timeWindows.append(window);
+            }
+        }
+      }
+      pathEntries.append(entry);
+    }
+  }
+  return pathEntries;
+}
+
 AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
   QString jsonFile = getAppConfigFilePath(commandLineConfig.configPath);
   QDir directory;
@@ -169,9 +230,10 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
   QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
   QJsonObject jsonDoc = d.object();
 
-  SetJSONBool(loadedConfig.recursive, jsonDoc, "recursive");
-  SetJSONBool(loadedConfig.shuffle, jsonDoc, "shuffle");
-  SetJSONBool(loadedConfig.sorted, jsonDoc, "sorted");
+  bool baseRecursive, baseShuffle, baseSorted;
+  SetJSONBool(baseRecursive, jsonDoc, "recursive");
+  SetJSONBool(baseShuffle, jsonDoc, "shuffle");
+  SetJSONBool(baseSorted, jsonDoc, "sorted");
   SetJSONBool(loadedConfig.debugMode, jsonDoc, "debug");
 
   std::string overlayString = ParseJSONString(jsonDoc, "overlay");
@@ -179,17 +241,26 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
   {
     loadedConfig.overlay = overlayString;
   }
-  std::string pathString = ParseJSONString(jsonDoc, "path");
-  if(!pathString.empty())
-  {
-    loadedConfig.path = pathString;
-  }
-  std::string imageListString = ParseJSONString(jsonDoc, "imageList");
-  if(!imageListString.empty())
-  {
-    loadedConfig.imageList = imageListString;
-  }
 
+  loadedConfig.paths = parsePathEntry(jsonDoc, baseRecursive, baseShuffle, baseSorted);
+  if(loadedConfig.paths.count() <= 0)
+  {
+    PathEntry entry;
+    entry.recursive = baseRecursive;
+    entry.sorted = baseSorted;
+    entry.shuffle = baseShuffle;
+    std::string pathString = ParseJSONString(jsonDoc, "path");
+    if(!pathString.empty())
+    {
+      entry.path = pathString;
+    }
+    std::string imageListString = ParseJSONString(jsonDoc, "imageList");
+    if(!imageListString.empty())
+    {
+      entry.imageList = imageListString;
+    }
+    loadedConfig.paths.append(entry);
+  }
   loadedConfig.configPath = commandLineConfig.configPath;
   return loadedConfig;
 }
diff --git a/src/appconfig.h b/src/appconfig.h
index 0b4398f..61fadb3 100644
--- a/src/appconfig.h
+++ b/src/appconfig.h
@@ -3,6 +3,7 @@
 #define APPCONFIG_H
 #include <QDateTime>
 #include "imagestructs.h"
+#include <QVector>
 
 // configuration options that apply to an image/folder of images
 struct Config {
@@ -14,34 +15,44 @@ struct Config {
     QDateTime loadTime;
 };
 
-// app level configuration
-struct AppConfig : public Config
-{
-    AppConfig() {}
-    AppConfig( const Config &inConfig ) : Config(inConfig) {}
-    std::string path = "";
-    std::string configPath = "";
+struct PathEntry {
+  QVector<DisplayTimeWindow> timeWindows;
+  std::string path = "";
+  std::string imageList = "";
+  std::string type = "";
+  bool exclusive = false;
 
-    std::string overlay = "";
-    std::string imageList = ""; // comma delimited list of images to show
-
-    bool recursive = false;
-    bool shuffle = false;
-    bool sorted = false;
-    bool debugMode = false;
-    static const std::string valid_aspects; 
-
-  public:
-    bool PathOptionsChanged(AppConfig &other) {
-      if ( other.recursive != recursive || other.shuffle != shuffle
-      || other.sorted != sorted)
-        return true;
-      if ( other.path != path || other.imageList != imageList )
-        return true;
-      return false;
-    }
+  bool recursive = false;
+  bool shuffle = false;
+  bool sorted = false;
 };
 
+// app level configuration
+struct AppConfig : public Config {
+    AppConfig() {}
+    AppConfig( const Config &inConfig ) : Config(inConfig) {}
+    std::string configPath = "";
+    std::string overlay = "";
+    QVector<PathEntry> paths;
+
+    bool debugMode = false;
+
+    static const std::string valid_aspects; 
+  public:
+    bool PathOptionsChanged(AppConfig &other) {
+      if (paths.count() != other.paths.count())
+        return true;
+      for(int index = 0; index < paths.count(); ++index)
+      {
+        if ( other.paths[index].recursive != paths[index].recursive || other.paths[index].shuffle != paths[index].shuffle
+        || other.paths[index].sorted != paths[index].sorted)
+          return true;
+        if ( other.paths[index].path != paths[index].path || other.paths[index].imageList != paths[index].imageList )
+          return true;
+      }
+     return false;
+    }
+};
 
 AppConfig loadAppConfiguration(const AppConfig &commandLineConfig);
 Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig, bool debugMode);
diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 22bcd75..839a919 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -17,6 +17,8 @@ ImageSelector::ImageSelector(std::unique_ptr<PathTraverser>& pathTraverserIn):
 {
 }
 
+ImageSelector::ImageSelector() {}
+
 ImageSelector::~ImageSelector(){}
 
 void ImageSelector::setDebugMode(bool debugModeIn) 
@@ -134,7 +136,7 @@ bool ImageSelector::imageInsideTimeWindow(const QVector<DisplayTimeWindow> &time
   if(debugMode && timeWindows.count() > 0)
   {
     std::cout << "image display time outside windows: " << std::endl;
-    for(auto timeWindow : timeWindows) 
+    for(auto &timeWindow : timeWindows) 
     {
       std::cout << "time: " << timeWindow.startDisplay.toString().toStdString() << "-" << timeWindow.endDisplay.toString().toStdString() << std::endl;
     }
@@ -324,3 +326,51 @@ void SortedImageSelector::reloadImagesIfEmpty()
     }
   }
 }
+
+
+ListImageSelector::ListImageSelector()
+{
+  currentSelector = imageSelectors.begin();
+}
+
+ListImageSelector::~ListImageSelector() 
+{
+}
+
+void ListImageSelector::AddImageSelector(std::unique_ptr<ImageSelector>& selector, const QVector<DisplayTimeWindow> &displayTimeWindows, const bool exclusiveIn)
+{
+  SelectoryEntry entry;
+  entry.selector = std::move(selector);
+  entry.displayTimeWindows = displayTimeWindows;
+  entry.exclusive = exclusiveIn;
+  imageSelectors.push_back(std::move(entry));
+  currentSelector = imageSelectors.begin();
+}
+
+
+const ImageDetails ListImageSelector::getNextImage(const ImageDisplayOptions& baseOptions)
+{
+  // check for exclusive time windows
+  for(auto& selector: imageSelectors)
+  {
+    if (imageInsideTimeWindow(selector.displayTimeWindows) && selector.exclusive) 
+    {
+      return selector.selector->getNextImage(baseOptions);
+    }
+  }
+
+  // fall back to the next in the list
+  do
+  {  
+    ++currentSelector;
+    if(currentSelector == imageSelectors.end())
+    {
+      currentSelector = imageSelectors.begin();
+    }
+    if (imageInsideTimeWindow(currentSelector->displayTimeWindows))
+    {
+      return currentSelector->selector->getNextImage(baseOptions);
+    }
+  }
+  while(true);
+}
\ No newline at end of file
diff --git a/src/imageselector.h b/src/imageselector.h
index fa46fd2..eeaccc3 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -4,6 +4,7 @@
 #include <iostream>
 #include <memory>
 #include <QStringList>
+#include <QVector>
 #include "imagestructs.h"
 
 class MainWindow;
@@ -13,6 +14,7 @@ class ImageSelector
 {
 public:
     ImageSelector(std::unique_ptr<PathTraverser>& pathTraverser);
+    ImageSelector(); // use case for when you don't own your own traverser
     virtual ~ImageSelector();
     virtual const ImageDetails getNextImage(const ImageDisplayOptions &baseOptions) = 0;
     void setDebugMode(bool debugModeIn);
@@ -61,4 +63,22 @@ private:
     void reloadImagesIfEmpty();
     QStringList images;
 };
+
+class ListImageSelector : public ImageSelector
+{
+public:
+    ListImageSelector();
+    virtual ~ListImageSelector();
+    virtual const ImageDetails getNextImage(const ImageDisplayOptions &baseOptions);
+    void AddImageSelector(std::unique_ptr<ImageSelector>& selector, const QVector<DisplayTimeWindow> &displayTimeWindows, const bool exclusiveIn);
+
+private:
+    struct SelectoryEntry {
+        std::unique_ptr<ImageSelector> selector;
+        QVector<DisplayTimeWindow> displayTimeWindows;
+        bool exclusive = false;
+    };
+    std::vector<SelectoryEntry> imageSelectors;
+    std::vector<SelectoryEntry>::iterator currentSelector;
+};
 #endif // IMAGESELECTOR_H
diff --git a/src/main.cpp b/src/main.cpp
index 967e3e7..f2c3d4c 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -39,7 +39,9 @@ bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
           return false;
           break;
       case 'p':
-        appConfig.path = optarg;
+        if(appConfig.paths.count() == 0)
+          appConfig.paths.append(PathEntry());
+        appConfig.paths[0].path = optarg;
         break;
       case 'a':
         if (appConfig.valid_aspects.find(optarg[0]) == std::string::npos)
@@ -62,14 +64,20 @@ bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
         appConfig.backgroundOpacity = atoi(optarg);
         break;
       case 'r':
-        appConfig.recursive = true;
+        if(appConfig.paths.count() == 0)
+          appConfig.paths.append(PathEntry());
+        appConfig.paths[0].recursive = true;
         break;
       case 's':
-        appConfig.shuffle = true;
+        if(appConfig.paths.count() == 0)
+          appConfig.paths.append(PathEntry());
+        appConfig.paths[0].shuffle = true;
         std::cout << "Shuffle mode is on." << std::endl;
         break;
       case 'S':
-        appConfig.sorted = true;
+        if(appConfig.paths.count() == 0)
+          appConfig.paths.append(PathEntry());
+        appConfig.paths[0].sorted = true;
         break;
       case 'O':
         appConfig.overlay = optarg;
@@ -78,7 +86,9 @@ bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
         appConfig.debugMode = true;
         break;
       case 'i':
-        appConfig.imageList = optarg;
+        if(appConfig.paths.count() == 0)
+          appConfig.paths.append(PathEntry());
+        appConfig.paths[0].imageList = optarg;
         break;
       case 'c':
         appConfig.configPath = optarg;
@@ -118,28 +128,28 @@ void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
   w.setBaseOptions(appConfig.baseDisplayOptions);
 }
 
-std::unique_ptr<ImageSelector> GetSelectorForConfig(const AppConfig&appConfig)
+std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, const bool debugMode)
 {
   std::unique_ptr<PathTraverser> pathTraverser;
-  if (!appConfig.imageList.empty())
+  if (!path.imageList.empty())
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(appConfig.imageList, appConfig.debugMode));
+    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(path.imageList, debugMode));
   }
-  else if (appConfig.recursive)
+  else if (path.recursive)
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(appConfig.path, appConfig.debugMode));
+    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path.path, debugMode));
   }
   else
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(appConfig.path, appConfig.debugMode));
+    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(path.path, debugMode));
   }
 
   std::unique_ptr<ImageSelector> selector;
-  if (appConfig.sorted)
+  if (path.sorted)
   {
     selector = std::unique_ptr<ImageSelector>(new SortedImageSelector(pathTraverser));
   }
-  else if (appConfig.shuffle)
+  else if (path.shuffle)
   {
     selector = std::unique_ptr<ImageSelector>(new ShuffleImageSelector(pathTraverser));
   }
@@ -151,6 +161,26 @@ std::unique_ptr<ImageSelector> GetSelectorForConfig(const AppConfig&appConfig)
   return selector;
 }
 
+std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig)
+{
+  if(appConfig.paths.count()==1)
+  {
+    return GetSelectorForConfig(appConfig.paths[0], appConfig.debugMode);
+  }
+  else
+  {
+    std::unique_ptr<ListImageSelector> listSelector(new ListImageSelector());
+    for(const auto &path : appConfig.paths)
+    {
+      auto selector = GetSelectorForConfig(path, appConfig.debugMode);
+      listSelector->AddImageSelector(selector,path.timeWindows, path.exclusive);
+    }
+    // new things
+    return listSelector;
+  }
+}
+
+
 void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)
 {  
   QString jsonFile = getAppConfigFilePath(appConfig.configPath);
@@ -162,16 +192,13 @@ void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *sw
 
   if(appConfig.loadTime <  QFileInfo(jsonFile).lastModified())
   {
-    const std::string oldPath = appConfig.path;
-    const std::string oldImageList = appConfig.imageList;
-
     AppConfig oldConfig = appConfig;
     appConfig = loadAppConfiguration(appConfig);
 
     ConfigureWindowFromSettings(w, appConfig);
     if(appConfig.PathOptionsChanged(oldConfig))
     {
-      std::unique_ptr<ImageSelector> selector = GetSelectorForConfig(appConfig);
+      std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
       switcher->setImageSelector(selector);
     }
 
@@ -193,7 +220,7 @@ int main(int argc, char *argv[])
 
   AppConfig appConfig = loadAppConfiguration(commandLineAppConfig);
 
-  if (appConfig.path.empty() && appConfig.imageList.empty())
+  if (appConfig.paths.empty())
   {
     std::cout << "Error: Path expected." << std::endl;
     usage(argv[0]);
@@ -210,7 +237,7 @@ int main(int argc, char *argv[])
   ConfigureWindowFromSettings(w, appConfig);
   w.show();
 
-  std::unique_ptr<ImageSelector> selector = GetSelectorForConfig(appConfig);
+  std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
   selector->setDebugMode(appConfig.debugMode);
   
   ImageSwitcher switcher(w, appConfig.rotationSeconds * 1000, selector);

From 94373e667101533010257bda220d583b08747465 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sun, 22 Aug 2021 09:55:47 +1200
Subject: [PATCH 17/30] - Add stretch key to scheduler entries - Fix change
 logic on pathentry to detect correct

---
 src/appconfig.cpp     |  9 ++++-----
 src/appconfig.h       | 39 ++++++++++++++++++++++++++++++---------
 src/imageselector.cpp | 18 ++++++++++++------
 src/imageselector.h   |  4 ++--
 src/imagestructs.h    |  5 +++++
 src/main.cpp          |  2 +-
 6 files changed, 54 insertions(+), 23 deletions(-)

diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index 8a18eae..fe06e57 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -170,6 +170,8 @@ QVector<PathEntry> parsePathEntry(QJsonObject &jsonMainDoc, bool baseRecursive,
       SetJSONBool(entry.shuffle, schedulerJson, "shuffle");
       SetJSONBool(entry.sorted, schedulerJson, "sorted");
 
+      SetJSONBool(entry.baseDisplayOptions.fitAspectAxisToWindow, schedulerJson, "stretch");
+
       std::string pathString = ParseJSONString(schedulerJson, "path");
       if(!pathString.empty()) {
         entry.path = pathString;
@@ -178,10 +180,7 @@ QVector<PathEntry> parsePathEntry(QJsonObject &jsonMainDoc, bool baseRecursive,
       if(!imageListString.empty()) {
         entry.imageList = imageListString;
       }
-      std::string typeString = ParseJSONString(schedulerJson, "type");
-      if(!pathString.empty()) {
-        entry.type = typeString;
-      }
+
       SetJSONBool(entry.exclusive, schedulerJson, "exclusive");
 
       if(schedulerJson.contains("times") && schedulerJson["times"].isArray())
@@ -201,7 +200,7 @@ QVector<PathEntry> parsePathEntry(QJsonObject &jsonMainDoc, bool baseRecursive,
                 {
                     window.endDisplay = QTime::fromString(timesJson["end"].toString());
                 }
-                entry.timeWindows.append(window);
+                entry.baseDisplayOptions.timeWindows.append(window);
             }
         }
       }
diff --git a/src/appconfig.h b/src/appconfig.h
index 61fadb3..849de7b 100644
--- a/src/appconfig.h
+++ b/src/appconfig.h
@@ -16,15 +16,38 @@ struct Config {
 };
 
 struct PathEntry {
-  QVector<DisplayTimeWindow> timeWindows;
   std::string path = "";
   std::string imageList = "";
-  std::string type = "";
-  bool exclusive = false;
+  bool exclusive = false; // only use this entry when it is valid, skip others
 
   bool recursive = false;
   bool shuffle = false;
   bool sorted = false;
+  ImageDisplayOptions baseDisplayOptions;
+
+  bool operator==(const PathEntry &b) const
+  {
+    return !operator!=(b);
+  }
+  bool operator!=(const PathEntry &b) const
+  {
+    if (b.exclusive != exclusive)
+      return true;
+    if (b.recursive != recursive || b.shuffle != shuffle || b.sorted != sorted)
+      return true;
+    if(b.baseDisplayOptions.fitAspectAxisToWindow != baseDisplayOptions.fitAspectAxisToWindow)
+      return true;
+    if (b.path != path || b.imageList != imageList)
+      return true;
+    if (b.baseDisplayOptions.timeWindows.count() != baseDisplayOptions.timeWindows.count())
+      return true;
+    for(int i = 0; i < baseDisplayOptions.timeWindows.count(); ++i)
+    {
+      if (b.baseDisplayOptions.timeWindows[i] != baseDisplayOptions.timeWindows[i])
+        return true;
+    }
+    return false;
+  }
 };
 
 // app level configuration
@@ -39,18 +62,16 @@ struct AppConfig : public Config {
 
     static const std::string valid_aspects; 
   public:
-    bool PathOptionsChanged(AppConfig &other) {
+    bool PathOptionsChanged(AppConfig &other) 
+    {
       if (paths.count() != other.paths.count())
         return true;
       for(int index = 0; index < paths.count(); ++index)
       {
-        if ( other.paths[index].recursive != paths[index].recursive || other.paths[index].shuffle != paths[index].shuffle
-        || other.paths[index].sorted != paths[index].sorted)
-          return true;
-        if ( other.paths[index].path != paths[index].path || other.paths[index].imageList != paths[index].imageList )
+        if(other.paths[index] != paths[index])
           return true;
       }
-     return false;
+      return false;
     }
 };
 
diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 839a919..147d94b 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -337,12 +337,12 @@ ListImageSelector::~ListImageSelector()
 {
 }
 
-void ListImageSelector::AddImageSelector(std::unique_ptr<ImageSelector>& selector, const QVector<DisplayTimeWindow> &displayTimeWindows, const bool exclusiveIn)
+void ListImageSelector::AddImageSelector(std::unique_ptr<ImageSelector>& selector, const bool exclusiveIn, const ImageDisplayOptions& baseDisplayOptionsIn)
 {
   SelectoryEntry entry;
   entry.selector = std::move(selector);
-  entry.displayTimeWindows = displayTimeWindows;
   entry.exclusive = exclusiveIn;
+  entry.baseDisplayOptions = baseDisplayOptionsIn;
   imageSelectors.push_back(std::move(entry));
   currentSelector = imageSelectors.begin();
 }
@@ -353,9 +353,12 @@ const ImageDetails ListImageSelector::getNextImage(const ImageDisplayOptions& ba
   // check for exclusive time windows
   for(auto& selector: imageSelectors)
   {
-    if (imageInsideTimeWindow(selector.displayTimeWindows) && selector.exclusive) 
+    if (imageInsideTimeWindow(selector.baseDisplayOptions.timeWindows) && selector.exclusive) 
     {
-      return selector.selector->getNextImage(baseOptions);
+      ImageDisplayOptions options = baseOptions;
+      if (selector.baseDisplayOptions.fitAspectAxisToWindow)
+        options.fitAspectAxisToWindow = true;
+      return selector.selector->getNextImage(options);
     }
   }
 
@@ -367,9 +370,12 @@ const ImageDetails ListImageSelector::getNextImage(const ImageDisplayOptions& ba
     {
       currentSelector = imageSelectors.begin();
     }
-    if (imageInsideTimeWindow(currentSelector->displayTimeWindows))
+    if (imageInsideTimeWindow(currentSelector->baseDisplayOptions.timeWindows))
     {
-      return currentSelector->selector->getNextImage(baseOptions);
+      ImageDisplayOptions options = baseOptions;
+      if (currentSelector->baseDisplayOptions.fitAspectAxisToWindow)
+        options.fitAspectAxisToWindow = true;
+      return currentSelector->selector->getNextImage(options);
     }
   }
   while(true);
diff --git a/src/imageselector.h b/src/imageselector.h
index eeaccc3..4443160 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -70,12 +70,12 @@ public:
     ListImageSelector();
     virtual ~ListImageSelector();
     virtual const ImageDetails getNextImage(const ImageDisplayOptions &baseOptions);
-    void AddImageSelector(std::unique_ptr<ImageSelector>& selector, const QVector<DisplayTimeWindow> &displayTimeWindows, const bool exclusiveIn);
+    void AddImageSelector(std::unique_ptr<ImageSelector>& selector, const bool exclusiveIn, const ImageDisplayOptions& baseDisplayOptionsIn);
 
 private:
     struct SelectoryEntry {
         std::unique_ptr<ImageSelector> selector;
-        QVector<DisplayTimeWindow> displayTimeWindows;
+        ImageDisplayOptions baseDisplayOptions;
         bool exclusive = false;
     };
     std::vector<SelectoryEntry> imageSelectors;
diff --git a/src/imagestructs.h b/src/imagestructs.h
index ce937fc..b7042ba 100644
--- a/src/imagestructs.h
+++ b/src/imagestructs.h
@@ -12,6 +12,11 @@ struct DisplayTimeWindow
 {
     QTime startDisplay = QTime(0,0,0,0);
     QTime endDisplay = QTime(23,59,59,0);
+    
+    bool operator!=(const DisplayTimeWindow &b) const
+    {
+        return startDisplay != b.startDisplay || endDisplay != b.endDisplay;
+    }
 };
 
 // options to consider when displaying an image
diff --git a/src/main.cpp b/src/main.cpp
index f2c3d4c..26ed635 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -173,7 +173,7 @@ std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig)
     for(const auto &path : appConfig.paths)
     {
       auto selector = GetSelectorForConfig(path, appConfig.debugMode);
-      listSelector->AddImageSelector(selector,path.timeWindows, path.exclusive);
+      listSelector->AddImageSelector(selector, path.exclusive, path.baseDisplayOptions);
     }
     // new things
     return listSelector;

From 3557b6041fd442c2ee33312585610eb9035f4258 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sun, 22 Aug 2021 11:36:00 +1200
Subject: [PATCH 18/30] - Update .pro file with new source and headers

---
 src/slide.pro | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/slide.pro b/src/slide.pro
index a3804b9..560414a 100644
--- a/src/slide.pro
+++ b/src/slide.pro
@@ -5,6 +5,7 @@
 #-------------------------------------------------
 
 QT       += core gui
+# CONFIG += qt debug
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
@@ -33,14 +34,17 @@ SOURCES += \
         imageswitcher.cpp \
         pathtraverser.cpp \
         overlay.cpp \
-    imageselector.cpp
+        imageselector.cpp \
+        appconfig.cpp
 
 HEADERS += \
         mainwindow.h \
         imageselector.h \
         pathtraverser.h \
         overlay.h \
-    imageswitcher.h
+        imageswitcher.h \
+        imagestructs.h \
+        appconfig.h
 
 FORMS += \
         mainwindow.ui

From 833e7ef915e6f3cf1f95ac52f7a49710065f828e Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sun, 22 Aug 2021 15:10:26 +1200
Subject: [PATCH 19/30] - Add the ability to parse the RSS feeds from reddit
 groups (in particular the image feed groups like EarthPorn) and display them

---
 src/appconfig.cpp     |  11 +++-
 src/appconfig.h       |   3 +-
 src/imageselector.cpp |  18 ++++++
 src/main.cpp          |  26 ++++++---
 src/mainwindow.cpp    |  60 ++++++++++++++++++-
 src/mainwindow.h      |   7 +++
 src/pathtraverser.cpp | 131 +++++++++++++++++++++++++++++++++++++++++-
 src/pathtraverser.h   |  26 +++++++++
 src/slide.pro         |   4 +-
 9 files changed, 271 insertions(+), 15 deletions(-)

diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index fe06e57..5532da7 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -180,6 +180,10 @@ QVector<PathEntry> parsePathEntry(QJsonObject &jsonMainDoc, bool baseRecursive,
       if(!imageListString.empty()) {
         entry.imageList = imageListString;
       }
+      std::string rssFeedURLString = ParseJSONString(schedulerJson, "redditrss");
+      if(!rssFeedURLString.empty()) {
+        entry.rssFeedURL = rssFeedURLString;
+      }
 
       SetJSONBool(entry.exclusive, schedulerJson, "exclusive");
 
@@ -229,7 +233,7 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
   QJsonDocument d = QJsonDocument::fromJson(val.toUtf8());
   QJsonObject jsonDoc = d.object();
 
-  bool baseRecursive, baseShuffle, baseSorted;
+  bool baseRecursive = false, baseShuffle = false, baseSorted = false;
   SetJSONBool(baseRecursive, jsonDoc, "recursive");
   SetJSONBool(baseShuffle, jsonDoc, "shuffle");
   SetJSONBool(baseSorted, jsonDoc, "sorted");
@@ -258,6 +262,11 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
     {
       entry.imageList = imageListString;
     }
+    std::string rssFeedURLString = ParseJSONString(jsonDoc, "redditrss");
+    if(!rssFeedURLString.empty())
+    {
+      entry.rssFeedURL = rssFeedURLString;
+    }
     loadedConfig.paths.append(entry);
   }
   loadedConfig.configPath = commandLineConfig.configPath;
diff --git a/src/appconfig.h b/src/appconfig.h
index 849de7b..324a055 100644
--- a/src/appconfig.h
+++ b/src/appconfig.h
@@ -18,6 +18,7 @@ struct Config {
 struct PathEntry {
   std::string path = "";
   std::string imageList = "";
+  std::string rssFeedURL = "";
   bool exclusive = false; // only use this entry when it is valid, skip others
 
   bool recursive = false;
@@ -37,7 +38,7 @@ struct PathEntry {
       return true;
     if(b.baseDisplayOptions.fitAspectAxisToWindow != baseDisplayOptions.fitAspectAxisToWindow)
       return true;
-    if (b.path != path || b.imageList != imageList)
+    if (b.path != path || b.imageList != imageList || b.rssFeedURL != rssFeedURL)
       return true;
     if (b.baseDisplayOptions.timeWindows.count() != baseDisplayOptions.timeWindows.count())
       return true;
diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 147d94b..bbe6fc1 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -146,6 +146,9 @@ bool ImageSelector::imageInsideTimeWindow(const QVector<DisplayTimeWindow> &time
 
 bool ImageSelector::imageMatchesFilter(const ImageDetails& imageDetails)
 {
+  if(imageDetails.filename.find("https://") != std::string::npos)
+    return imageInsideTimeWindow(imageDetails.options.timeWindows);
+
   if(!QFileInfo::exists(QString(imageDetails.filename.c_str())))
   {
     if(debugMode)
@@ -245,9 +248,16 @@ const ImageDetails ShuffleImageSelector::getNextImage(const ImageDisplayOptions
   {
     return imageDetails;
   }
+  bool bReloadedImages = false;
   imageDetails = populateImageDetails(pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString()), baseOptions);
   current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
   while(!imageMatchesFilter(imageDetails)) {
+    if(current_image_shuffle >= images.size()) {
+      // don't keep looping
+      if(bReloadedImages == true)
+        return ImageDetails();
+      bReloadedImages = true;
+    }
     reloadImagesIfNoneLeft();
     imageDetails = populateImageDetails(pathTraverser->getImagePath(images.at(current_image_shuffle).toStdString()),baseOptions);
     current_image_shuffle = current_image_shuffle + 1; // ignore and move to next image
@@ -300,8 +310,16 @@ const ImageDetails SortedImageSelector::getNextImage(const ImageDisplayOptions &
   {
     return imageDetails;
   }
+  bool bReloadedImages = false;
   imageDetails = populateImageDetails(pathTraverser->getImagePath(images.takeFirst().toStdString()), baseOptions);
   while(!imageMatchesFilter(imageDetails)) {
+    if (images.size() == 0) {
+      // don't keep looping
+      if(bReloadedImages == true)
+        return ImageDetails();
+      bReloadedImages = true;
+    }
+
     reloadImagesIfEmpty();
     imageDetails = populateImageDetails(pathTraverser->getImagePath(images.takeFirst().toStdString()), baseOptions);
   }
diff --git a/src/main.cpp b/src/main.cpp
index 26ed635..da5a306 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -6,6 +6,7 @@
 #include "appconfig.h"
 
 #include <QApplication>
+#include <QNetworkAccessManager>
 #include <iostream>
 #include <sys/file.h>
 #include <errno.h>
@@ -128,10 +129,14 @@ void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
   w.setBaseOptions(appConfig.baseDisplayOptions);
 }
 
-std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, const bool debugMode)
+std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, QNetworkAccessManager& networkManagerIn, const bool debugMode)
 {
   std::unique_ptr<PathTraverser> pathTraverser;
-  if (!path.imageList.empty())
+  if (!path.rssFeedURL.empty())
+  {
+    pathTraverser = std::unique_ptr<PathTraverser>(new RedditRSSFeedPathTraverser(path.rssFeedURL, networkManagerIn, debugMode));
+  }
+  else if (!path.imageList.empty())
   {
     pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(path.imageList, debugMode));
   }
@@ -161,18 +166,18 @@ std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, const
   return selector;
 }
 
-std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig)
+std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig, QNetworkAccessManager& networkManagerIn)
 {
   if(appConfig.paths.count()==1)
   {
-    return GetSelectorForConfig(appConfig.paths[0], appConfig.debugMode);
+    return GetSelectorForConfig(appConfig.paths[0], networkManagerIn, appConfig.debugMode);
   }
   else
   {
     std::unique_ptr<ListImageSelector> listSelector(new ListImageSelector());
     for(const auto &path : appConfig.paths)
     {
-      auto selector = GetSelectorForConfig(path, appConfig.debugMode);
+      auto selector = GetSelectorForConfig(path, networkManagerIn, appConfig.debugMode);
       listSelector->AddImageSelector(selector, path.exclusive, path.baseDisplayOptions);
     }
     // new things
@@ -181,7 +186,7 @@ std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig)
 }
 
 
-void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)
+void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector, QNetworkAccessManager& networkManager)
 {  
   QString jsonFile = getAppConfigFilePath(appConfig.configPath);
   QDir directory;
@@ -198,7 +203,7 @@ void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *sw
     ConfigureWindowFromSettings(w, appConfig);
     if(appConfig.PathOptionsChanged(oldConfig))
     {
-      std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
+      std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig, networkManager);
       switcher->setImageSelector(selector);
     }
 
@@ -233,16 +238,19 @@ int main(int argc, char *argv[])
     std::cout << "Overlay input: " << appConfig.overlay << std::endl;
   }
   
+  QNetworkAccessManager webCtrl; 
+
   MainWindow w;
   ConfigureWindowFromSettings(w, appConfig);
+  w.setNetworkManager(&webCtrl);
   w.show();
 
-  std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
+  std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig, webCtrl);
   selector->setDebugMode(appConfig.debugMode);
   
   ImageSwitcher switcher(w, appConfig.rotationSeconds * 1000, selector);
   w.setImageSwitcher(&switcher);
-  std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloader = [&appConfig](MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector) { ReloadConfigIfNeeded(appConfig, w, switcher, selector); };
+  std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloader = [&appConfig, &webCtrl](MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector) { ReloadConfigIfNeeded(appConfig, w, switcher, selector, webCtrl); };
   switcher.setConfigFileReloader(reloader);
   switcher.start();
   return a.exec();
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index d6478f0..3f1323b 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -17,6 +17,7 @@
 #include <QGraphicsPixmapItem>
 #include <QApplication>
 #include <QScreen>
+#include <QNetworkReply>
 #include <sstream>
 
 MainWindow::MainWindow(QWidget *parent) :
@@ -165,15 +166,46 @@ void MainWindow::checkWindowSize()
 void MainWindow::setImage(const ImageDetails &imageDetails)
 {
     currentImage = imageDetails;
+    downloadedData.clear();
+    if (pendingReply)
+    {
+      pendingReply->abort();
+    }
     updateImage(false);
 }
 
+void MainWindow::fileDownloaded(QNetworkReply* netReply) 
+{
+  if (netReply == pendingReply)
+  {
+    pendingReply = nullptr;
+    QNetworkReply::NetworkError err = netReply->error();
+    if (err == QNetworkReply::NoError)
+    {
+      downloadedData = netReply->readAll();
+      netReply->deleteLater();
+      updateImage(false);
+    }
+  }
+}
+
 void MainWindow::updateImage(bool immediately)
 {
     checkWindowSize();
     if (currentImage.filename == "")
       return;
 
+    if (currentImage.filename.find("https://") != std::string::npos && downloadedData.isNull())
+    {
+      if (pendingReply == nullptr)
+      {
+        QNetworkRequest request(QUrl(currentImage.filename.c_str()));
+        pendingReply = networkManager->get(request);
+        connect( networkManager, SIGNAL (finished(QNetworkReply*)), this, SLOT (fileDownloaded(QNetworkReply*)));
+      }
+      return;
+    }
+
     QLabel *label = this->findChild<QLabel*>("image");
     const QPixmap* oldImage = label->pixmap();
     if (oldImage != NULL && !immediately)
@@ -183,7 +215,28 @@ void MainWindow::updateImage(bool immediately)
       this->setPalette(palette);
     }
 
-    QPixmap p( currentImage.filename.c_str() );
+    QPixmap p;
+    if (!downloadedData.isNull())
+    {
+      p.loadFromData(downloadedData);
+      // BUG BUG have the selector update this?
+      currentImage.width = p.width();
+      currentImage.height = p.height();
+      currentImage.rotation = 0;
+      if (currentImage.width > currentImage.height) {
+        currentImage.aspect = ImageAspect_Landscape;
+      } else if (currentImage.height > currentImage.width) {
+        currentImage.aspect = ImageAspect_Portrait;
+      } else {
+        currentImage.aspect = ImageAspect_Any;
+      }
+
+    }
+    else
+    {
+      p.load( currentImage.filename.c_str() );
+    }
+
     if(debugMode)
     {
       std::cout << "size:" << p.width() << "x" << p.height() << "(window:" << width() << "," << height() << ")" << std::endl;
@@ -382,3 +435,8 @@ const ImageDisplayOptions &MainWindow::getBaseOptions()
 {
    return baseImageOptions; 
 }
+
+void MainWindow::setNetworkManager(QNetworkAccessManager *networkManagerIn)
+{
+  networkManager = networkManagerIn;
+}
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 1a3c8f5..3d569d7 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -3,6 +3,7 @@
 
 #include <QMainWindow>
 #include <QPixmap>
+#include <QNetworkAccessManager>
 #include "imagestructs.h"
 #include "imageselector.h"
 
@@ -33,8 +34,11 @@ public:
     void setBaseOptions(const ImageDisplayOptions &baseOptionsIn);
     const ImageDisplayOptions &getBaseOptions();
     void setImageSwitcher(ImageSwitcher *switcherIn);
+    void setNetworkManager(QNetworkAccessManager *networkManagerIn);
 public slots:
     void checkWindowSize();
+private slots:
+  void fileDownloaded(QNetworkReply* pReply);
 private:
     Ui::MainWindow *ui;
 
@@ -43,6 +47,9 @@ private:
     ImageDisplayOptions baseImageOptions;
     bool imageAspectMatchesMonitor = false;
     ImageDetails currentImage;
+    QByteArray downloadedData;
+    QNetworkAccessManager *networkManager = nullptr;
+    QNetworkReply *pendingReply = nullptr;
     bool debugMode = false;
     QSize lastScreenSize = {0,0};
 
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index d42385f..048c37a 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -5,6 +5,8 @@
 #include <QDirIterator>
 #include <QDir>
 #include <QFileInfo>
+#include <QDomDocument>
+#include <QDomAttr>
 #include <iostream>
 #include <stdlib.h>     /* srand, rand */
 
@@ -108,5 +110,132 @@ ImageDisplayOptions ImageListPathTraverser::UpdateOptionsForImage(const std::str
   // no per file options modification supported
   Q_UNUSED(filename);
   Q_UNUSED(baseOptions);
-  return ImageDisplayOptions();
+  return baseOptions;
+}
+
+
+RedditRSSFeedPathTraverser::RedditRSSFeedPathTraverser(const std::string& rssFeedURLIn, QNetworkAccessManager& networkManager, bool debugModeIn) :
+  PathTraverser("",debugModeIn), rssFeedURL(rssFeedURLIn), webCtrl(networkManager)
+{
+  connect( &webCtrl, SIGNAL (finished(QNetworkReply*)), this, SLOT (fileDownloaded(QNetworkReply*)));
+  RequestRSSFeed();
+}
+
+RedditRSSFeedPathTraverser::~RedditRSSFeedPathTraverser()
+{
+}
+
+void RedditRSSFeedPathTraverser::RequestRSSFeed()
+{
+  if (pendingReply)
+  {
+    pendingReply->abort();
+  }
+  if (debugMode)
+  {
+    std::cout << "Requesting RSS feed:" << rssFeedURL << std::endl;
+  }
+  rssRequestedTime = QDateTime::currentDateTime();
+  QNetworkRequest request(QUrl(rssFeedURL.c_str()));
+  pendingReply = webCtrl.get(request);
+}
+
+void RedditRSSFeedPathTraverser::fileDownloaded(QNetworkReply* netReply) 
+{
+  if (netReply != pendingReply)
+    return;
+
+  pendingReply = nullptr;
+
+  QNetworkReply::NetworkError err = netReply->error();
+  if (err != QNetworkReply::NoError)
+  {
+    std::cout << "Failed to load Reddit RSS URL: " << err << std::endl;
+    return;
+  }
+
+  QString str (netReply->readAll());
+  QVariant vt = netReply->attribute(QNetworkRequest::RedirectionTargetAttribute);
+  netReply->deleteLater();
+  if (!vt.isNull())
+  {
+    if (debugMode)
+    {
+      std::cout << "Redirected to:" << vt.toUrl().toString().toStdString() << std::endl;
+    }
+    webCtrl.get(QNetworkRequest(vt.toUrl()));
+  }
+  else
+  {
+    QDomDocument doc;
+    QString error;
+    if (!doc.setContent(str, false, &error))
+    {
+      if (debugMode)
+      {
+        std::cout << "Failed to load page:" << error.toStdString() << std::endl;
+      }
+    }
+    else
+    {
+      QDomElement docElem = doc.documentElement();
+      QDomNodeList nodeList = docElem.elementsByTagName("entry"); 
+      for (int iEntry = 0; iEntry < nodeList.length(); ++iEntry)
+      {
+        QDomNode node = nodeList.item(iEntry);
+        QDomElement e = node.toElement();
+        QDomNode contentNode =  e.elementsByTagName("content").item(0).firstChild();
+        QDomDocument docContent;
+        if (!docContent.setContent(contentNode.nodeValue(), false, &error))
+        {
+          continue;
+        }
+
+        QDomNodeList addressEntries = docContent.documentElement().elementsByTagName("a");
+        for (int iAddr = 0; iAddr < addressEntries.length(); ++iAddr)
+        {
+          QDomNode node = addressEntries.item(iAddr);
+          /*QString output;
+          QTextStream stream(&output);
+          node.save(stream, 0);
+          qDebug() << "nodeValue: " << output;*/
+          if (node.toElement().text() == "[link]" && node.hasAttributes() )
+          {
+            QDomAttr a = node.toElement().attributeNode("href");
+            // check if the URL matches one of our supported formats
+            for ( const QString& format : supportedFormats ) 
+            {
+              if (a.value().endsWith(format))
+              {
+                imageURLS.append(a.value());
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+
+QStringList RedditRSSFeedPathTraverser::getImages() const
+{
+  // refresh the feed after 5 hours
+  if (rssRequestedTime.secsTo(QDateTime::currentDateTime()) > 60*60*5 )
+  {
+    const_cast<RedditRSSFeedPathTraverser *>(this)->RequestRSSFeed(); 
+  }
+  return imageURLS;
+}
+
+const std::string RedditRSSFeedPathTraverser::getImagePath(const std::string image) const
+{
+  return image;
+}
+
+ImageDisplayOptions RedditRSSFeedPathTraverser::UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const
+{
+  // no per file options modification supported
+  Q_UNUSED(filename);
+  return baseOptions;
 }
diff --git a/src/pathtraverser.h b/src/pathtraverser.h
index 7f4d921..9dc6425 100644
--- a/src/pathtraverser.h
+++ b/src/pathtraverser.h
@@ -4,6 +4,9 @@
 #include <iostream>
 #include <QDir>
 #include <QStringList>
+#include <QNetworkAccessManager>
+#include <QNetworkRequest>
+#include <QNetworkReply>
 #include "imageselector.h"
 
 static const QStringList supportedFormats={"jpg","jpeg","png","tif","tiff"};
@@ -58,4 +61,27 @@ class ImageListPathTraverser : public PathTraverser
   private:
     QStringList imageList;
 };
+
+class RedditRSSFeedPathTraverser: public QObject, public PathTraverser
+{
+  Q_OBJECT 
+ public:
+    RedditRSSFeedPathTraverser(const std::string& rSSFeedURL,QNetworkAccessManager& networkManager, bool debugModeIn);
+    virtual ~RedditRSSFeedPathTraverser();
+
+    virtual QStringList getImages() const;
+    virtual const std::string getImagePath(const std::string image) const;
+    virtual ImageDisplayOptions UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const;
+
+  private slots:
+    void fileDownloaded(QNetworkReply* pReply);
+  private:
+    void RequestRSSFeed();
+    std::string rssFeedURL;
+    QStringList imageURLS;
+    QNetworkAccessManager& webCtrl; 
+    QNetworkReply *pendingReply = nullptr;
+    QDateTime rssRequestedTime;
+};
+
 #endif // PATHTRAVERSER_H
diff --git a/src/slide.pro b/src/slide.pro
index 560414a..db060ef 100644
--- a/src/slide.pro
+++ b/src/slide.pro
@@ -4,8 +4,8 @@
 #
 #-------------------------------------------------
 
-QT       += core gui
-# CONFIG += qt debug
+QT       += core gui network xml
+CONFIG += qt debug
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 

From be8f615c21acbea3b338689866c62a1d1bbbe7ca Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Thu, 26 Aug 2021 12:13:09 +1200
Subject: [PATCH 20/30] - Add a new Log() function to replace ad-hoc std::cout
 calls wrapped in debugMode checks - Remove debugMode from classes that don't
 need it (i.e all of them)

---
 src/appconfig.cpp     | 14 ++++++--------
 src/appconfig.h       |  2 +-
 src/imageselector.cpp | 33 ++++++++++-----------------------
 src/imageselector.h   |  4 +---
 src/imageswitcher.cpp |  4 ++--
 src/imageswitcher.h   |  4 ++--
 src/logger.cpp        | 14 ++++++++++++++
 src/logger.h          | 20 ++++++++++++++++++++
 src/main.cpp          | 32 +++++++++++++-------------------
 src/mainwindow.cpp    | 24 +++++-------------------
 src/mainwindow.h      |  2 --
 src/overlay.cpp       | 21 ++++-----------------
 src/overlay.h         |  3 ---
 src/pathtraverser.cpp | 38 +++++++++++++++-----------------------
 src/pathtraverser.h   | 11 +++++------
 src/slide.pro         | 10 +++++++---
 16 files changed, 105 insertions(+), 131 deletions(-)
 create mode 100644 src/logger.cpp
 create mode 100644 src/logger.h

diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index 5532da7..b424fee 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -1,4 +1,5 @@
 #include "appconfig.h"
+#include "logger.h"
 
 #include <QJsonDocument>
 #include <QJsonObject>
@@ -47,7 +48,7 @@ void SetJSONBool(bool &value, QJsonObject jsonDoc, const char *key) {
   }
 }
 
-Config loadConfiguration(const std::string &configFilePath, const Config &currentConfig, bool debugMode) {
+Config loadConfiguration(const std::string &configFilePath, const Config &currentConfig) {
   QString jsonFile(configFilePath.c_str());
   QDir directory;
   if(!directory.exists(jsonFile))
@@ -57,10 +58,7 @@ Config loadConfiguration(const std::string &configFilePath, const Config &curren
 
   Config userConfig = currentConfig;
 
-  if(debugMode)
-  {
-    std::cout << "Found options file: " << jsonFile.toStdString() << std::endl;
-  }
+  Log( "Found options file: ", jsonFile.toStdString() );
 
   QString val;
   QFile file;
@@ -222,7 +220,7 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
     return commandLineConfig;
   }
 
-  AppConfig loadedConfig = loadConfiguration(jsonFile.toStdString(), commandLineConfig, commandLineConfig.debugMode);
+  AppConfig loadedConfig = loadConfiguration(jsonFile.toStdString(), commandLineConfig);
   
   QString val;
   QFile file;
@@ -273,12 +271,12 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
   return loadedConfig;
 }
 
-Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig, bool debugMode) {
+Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig) {
   QDir directory(folderPath.c_str());
   QString jsonFile = directory.filePath(QString("options.json"));
   if(directory.exists(jsonFile))
   {
-      return loadConfiguration(jsonFile.toStdString(), currentConfig, debugMode );
+      return loadConfiguration(jsonFile.toStdString(), currentConfig );
   }
   return currentConfig;
 }
\ No newline at end of file
diff --git a/src/appconfig.h b/src/appconfig.h
index 324a055..c8e7d8e 100644
--- a/src/appconfig.h
+++ b/src/appconfig.h
@@ -77,7 +77,7 @@ struct AppConfig : public Config {
 };
 
 AppConfig loadAppConfiguration(const AppConfig &commandLineConfig);
-Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig, bool debugMode);
+Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig);
 
 ImageAspect parseAspectFromString(char aspect);
 QString getAppConfigFilePath(const std::string &configPath);
diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index bbe6fc1..a4561b6 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -1,6 +1,7 @@
 #include "imageselector.h"
 #include "pathtraverser.h"
 #include "mainwindow.h"
+#include "logger.h"
 #include <QDirIterator>
 #include <QTimer>
 #include <QApplication>
@@ -21,11 +22,6 @@ ImageSelector::ImageSelector() {}
 
 ImageSelector::~ImageSelector(){}
 
-void ImageSelector::setDebugMode(bool debugModeIn) 
-{ 
-  debugMode = debugModeIn;
-}
-
 int ReadExifTag(ExifData* exifData, ExifTag tag, bool shortRead = false)
 {
   int value = -1;
@@ -133,12 +129,12 @@ bool ImageSelector::imageInsideTimeWindow(const QVector<DisplayTimeWindow> &time
       return true;
     }
   }
-  if(debugMode && timeWindows.count() > 0)
+  if(ShouldLog() && timeWindows.count() > 0)
   {
-    std::cout << "image display time outside windows: " << std::endl;
+    Log( "image display time outside window: ");
     for(auto &timeWindow : timeWindows) 
     {
-      std::cout << "time: " << timeWindow.startDisplay.toString().toStdString() << "-" << timeWindow.endDisplay.toString().toStdString() << std::endl;
+      Log("time: ", timeWindow.startDisplay.toString().toStdString(), "-", timeWindow.endDisplay.toString().toStdString());
     }
   }
   return false;
@@ -151,19 +147,13 @@ bool ImageSelector::imageMatchesFilter(const ImageDetails& imageDetails)
 
   if(!QFileInfo::exists(QString(imageDetails.filename.c_str())))
   {
-    if(debugMode)
-    {
-      std::cout << "file not found: " << imageDetails.filename << std::endl;
-    }
+    Log("file not found: ", imageDetails.filename);
     return false;
   }
 
   if(!imageValidForAspect(imageDetails)) 
   {
-    if(debugMode)
-    {
-      std::cout << "image aspect ratio doesn't match filter '" << imageDetails.options.onlyAspect << "' : " << imageDetails.filename << std::endl;
-    }
+    Log("image aspect ratio doesn't match filter '", imageDetails.options.onlyAspect, "' : ", imageDetails.filename);
     return false;
   }
 
@@ -217,10 +207,7 @@ const ImageDetails RandomImageSelector::getNextImage(const ImageDisplayOptions &
 
 unsigned int RandomImageSelector::selectRandom(const QStringList& images) const
 {
-  if(debugMode)
-  {
-    std::cout << "images: " << images.size() << std::endl;
-  }
+  Log("images: ", images.size());
   if (images.size() == 0)
   {
     throw std::string("No jpg images found in given folder");
@@ -335,11 +322,11 @@ void SortedImageSelector::reloadImagesIfEmpty()
   {
     images = pathTraverser->getImages();
     std::sort(images.begin(), images.end());
-    if(debugMode)
+    if(ShouldLog())
     {
-      std::cout << "read " << images.size() << " images." << std::endl;
+      Log( "read ", images.size(), " images.");
       for (int i = 0;i <images.size();i++){
-          std::cout << images[i].toStdString() << std::endl;
+          Log(images[i].toStdString());
       }
     }
   }
diff --git a/src/imageselector.h b/src/imageselector.h
index 4443160..81088f8 100644
--- a/src/imageselector.h
+++ b/src/imageselector.h
@@ -17,15 +17,13 @@ public:
     ImageSelector(); // use case for when you don't own your own traverser
     virtual ~ImageSelector();
     virtual const ImageDetails getNextImage(const ImageDisplayOptions &baseOptions) = 0;
-    void setDebugMode(bool debugModeIn);
-
+ 
 protected:
     ImageDetails populateImageDetails(const std::string&filename, const ImageDisplayOptions &baseOptions);
     bool imageValidForAspect(const ImageDetails& imageDetails);
     bool imageMatchesFilter(const ImageDetails& imageDetails);
     bool imageInsideTimeWindow(const QVector<DisplayTimeWindow> &timeWindows);
     std::unique_ptr<PathTraverser> pathTraverser;
-    bool debugMode = false;
 };
 
 class RandomImageSelector : public ImageSelector
diff --git a/src/imageswitcher.cpp b/src/imageswitcher.cpp
index 4347af2..e0b2fa0 100644
--- a/src/imageswitcher.cpp
+++ b/src/imageswitcher.cpp
@@ -23,7 +23,7 @@ void ImageSwitcher::updateImage()
 {
     if(reloadConfigIfNeeded)
     {
-      reloadConfigIfNeeded(window, this, selector.get());
+      reloadConfigIfNeeded(window, this);
     }
     ImageDetails imageDetails = selector->getNextImage(window.getBaseOptions());
     if (imageDetails.filename == "")
@@ -52,7 +52,7 @@ void ImageSwitcher::scheduleImageUpdate()
   QTimer::singleShot(100, this, SLOT(updateImage())); 
 }
 
-void ImageSwitcher::setConfigFileReloader(std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloadConfigIfNeededIn)
+void ImageSwitcher::setConfigFileReloader(std::function<void(MainWindow &w, ImageSwitcher *switcher)> reloadConfigIfNeededIn)
 {
   reloadConfigIfNeeded = reloadConfigIfNeededIn;
 }
diff --git a/src/imageswitcher.h b/src/imageswitcher.h
index ea00e49..4f501d7 100644
--- a/src/imageswitcher.h
+++ b/src/imageswitcher.h
@@ -16,7 +16,7 @@ public:
     ImageSwitcher(MainWindow& w, unsigned int timeoutMsec, std::unique_ptr<ImageSelector>& selector);
     void start();
     void scheduleImageUpdate();
-    void setConfigFileReloader(std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloadConfigIfNeededIn);
+    void setConfigFileReloader(std::function<void(MainWindow &w, ImageSwitcher *switcher)> reloadConfigIfNeededIn);
     void setRotationTime(unsigned int timeoutMsec);
     void setImageSelector(std::unique_ptr<ImageSelector>& selector);
 
@@ -29,7 +29,7 @@ private:
     QTimer timer;
     const unsigned int timeoutNoContent = 5 * 1000; // 5 sec
     QTimer timerNoContent;
-    std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloadConfigIfNeeded;
+    std::function<void(MainWindow &w, ImageSwitcher *switcher)> reloadConfigIfNeeded;
 };
 
 #endif // IMAGESWITCHER_H
diff --git a/src/logger.cpp b/src/logger.cpp
new file mode 100644
index 0000000..95bd309
--- /dev/null
+++ b/src/logger.cpp
@@ -0,0 +1,14 @@
+#include "logger.h"
+
+
+static bool shouldLog = false;
+
+void SetupLogger(bool shouldLogIn)
+{
+    shouldLog = shouldLogIn;
+}
+
+bool ShouldLog()
+{
+    return shouldLog;
+}
\ No newline at end of file
diff --git a/src/logger.h b/src/logger.h
new file mode 100644
index 0000000..630411b
--- /dev/null
+++ b/src/logger.h
@@ -0,0 +1,20 @@
+#ifndef LOGGER_H
+#define LOGGER_H
+#include <iostream>
+#include <string_view>
+#include <sstream>
+
+void SetupLogger(bool shouldLog);
+bool ShouldLog();
+
+template <typename ...Args>
+void Log(Args&& ...args) {
+    if(!ShouldLog())
+        return;
+    std::ostringstream stream;
+    (stream << ... << std::forward<Args>(args)) << std::endl;
+    std::cout << stream.str();
+}
+
+
+#endif // LOGGER_H
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index da5a306..3c55790 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -4,6 +4,7 @@
 #include "pathtraverser.h"
 #include "overlay.h"
 #include "appconfig.h"
+#include "logger.h"
 
 #include <QApplication>
 #include <QNetworkAccessManager>
@@ -123,30 +124,28 @@ void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
       w.setBackgroundOpacity(appConfig.backgroundOpacity);
   }
   std::unique_ptr<Overlay> o = std::unique_ptr<Overlay>(new Overlay(appConfig.overlay));
-  o->setDebugMode(appConfig.debugMode);
-  w.setDebugMode(appConfig.debugMode);
   w.setOverlay(o);
   w.setBaseOptions(appConfig.baseDisplayOptions);
 }
 
-std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, QNetworkAccessManager& networkManagerIn, const bool debugMode)
+std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, QNetworkAccessManager& networkManagerIn)
 {
   std::unique_ptr<PathTraverser> pathTraverser;
   if (!path.rssFeedURL.empty())
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new RedditRSSFeedPathTraverser(path.rssFeedURL, networkManagerIn, debugMode));
+    pathTraverser = std::unique_ptr<PathTraverser>(new RedditRSSFeedPathTraverser(path.rssFeedURL, networkManagerIn));
   }
   else if (!path.imageList.empty())
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(path.imageList, debugMode));
+    pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(path.imageList));
   }
   else if (path.recursive)
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path.path, debugMode));
+    pathTraverser = std::unique_ptr<PathTraverser>(new RecursivePathTraverser(path.path));
   }
   else
   {
-    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(path.path, debugMode));
+    pathTraverser = std::unique_ptr<PathTraverser>(new DefaultPathTraverser(path.path));
   }
 
   std::unique_ptr<ImageSelector> selector;
@@ -170,14 +169,14 @@ std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig, QNe
 {
   if(appConfig.paths.count()==1)
   {
-    return GetSelectorForConfig(appConfig.paths[0], networkManagerIn, appConfig.debugMode);
+    return GetSelectorForConfig(appConfig.paths[0], networkManagerIn);
   }
   else
   {
     std::unique_ptr<ListImageSelector> listSelector(new ListImageSelector());
     for(const auto &path : appConfig.paths)
     {
-      auto selector = GetSelectorForConfig(path, networkManagerIn, appConfig.debugMode);
+      auto selector = GetSelectorForConfig(path, networkManagerIn);
       listSelector->AddImageSelector(selector, path.exclusive, path.baseDisplayOptions);
     }
     // new things
@@ -186,7 +185,7 @@ std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig, QNe
 }
 
 
-void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector, QNetworkAccessManager& networkManager)
+void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher, QNetworkAccessManager& networkManager)
 {  
   QString jsonFile = getAppConfigFilePath(appConfig.configPath);
   QDir directory;
@@ -207,7 +206,6 @@ void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *sw
       switcher->setImageSelector(selector);
     }
 
-    selector->setDebugMode(appConfig.debugMode);
     switcher->setRotationTime(appConfig.rotationSeconds * 1000);
   }
 }
@@ -231,12 +229,9 @@ int main(int argc, char *argv[])
     usage(argv[0]);
     return 1;
   }
-
-  if(appConfig.debugMode)
-  {
-    std::cout << "Rotation Time: " << appConfig.rotationSeconds << std::endl;
-    std::cout << "Overlay input: " << appConfig.overlay << std::endl;
-  }
+  SetupLogger(appConfig.debugMode);
+  Log( "Rotation Time: ", appConfig.rotationSeconds );
+  Log( "Overlay input: ", appConfig.overlay );
   
   QNetworkAccessManager webCtrl; 
 
@@ -246,11 +241,10 @@ int main(int argc, char *argv[])
   w.show();
 
   std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig, webCtrl);
-  selector->setDebugMode(appConfig.debugMode);
   
   ImageSwitcher switcher(w, appConfig.rotationSeconds * 1000, selector);
   w.setImageSwitcher(&switcher);
-  std::function<void(MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector)> reloader = [&appConfig, &webCtrl](MainWindow &w, ImageSwitcher *switcher, ImageSelector *selector) { ReloadConfigIfNeeded(appConfig, w, switcher, selector, webCtrl); };
+  std::function<void(MainWindow &w, ImageSwitcher *switcher)> reloader = [&appConfig, &webCtrl](MainWindow &w, ImageSwitcher *switcher) { ReloadConfigIfNeeded(appConfig, w, switcher, webCtrl); };
   switcher.setConfigFileReloader(reloader);
   switcher.start();
   return a.exec();
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 3f1323b..267545f 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -2,6 +2,7 @@
 #include "overlay.h"
 #include "ui_mainwindow.h"
 #include "imageswitcher.h"
+#include "logger.h"
 #include <QLabel>
 #include <QPixmap>
 #include <QBitmap>
@@ -130,10 +131,7 @@ void MainWindow::checkWindowSize()
     QSize screenSize = screen->geometry().size();
     if(size() != screenSize)
     {
-      if(debugMode)
-      {
-        std::cout << "Resizing Window" << screenSize.width() << "," << screenSize.height() << std::endl;
-      }
+      Log("Resizing Window", screenSize.width(), "," , screenSize.height() );
       setFixedSize(screenSize);
       updateImage(true);
     }
@@ -144,10 +142,7 @@ void MainWindow::checkWindowSize()
       ImageAspect newAspect = isLandscape ? ImageAspect_Landscape : ImageAspect_Portrait;
       if (newAspect != baseImageOptions.onlyAspect)
       {
-        if(debugMode)
-        {
-          std::cout << "Changing image orientation to " << newAspect << std::endl;
-        }
+        Log("Changing image orientation to ", newAspect);
         baseImageOptions.onlyAspect = newAspect;
         currentImage.filename = "";
         warn("Monitor aspect changed, updating image...");
@@ -237,10 +232,7 @@ void MainWindow::updateImage(bool immediately)
       p.load( currentImage.filename.c_str() );
     }
 
-    if(debugMode)
-    {
-      std::cout << "size:" << p.width() << "x" << p.height() << "(window:" << width() << "," << height() << ")" << std::endl;
-    }
+    Log("size:", p.width(), "x", p.height(), "(window:", width(), ",", height(), ")");
 
     QPixmap rotated = getRotatedPixmap(p);
     QPixmap scaled = getScaledPixmap(rotated);
@@ -253,7 +245,7 @@ void MainWindow::updateImage(bool immediately)
       drawText(background, overlay->getMarginTopRight(), overlay->getFontsizeTopRight(), overlay->getRenderedTopRight(currentImage.filename).c_str(), Qt::AlignTop|Qt::AlignRight);
       drawText(background, overlay->getMarginBottomLeft(), overlay->getFontsizeBottomLeft(), overlay->getRenderedBottomLeft(currentImage.filename).c_str(), Qt::AlignBottom|Qt::AlignLeft);
       drawText(background, overlay->getMarginBottomRight(), overlay->getFontsizeBottomRight(), overlay->getRenderedBottomRight(currentImage.filename).c_str(), Qt::AlignBottom|Qt::AlignRight);
-      if (debugMode)
+      if (ShouldLog())
       {
         // draw a thumbnail version of the source image in the bottom left, to check for cropping issues
         QPainter pt(&background);
@@ -288,7 +280,6 @@ void MainWindow::updateImage(bool immediately)
 }
 
 void MainWindow::drawText(QPixmap& image, int margin, int fontsize, QString text, int alignment) {
-  //std::cout << "text: " << text.toStdString()  << " margin: " << margin << " fontsize: " << fontsize<< std::endl;
   QPainter pt(&image);
   pt.setPen(QPen(Qt::white));
   pt.setFont(QFont("Sans", fontsize, QFont::Bold));
@@ -426,11 +417,6 @@ void MainWindow::setImageSwitcher(ImageSwitcher *switcherIn)
    switcher = switcherIn; 
 }
 
-void MainWindow::setDebugMode(bool debugModeIn) 
-{
-  debugMode = debugModeIn;
-}
-
 const ImageDisplayOptions &MainWindow::getBaseOptions() 
 {
    return baseImageOptions; 
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 3d569d7..7538b35 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -30,7 +30,6 @@ public:
     void setBackgroundOpacity(unsigned int opacity);
     void warn(std::string text);
     void setOverlay(std::unique_ptr<Overlay> &overlay);
-    void setDebugMode(bool debugModeIn);
     void setBaseOptions(const ImageDisplayOptions &baseOptionsIn);
     const ImageDisplayOptions &getBaseOptions();
     void setImageSwitcher(ImageSwitcher *switcherIn);
@@ -50,7 +49,6 @@ private:
     QByteArray downloadedData;
     QNetworkAccessManager *networkManager = nullptr;
     QNetworkReply *pendingReply = nullptr;
-    bool debugMode = false;
     QSize lastScreenSize = {0,0};
 
     std::unique_ptr<Overlay> overlay;
diff --git a/src/overlay.cpp b/src/overlay.cpp
index f32c560..313d09f 100644
--- a/src/overlay.cpp
+++ b/src/overlay.cpp
@@ -1,4 +1,5 @@
 #include "overlay.h"
+#include "logger.h"
 #include <QString>
 #include <QDateTime>
 #include <libexif/exif-data.h>
@@ -19,11 +20,6 @@ Overlay::Overlay(const std::string overlayInput):
 
 Overlay::~Overlay() {}
 
-void Overlay::setDebugMode(const bool debugModeIn) 
-{ 
-  debugMode = debugModeIn; 
-}
-
 void Overlay::parseInput() {
   QString str = QString(overlayInput.c_str());
   QStringList corners = str.split(QLatin1Char(';'));
@@ -55,10 +51,7 @@ void Overlay::parseInput() {
 
 QString Overlay::getTemplate(QStringList components){
   if (components.size()>3) {
-    if(debugMode)
-    {
-      std::cout << "template: " << components[3].toStdString() << std::endl;
-    }
+    Log("template: ", components[3].toStdString());
     return components[3];
   }
   return "";
@@ -66,10 +59,7 @@ QString Overlay::getTemplate(QStringList components){
 
 int Overlay::getMargin(QStringList components){
   if (components.size()>1) {
-    if(debugMode)
-    {
-      std::cout << "margin: " << components[1].toStdString() << std::endl;
-    }
+    Log("margin: ", components[1].toStdString());
     int num = components[1].toInt();
     if (num > 0) {
       return num;
@@ -81,10 +71,7 @@ int Overlay::getMargin(QStringList components){
 
 int Overlay::getFontsize(QStringList components){
   if (components.size()>2) {
-    if(debugMode)
-    {
-      std::cout << "fontsize: " << components[2].toStdString() << std::endl;
-    }
+    Log("fontsize: ", components[2].toStdString());
     int num = components[2].toInt();
     if (num > 0) {
       return num;
diff --git a/src/overlay.h b/src/overlay.h
index 5837cba..d11f8f2 100644
--- a/src/overlay.h
+++ b/src/overlay.h
@@ -27,13 +27,10 @@ class Overlay
     int getMarginBottomRight();
     int getFontsizeBottomRight();
 
-    void setDebugMode(const bool debugModeIn);
-
   private:
     const std::string overlayInput;
     int margin;
     int fontsize;
-    bool debugMode = false;
 
     QString topLeftTemplate;
     QString topRightTemplate;
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index 048c37a..3ad6fc4 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -1,6 +1,7 @@
 #include "pathtraverser.h"
 #include "mainwindow.h"
 #include "appconfig.h"
+#include "logger.h"
 
 #include <QDirIterator>
 #include <QDir>
@@ -11,8 +12,8 @@
 #include <stdlib.h>     /* srand, rand */
 
 
-PathTraverser::PathTraverser(const std::string path, bool debugModeIn):
-  path(path), debugMode(debugModeIn)
+PathTraverser::PathTraverser(const std::string path):
+  path(path)
 {}
 
 PathTraverser::~PathTraverser() {}
@@ -28,11 +29,11 @@ ImageDisplayOptions PathTraverser::LoadOptionsForDirectory(const std::string &di
 {
   Config baseConfig;
   baseConfig.baseDisplayOptions = baseOptions;
-  return getConfigurationForFolder(directoryPath, baseConfig, debugMode).baseDisplayOptions;
+  return getConfigurationForFolder(directoryPath, baseConfig).baseDisplayOptions;
 }
 
-RecursivePathTraverser::RecursivePathTraverser(const std::string path,bool debugMode):
-  PathTraverser(path,debugMode)
+RecursivePathTraverser::RecursivePathTraverser(const std::string path):
+  PathTraverser(path)
 {}
 
 RecursivePathTraverser::~RecursivePathTraverser() {}
@@ -61,8 +62,8 @@ ImageDisplayOptions RecursivePathTraverser::UpdateOptionsForImage(const std::str
   return LoadOptionsForDirectory(d.absolutePath().toStdString(), baseOptions);
 }
 
-DefaultPathTraverser::DefaultPathTraverser(const std::string path,bool debugMode):
-  PathTraverser(path,debugMode),
+DefaultPathTraverser::DefaultPathTraverser(const std::string path):
+  PathTraverser(path),
   directory(path.c_str())
 {}
 
@@ -85,8 +86,8 @@ ImageDisplayOptions DefaultPathTraverser::UpdateOptionsForImage(const std::strin
   return LoadOptionsForDirectory(directory.absolutePath().toStdString(), baseOptions);
 }
 
-ImageListPathTraverser::ImageListPathTraverser(const std::string &imageListString,bool debugMode):
-  PathTraverser("",debugMode)
+ImageListPathTraverser::ImageListPathTraverser(const std::string &imageListString):
+  PathTraverser("")
 {
   QString str = QString(imageListString.c_str());
   imageList = str.split(QLatin1Char(','));
@@ -114,8 +115,8 @@ ImageDisplayOptions ImageListPathTraverser::UpdateOptionsForImage(const std::str
 }
 
 
-RedditRSSFeedPathTraverser::RedditRSSFeedPathTraverser(const std::string& rssFeedURLIn, QNetworkAccessManager& networkManager, bool debugModeIn) :
-  PathTraverser("",debugModeIn), rssFeedURL(rssFeedURLIn), webCtrl(networkManager)
+RedditRSSFeedPathTraverser::RedditRSSFeedPathTraverser(const std::string& rssFeedURLIn, QNetworkAccessManager& networkManager) :
+  PathTraverser(""), rssFeedURL(rssFeedURLIn), webCtrl(networkManager)
 {
   connect( &webCtrl, SIGNAL (finished(QNetworkReply*)), this, SLOT (fileDownloaded(QNetworkReply*)));
   RequestRSSFeed();
@@ -131,10 +132,7 @@ void RedditRSSFeedPathTraverser::RequestRSSFeed()
   {
     pendingReply->abort();
   }
-  if (debugMode)
-  {
-    std::cout << "Requesting RSS feed:" << rssFeedURL << std::endl;
-  }
+  Log("Requesting RSS feed:", rssFeedURL);
   rssRequestedTime = QDateTime::currentDateTime();
   QNetworkRequest request(QUrl(rssFeedURL.c_str()));
   pendingReply = webCtrl.get(request);
@@ -159,10 +157,7 @@ void RedditRSSFeedPathTraverser::fileDownloaded(QNetworkReply* netReply)
   netReply->deleteLater();
   if (!vt.isNull())
   {
-    if (debugMode)
-    {
-      std::cout << "Redirected to:" << vt.toUrl().toString().toStdString() << std::endl;
-    }
+    Log("Redirected to:", vt.toUrl().toString().toStdString());
     webCtrl.get(QNetworkRequest(vt.toUrl()));
   }
   else
@@ -171,10 +166,7 @@ void RedditRSSFeedPathTraverser::fileDownloaded(QNetworkReply* netReply)
     QString error;
     if (!doc.setContent(str, false, &error))
     {
-      if (debugMode)
-      {
-        std::cout << "Failed to load page:" << error.toStdString() << std::endl;
-      }
+      Log("Failed to load page:", error.toStdString());
     }
     else
     {
diff --git a/src/pathtraverser.h b/src/pathtraverser.h
index 9dc6425..ef65ead 100644
--- a/src/pathtraverser.h
+++ b/src/pathtraverser.h
@@ -15,7 +15,7 @@ class MainWindow;
 class PathTraverser
 {
   public:
-    PathTraverser(const std::string path, bool debugModeIn);
+    PathTraverser(const std::string path);
     virtual ~PathTraverser();
     virtual QStringList getImages() const = 0;
     virtual const std::string getImagePath(const std::string image) const = 0;
@@ -23,7 +23,6 @@ class PathTraverser
 
   protected:
     const std::string path;
-    bool debugMode = false;
     QStringList getImageFormats() const;
     ImageDisplayOptions LoadOptionsForDirectory(const std::string &directoryPath, const ImageDisplayOptions &baseOptions) const;
 };
@@ -31,7 +30,7 @@ class PathTraverser
 class RecursivePathTraverser : public PathTraverser
 {
   public:
-    RecursivePathTraverser(const std::string path, bool debugModeIn);
+    RecursivePathTraverser(const std::string path);
     virtual ~RecursivePathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
@@ -41,7 +40,7 @@ class RecursivePathTraverser : public PathTraverser
 class DefaultPathTraverser : public PathTraverser
 {
   public:
-    DefaultPathTraverser(const std::string path, bool debugModeIn);
+    DefaultPathTraverser(const std::string path);
     virtual ~DefaultPathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
@@ -53,7 +52,7 @@ class DefaultPathTraverser : public PathTraverser
 class ImageListPathTraverser : public PathTraverser
 {
   public:
-    ImageListPathTraverser(const std::string &imageListString, bool debugModeIn);
+    ImageListPathTraverser(const std::string &imageListString);
     virtual ~ImageListPathTraverser();
     QStringList getImages() const;
     virtual const std::string getImagePath(const std::string image) const;
@@ -66,7 +65,7 @@ class RedditRSSFeedPathTraverser: public QObject, public PathTraverser
 {
   Q_OBJECT 
  public:
-    RedditRSSFeedPathTraverser(const std::string& rSSFeedURL,QNetworkAccessManager& networkManager, bool debugModeIn);
+    RedditRSSFeedPathTraverser(const std::string& rSSFeedURL,QNetworkAccessManager& networkManager);
     virtual ~RedditRSSFeedPathTraverser();
 
     virtual QStringList getImages() const;
diff --git a/src/slide.pro b/src/slide.pro
index db060ef..de08fca 100644
--- a/src/slide.pro
+++ b/src/slide.pro
@@ -5,7 +5,9 @@
 #-------------------------------------------------
 
 QT       += core gui network xml
-CONFIG += qt debug
+CONFIG += qt 
+CONFIG += debug
+CONFIG += c++1z
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
@@ -35,7 +37,8 @@ SOURCES += \
         pathtraverser.cpp \
         overlay.cpp \
         imageselector.cpp \
-        appconfig.cpp
+        appconfig.cpp \
+        logger.cpp
 
 HEADERS += \
         mainwindow.h \
@@ -44,7 +47,8 @@ HEADERS += \
         overlay.h \
         imageswitcher.h \
         imagestructs.h \
-        appconfig.h
+        appconfig.h \
+        logger.h
 
 FORMS += \
         mainwindow.ui

From 1211a93b64a014a2a32e58de2d1101edaa24c4ff Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Fri, 27 Aug 2021 13:41:26 +1200
Subject: [PATCH 21/30] - Add documentation for the scheduler json config file
 key

---
 README.md | 47 +++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 43 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 84d5602..32ed439 100644
--- a/README.md
+++ b/README.md
@@ -66,11 +66,45 @@ The file format is:
    "stretch": false,
    "rotationSeconds" : 300,
    "opacity" : 200,
-   "debug" : false
+   "debug" : false,
+   "scheduler" : [
+      {
+         "exclusive" : true,
+         "redditrss" : "https://www.reddit.com/r/earthporn/.rss?limit=100",
+         "stretch" : true,
+         "times": [
+            {
+                "start": "14:00",
+                "end": "16:00"
+            }
+         ]
+      },
+      { 
+         "exclusive" : true,
+         "stretch" : false,
+         "times": [
+            {
+                "start": "08:00",
+                "end": "10:00"
+            },
+            {
+                "start": "16:00",
+                "end": "19:00"
+            }
+         ],
+         "path" : "/path/to/pictures/show_peak_times/"
+      },
+      {
+               "path" : "/path/to/pictures/always_show_1"
+      },
+      {
+               "path" : "/path/to/pictures/always_show_2"
+      }
+
 }
 ```
 Supported keys and values in the JSON configuration are:
-* `path` : where to search for images (.jpg files)
+* `path` : where to search for images (.jpg files). This path is ignored if the `scheduler` feature is used.
 * `aspect` : the same as the command line argument
 * `overlay` : the same as the overlay command line argument
 * `shuffle` : set to true to enable shuffle mode for file display
@@ -81,6 +115,12 @@ Supported keys and values in the JSON configuration are:
 * `opacity` : the same as the command line `-o` argument
 * `blur` : the same as the command line `-b` argument
 * `debug` : set to true to enable verbose output from the program
+* `scheduler` : this entry is an array of possible path values and associated settings. This key lets you manage display times/settings for a collection of paths. In the example above the top entry shows ONLY files from a Redit RSS feed between 2 and 4pm, ONLY files from the `show_peak_times` folder from 8am to 10am and then 4pm to 7pm. At all other times it alternates displaying files in the `always_show_1` and `always_show_2` folder.
+   * `exclusive` : When set to `true` only this entry will be used when it is in its valid time window. 
+   * `times` : times is a JSON array of start and end times in which it is valid to display this image. The time is in the format HH:MM:SS and is based on the systems local time. If `start` isn't defined then it defaults to the start of the day, if `end` isn't defined it defaults to the end of the day.
+   * `path` : the path to image files
+   * `stretch` : as above
+   * `redditrss` : the path to a ReditRSS feed from which images will be selected. This is designed for the EarthPorn page and others like it and is highly dependent on the Redit RSS syntax.
 
 ## Folder Options file
 When using the default or recursive folder mode we support having per folder display options. The options are stored in a file called "options.json" in the images folder and support a subset of the applications configuration settings:
@@ -88,7 +128,6 @@ When using the default or recursive folder mode we support having per folder dis
 {
    "stretch": false,
    "aspect" : "m",
-   "rotationSeconds" : 300,
    "opacity" : 200,
    "blur" : 20,
    "times": [
@@ -104,7 +143,7 @@ When using the default or recursive folder mode we support having per folder dis
 }
 ```
 See the `Configuration File` section for details of each setting.
-* `times` : times is a JSON array of start and end times in which it is valid to display this image. The time is in the format HH:MM:SS and is based on the systems local time. If `start` isn't defined then it defaults to the start of the day, if `end` isn't default it defaults to the end of the day.
+
 
 ## Dependencies
 

From 0c9721976b890a51aedb57b8fb03a9821d598192 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Fri, 27 Aug 2021 15:30:45 +1200
Subject: [PATCH 22/30] - remove the reddit rss support. This is better done by
 a 3rd party downloader to disk (i.e
 https://github.com/Pomax/reddit-image-catch-up)

---
 README.md             |   5 +-
 src/appconfig.cpp     |   9 ----
 src/appconfig.h       |   3 +-
 src/imageselector.cpp |   3 --
 src/main.cpp          |   6 +--
 src/pathtraverser.cpp | 117 ------------------------------------------
 src/pathtraverser.h   |  23 ---------
 7 files changed, 4 insertions(+), 162 deletions(-)

diff --git a/README.md b/README.md
index 32ed439..18521a5 100644
--- a/README.md
+++ b/README.md
@@ -70,7 +70,7 @@ The file format is:
    "scheduler" : [
       {
          "exclusive" : true,
-         "redditrss" : "https://www.reddit.com/r/earthporn/.rss?limit=100",
+         "path" : "/path/to/pictures/reddit_sync"
          "stretch" : true,
          "times": [
             {
@@ -115,12 +115,11 @@ Supported keys and values in the JSON configuration are:
 * `opacity` : the same as the command line `-o` argument
 * `blur` : the same as the command line `-b` argument
 * `debug` : set to true to enable verbose output from the program
-* `scheduler` : this entry is an array of possible path values and associated settings. This key lets you manage display times/settings for a collection of paths. In the example above the top entry shows ONLY files from a Redit RSS feed between 2 and 4pm, ONLY files from the `show_peak_times` folder from 8am to 10am and then 4pm to 7pm. At all other times it alternates displaying files in the `always_show_1` and `always_show_2` folder.
+* `scheduler` : this entry is an array of possible path values and associated settings. This key lets you manage display times/settings for a collection of paths. In the example above the top entry shows ONLY files from a Redit feed between 2 and 4pm, ONLY files from the `show_peak_times` folder from 8am to 10am and then 4pm to 7pm. At all other times it alternates displaying files in the `always_show_1` and `always_show_2` folder.
    * `exclusive` : When set to `true` only this entry will be used when it is in its valid time window. 
    * `times` : times is a JSON array of start and end times in which it is valid to display this image. The time is in the format HH:MM:SS and is based on the systems local time. If `start` isn't defined then it defaults to the start of the day, if `end` isn't defined it defaults to the end of the day.
    * `path` : the path to image files
    * `stretch` : as above
-   * `redditrss` : the path to a ReditRSS feed from which images will be selected. This is designed for the EarthPorn page and others like it and is highly dependent on the Redit RSS syntax.
 
 ## Folder Options file
 When using the default or recursive folder mode we support having per folder display options. The options are stored in a file called "options.json" in the images folder and support a subset of the applications configuration settings:
diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index b424fee..f495870 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -178,10 +178,6 @@ QVector<PathEntry> parsePathEntry(QJsonObject &jsonMainDoc, bool baseRecursive,
       if(!imageListString.empty()) {
         entry.imageList = imageListString;
       }
-      std::string rssFeedURLString = ParseJSONString(schedulerJson, "redditrss");
-      if(!rssFeedURLString.empty()) {
-        entry.rssFeedURL = rssFeedURLString;
-      }
 
       SetJSONBool(entry.exclusive, schedulerJson, "exclusive");
 
@@ -260,11 +256,6 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
     {
       entry.imageList = imageListString;
     }
-    std::string rssFeedURLString = ParseJSONString(jsonDoc, "redditrss");
-    if(!rssFeedURLString.empty())
-    {
-      entry.rssFeedURL = rssFeedURLString;
-    }
     loadedConfig.paths.append(entry);
   }
   loadedConfig.configPath = commandLineConfig.configPath;
diff --git a/src/appconfig.h b/src/appconfig.h
index c8e7d8e..c219434 100644
--- a/src/appconfig.h
+++ b/src/appconfig.h
@@ -18,7 +18,6 @@ struct Config {
 struct PathEntry {
   std::string path = "";
   std::string imageList = "";
-  std::string rssFeedURL = "";
   bool exclusive = false; // only use this entry when it is valid, skip others
 
   bool recursive = false;
@@ -38,7 +37,7 @@ struct PathEntry {
       return true;
     if(b.baseDisplayOptions.fitAspectAxisToWindow != baseDisplayOptions.fitAspectAxisToWindow)
       return true;
-    if (b.path != path || b.imageList != imageList || b.rssFeedURL != rssFeedURL)
+    if (b.path != path || b.imageList != imageList)
       return true;
     if (b.baseDisplayOptions.timeWindows.count() != baseDisplayOptions.timeWindows.count())
       return true;
diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index a4561b6..0613470 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -142,9 +142,6 @@ bool ImageSelector::imageInsideTimeWindow(const QVector<DisplayTimeWindow> &time
 
 bool ImageSelector::imageMatchesFilter(const ImageDetails& imageDetails)
 {
-  if(imageDetails.filename.find("https://") != std::string::npos)
-    return imageInsideTimeWindow(imageDetails.options.timeWindows);
-
   if(!QFileInfo::exists(QString(imageDetails.filename.c_str())))
   {
     Log("file not found: ", imageDetails.filename);
diff --git a/src/main.cpp b/src/main.cpp
index 3c55790..e3cac1f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -131,11 +131,7 @@ void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
 std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, QNetworkAccessManager& networkManagerIn)
 {
   std::unique_ptr<PathTraverser> pathTraverser;
-  if (!path.rssFeedURL.empty())
-  {
-    pathTraverser = std::unique_ptr<PathTraverser>(new RedditRSSFeedPathTraverser(path.rssFeedURL, networkManagerIn));
-  }
-  else if (!path.imageList.empty())
+  if (!path.imageList.empty())
   {
     pathTraverser = std::unique_ptr<PathTraverser>(new ImageListPathTraverser(path.imageList));
   }
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index 3ad6fc4..1be7974 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -114,120 +114,3 @@ ImageDisplayOptions ImageListPathTraverser::UpdateOptionsForImage(const std::str
   return baseOptions;
 }
 
-
-RedditRSSFeedPathTraverser::RedditRSSFeedPathTraverser(const std::string& rssFeedURLIn, QNetworkAccessManager& networkManager) :
-  PathTraverser(""), rssFeedURL(rssFeedURLIn), webCtrl(networkManager)
-{
-  connect( &webCtrl, SIGNAL (finished(QNetworkReply*)), this, SLOT (fileDownloaded(QNetworkReply*)));
-  RequestRSSFeed();
-}
-
-RedditRSSFeedPathTraverser::~RedditRSSFeedPathTraverser()
-{
-}
-
-void RedditRSSFeedPathTraverser::RequestRSSFeed()
-{
-  if (pendingReply)
-  {
-    pendingReply->abort();
-  }
-  Log("Requesting RSS feed:", rssFeedURL);
-  rssRequestedTime = QDateTime::currentDateTime();
-  QNetworkRequest request(QUrl(rssFeedURL.c_str()));
-  pendingReply = webCtrl.get(request);
-}
-
-void RedditRSSFeedPathTraverser::fileDownloaded(QNetworkReply* netReply) 
-{
-  if (netReply != pendingReply)
-    return;
-
-  pendingReply = nullptr;
-
-  QNetworkReply::NetworkError err = netReply->error();
-  if (err != QNetworkReply::NoError)
-  {
-    std::cout << "Failed to load Reddit RSS URL: " << err << std::endl;
-    return;
-  }
-
-  QString str (netReply->readAll());
-  QVariant vt = netReply->attribute(QNetworkRequest::RedirectionTargetAttribute);
-  netReply->deleteLater();
-  if (!vt.isNull())
-  {
-    Log("Redirected to:", vt.toUrl().toString().toStdString());
-    webCtrl.get(QNetworkRequest(vt.toUrl()));
-  }
-  else
-  {
-    QDomDocument doc;
-    QString error;
-    if (!doc.setContent(str, false, &error))
-    {
-      Log("Failed to load page:", error.toStdString());
-    }
-    else
-    {
-      QDomElement docElem = doc.documentElement();
-      QDomNodeList nodeList = docElem.elementsByTagName("entry"); 
-      for (int iEntry = 0; iEntry < nodeList.length(); ++iEntry)
-      {
-        QDomNode node = nodeList.item(iEntry);
-        QDomElement e = node.toElement();
-        QDomNode contentNode =  e.elementsByTagName("content").item(0).firstChild();
-        QDomDocument docContent;
-        if (!docContent.setContent(contentNode.nodeValue(), false, &error))
-        {
-          continue;
-        }
-
-        QDomNodeList addressEntries = docContent.documentElement().elementsByTagName("a");
-        for (int iAddr = 0; iAddr < addressEntries.length(); ++iAddr)
-        {
-          QDomNode node = addressEntries.item(iAddr);
-          /*QString output;
-          QTextStream stream(&output);
-          node.save(stream, 0);
-          qDebug() << "nodeValue: " << output;*/
-          if (node.toElement().text() == "[link]" && node.hasAttributes() )
-          {
-            QDomAttr a = node.toElement().attributeNode("href");
-            // check if the URL matches one of our supported formats
-            for ( const QString& format : supportedFormats ) 
-            {
-              if (a.value().endsWith(format))
-              {
-                imageURLS.append(a.value());
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-
-QStringList RedditRSSFeedPathTraverser::getImages() const
-{
-  // refresh the feed after 5 hours
-  if (rssRequestedTime.secsTo(QDateTime::currentDateTime()) > 60*60*5 )
-  {
-    const_cast<RedditRSSFeedPathTraverser *>(this)->RequestRSSFeed(); 
-  }
-  return imageURLS;
-}
-
-const std::string RedditRSSFeedPathTraverser::getImagePath(const std::string image) const
-{
-  return image;
-}
-
-ImageDisplayOptions RedditRSSFeedPathTraverser::UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const
-{
-  // no per file options modification supported
-  Q_UNUSED(filename);
-  return baseOptions;
-}
diff --git a/src/pathtraverser.h b/src/pathtraverser.h
index ef65ead..c018081 100644
--- a/src/pathtraverser.h
+++ b/src/pathtraverser.h
@@ -60,27 +60,4 @@ class ImageListPathTraverser : public PathTraverser
   private:
     QStringList imageList;
 };
-
-class RedditRSSFeedPathTraverser: public QObject, public PathTraverser
-{
-  Q_OBJECT 
- public:
-    RedditRSSFeedPathTraverser(const std::string& rSSFeedURL,QNetworkAccessManager& networkManager);
-    virtual ~RedditRSSFeedPathTraverser();
-
-    virtual QStringList getImages() const;
-    virtual const std::string getImagePath(const std::string image) const;
-    virtual ImageDisplayOptions UpdateOptionsForImage(const std::string& filename, const ImageDisplayOptions& baseOptions) const;
-
-  private slots:
-    void fileDownloaded(QNetworkReply* pReply);
-  private:
-    void RequestRSSFeed();
-    std::string rssFeedURL;
-    QStringList imageURLS;
-    QNetworkAccessManager& webCtrl; 
-    QNetworkReply *pendingReply = nullptr;
-    QDateTime rssRequestedTime;
-};
-
 #endif // PATHTRAVERSER_H

From f8a8c3fab93683c46217693717aaf894e97312a3 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sat, 4 Sep 2021 08:12:05 +1200
Subject: [PATCH 23/30] - simplfy the logic in ReadExifTag

---
 src/imageselector.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 961c1e6..dc0fadd 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -34,12 +34,10 @@ int ReadExifTag(ExifData* exifData, ExifTag tag, bool shortRead = false)
   {
     if (shortRead)
     {
-      value = exif_get_short(exifEntry->data, byteOrder);
-    }
-    else
-    {
-      value = exif_get_long(exifEntry->data, byteOrder);
+      return exif_get_short(exifEntry->data, byteOrder);
     }
+    
+    return exif_get_long(exifEntry->data, byteOrder);
   }
   return value;
 }

From ff79599a19fcfb844538db338c6f931f0939fc69 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sat, 4 Sep 2021 08:20:15 +1200
Subject: [PATCH 24/30] - remove some more networkmanager code we don't need

---
 src/main.cpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index e3cac1f..ef118d4 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -128,7 +128,7 @@ void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
   w.setBaseOptions(appConfig.baseDisplayOptions);
 }
 
-std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, QNetworkAccessManager& networkManagerIn)
+std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path)
 {
   std::unique_ptr<PathTraverser> pathTraverser;
   if (!path.imageList.empty())
@@ -161,18 +161,18 @@ std::unique_ptr<ImageSelector> GetSelectorForConfig(const PathEntry& path, QNetw
   return selector;
 }
 
-std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig, QNetworkAccessManager& networkManagerIn)
+std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig)
 {
   if(appConfig.paths.count()==1)
   {
-    return GetSelectorForConfig(appConfig.paths[0], networkManagerIn);
+    return GetSelectorForConfig(appConfig.paths[0]);
   }
   else
   {
     std::unique_ptr<ListImageSelector> listSelector(new ListImageSelector());
     for(const auto &path : appConfig.paths)
     {
-      auto selector = GetSelectorForConfig(path, networkManagerIn);
+      auto selector = GetSelectorForConfig(path);
       listSelector->AddImageSelector(selector, path.exclusive, path.baseDisplayOptions);
     }
     // new things
@@ -181,7 +181,7 @@ std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig, QNe
 }
 
 
-void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher, QNetworkAccessManager& networkManager)
+void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher)
 {  
   QString jsonFile = getAppConfigFilePath(appConfig.configPath);
   QDir directory;
@@ -198,7 +198,7 @@ void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *sw
     ConfigureWindowFromSettings(w, appConfig);
     if(appConfig.PathOptionsChanged(oldConfig))
     {
-      std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig, networkManager);
+      std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
       switcher->setImageSelector(selector);
     }
 
@@ -236,11 +236,11 @@ int main(int argc, char *argv[])
   w.setNetworkManager(&webCtrl);
   w.show();
 
-  std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig, webCtrl);
+  std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
   
   ImageSwitcher switcher(w, appConfig.rotationSeconds * 1000, selector);
   w.setImageSwitcher(&switcher);
-  std::function<void(MainWindow &w, ImageSwitcher *switcher)> reloader = [&appConfig, &webCtrl](MainWindow &w, ImageSwitcher *switcher) { ReloadConfigIfNeeded(appConfig, w, switcher, webCtrl); };
+  std::function<void(MainWindow &w, ImageSwitcher *switcher)> reloader = [&appConfig](MainWindow &w, ImageSwitcher *switcher) { ReloadConfigIfNeeded(appConfig, w, switcher); };
   switcher.setConfigFileReloader(reloader);
   switcher.start();
   return a.exec();

From 7fef2e5a68721cf5f6ac8c106c4629bb469e2a0c Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Wed, 8 Sep 2021 11:23:39 +1200
Subject: [PATCH 25/30] - Move new overlay color string into appconfig struct

---
 src/appconfig.cpp | 11 ++++++++++-
 src/appconfig.h   |  1 +
 src/main.cpp      | 12 +++++-------
 3 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index f495870..724700a 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -117,6 +117,15 @@ Config loadConfiguration(const std::string &configFilePath, const Config &curren
 }
 
 
+AppConfig loadConfiguration(const std::string &configFilePath, const AppConfig &currentConfig) {
+  AppConfig userConfig = currentConfig;
+  // make sure to only update the base members, preserve the ones from the copy above
+  (Config &)userConfig = loadConfiguration(configFilePath, (const Config &)userConfig);
+
+  return userConfig;
+}
+
+
 QString getAppConfigFilePath(const std::string &configPath) {
   std::string userConfigFolder = "~/.config/slide/";
   std::string systemConfigFolder = "/etc/slide";
@@ -217,7 +226,7 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
   }
 
   AppConfig loadedConfig = loadConfiguration(jsonFile.toStdString(), commandLineConfig);
-  
+
   QString val;
   QFile file;
   file.setFileName(jsonFile);
diff --git a/src/appconfig.h b/src/appconfig.h
index c219434..fce2c20 100644
--- a/src/appconfig.h
+++ b/src/appconfig.h
@@ -56,6 +56,7 @@ struct AppConfig : public Config {
     AppConfig( const Config &inConfig ) : Config(inConfig) {}
     std::string configPath = "";
     std::string overlay = "";
+    QString overlayHexRGB = "#FFFFFF";
     QVector<PathEntry> paths;
 
     bool debugMode = false;
diff --git a/src/main.cpp b/src/main.cpp
index afe5968..2b54d1b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -23,9 +23,6 @@ void usage(std::string programName) {
     std::cerr << "Usage: " << programName << " [-t rotation_seconds] [-a aspect('l','p','a', 'm')] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-s] [-v] [--verbose] [--stretch] [-c config_file_path]" << std::endl;
 }
 
-QString overlayHexRGB = QString("#FFFFFF");
-QRegularExpression hexRGBMatcher("^#([0-9A-Fa-f]{3}){1,2}$");
-
 bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
   int opt;
   int debugInt = 0;
@@ -90,7 +87,7 @@ bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
         appConfig.overlay = optarg;
         break;
       case 'h':
-        overlayHexRGB = QString::fromStdString(optarg);
+        appConfig.overlayHexRGB = QString::fromStdString(optarg);
         break;
       case 'v':
         appConfig.debugMode = true;
@@ -132,15 +129,16 @@ void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
       w.setBackgroundOpacity(appConfig.backgroundOpacity);
   }
 
-  if (!overlayHexRGB.isEmpty())
+  if (!appConfig.overlayHexRGB.isEmpty())
   {
-    if(!hexRGBMatcher.match(overlayHexRGB).hasMatch())
+    QRegularExpression hexRGBMatcher("^#([0-9A-Fa-f]{3}){1,2}$");
+    if(!hexRGBMatcher.match(appConfig.overlayHexRGB).hasMatch())
     {
       std::cout << "Error: hex rgb string expected. e.g. #FFFFFF or #FFF" << std::endl;
     }
     else
     {
-      w.setOverlayHexRGB(overlayHexRGB);
+      w.setOverlayHexRGB(appConfig.overlayHexRGB);
     }
   }
 

From 8bb97ed926e4bd267bdcf94809a06eb57c10a139 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Wed, 8 Sep 2021 11:56:47 +1200
Subject: [PATCH 26/30] - Split ImageAspect into 2 types, ImageAspect for
 images and ImageAspectScreenFilter for screens - Change ImageDetails into a
 class and add some accessors for the filtering logic for screen aspect and
 image aspect

---
 src/appconfig.cpp     | 10 ++++----
 src/appconfig.h       |  2 +-
 src/imageselector.cpp | 10 +-------
 src/imagestructs.cpp  | 54 +++++++++++++++++++++++++++++++++++++++++++
 src/imagestructs.h    | 15 ++++++++----
 src/main.cpp          |  2 +-
 src/mainwindow.cpp    | 18 ++++-----------
 src/slide.pro         |  1 +
 8 files changed, 79 insertions(+), 33 deletions(-)
 create mode 100644 src/imagestructs.cpp

diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index 724700a..a9fb920 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -14,21 +14,21 @@
 
 const std::string AppConfig::valid_aspects = "alpm"; // all, landscape, portait, monitor
 
-ImageAspect parseAspectFromString(char aspect) {
+ImageAspectScreenFilter parseAspectFromString(char aspect) {
   switch(aspect)
   {
     case 'l':
-      return ImageAspect_Landscape;
+      return ImageAspectScreenFilter_Landscape;
       break;
     case 'p':
-      return ImageAspect_Portrait;
+      return ImageAspectScreenFilter_Portrait;
       break;
     case 'm':
-      return ImageAspect_Monitor;
+      return ImageAspectScreenFilter_Monitor;
       break;
     default:
     case 'a':
-      return ImageAspect_Any;
+      return ImageAspectScreenFilter_Any;
       break;
   }
 }
diff --git a/src/appconfig.h b/src/appconfig.h
index fce2c20..c5b3df1 100644
--- a/src/appconfig.h
+++ b/src/appconfig.h
@@ -79,7 +79,7 @@ struct AppConfig : public Config {
 AppConfig loadAppConfiguration(const AppConfig &commandLineConfig);
 Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig);
 
-ImageAspect parseAspectFromString(char aspect);
+ImageAspectScreenFilter parseAspectFromString(char aspect);
 QString getAppConfigFilePath(const std::string &configPath);
 
 #endif
\ No newline at end of file
diff --git a/src/imageselector.cpp b/src/imageselector.cpp
index 469058f..13afb5f 100644
--- a/src/imageselector.cpp
+++ b/src/imageselector.cpp
@@ -100,13 +100,6 @@ ImageDetails ImageSelector::populateImageDetails(const std::string&fileName, con
   imageDetails.width = imageWidth;
   imageDetails.height = imageHeight;
   imageDetails.rotation = degrees;
-  if (imageWidth > imageHeight) {
-    imageDetails.aspect = ImageAspect_Landscape;
-  } else if (imageHeight > imageWidth) {
-    imageDetails.aspect = ImageAspect_Portrait;
-  } else {
-    imageDetails.aspect = ImageAspect_Any;
-  }
 
   imageDetails.options = pathTraverser->UpdateOptionsForImage(imageDetails.filename, baseOptions);
   
@@ -161,8 +154,7 @@ bool ImageSelector::imageMatchesFilter(const ImageDetails& imageDetails)
 
 bool ImageSelector::imageValidForAspect(const ImageDetails& imageDetails)
 {
-  if (imageDetails.options.onlyAspect == ImageAspect_Any ||
-      imageDetails.aspect == imageDetails.options.onlyAspect)
+  if (imageDetails.isValidForScreenAspect(imageDetails.options.onlyAspect))
   {
     return true;
   }
diff --git a/src/imagestructs.cpp b/src/imagestructs.cpp
new file mode 100644
index 0000000..948f44b
--- /dev/null
+++ b/src/imagestructs.cpp
@@ -0,0 +1,54 @@
+
+#include "imagestructs.h"
+#include "logger.h"
+
+ImageDetails::ImageDetails()
+{
+
+}
+
+ImageDetails::~ImageDetails()
+{
+
+}
+
+ImageAspect ImageDetails::aspect() const
+{
+  if (width > height) 
+  {
+    return ImageAspect_Landscape;
+  } 
+  else if (height > width) 
+  {
+    return ImageAspect_Portrait;
+  }
+
+  // must be square, so just pick something
+  return ImageAspect_Portrait;
+}
+
+
+bool ImageDetails::isValidForScreenAspect(const ImageAspectScreenFilter aspectScreen) const
+{
+  if(aspectScreen == ImageAspectScreenFilter_Any) 
+  {
+    return true;
+  }
+  if(aspectScreen == ImageAspectScreenFilter_Monitor) 
+  {
+    Log("Error: invalid aspect of ImageAspectScreenFilter_Monitor" );
+    return false;
+  }
+
+  if (width > height) 
+  {
+    return aspectScreen == ImageAspectScreenFilter_Landscape;
+  } 
+  else if (height > width) 
+  {
+    return aspectScreen == ImageAspectScreenFilter_Portrait;
+  } 
+
+  // must be square so let is always display
+  return true;
+}
diff --git a/src/imagestructs.h b/src/imagestructs.h
index b7042ba..0ccf3c7 100644
--- a/src/imagestructs.h
+++ b/src/imagestructs.h
@@ -6,7 +6,8 @@
 #include <string>
 
 // possible aspect ratios of an image
-enum ImageAspect { ImageAspect_Landscape = 0, ImageAspect_Portrait, ImageAspect_Any, ImageAspect_Monitor /* match monitors aspect */ };
+enum ImageAspect { ImageAspect_Landscape = 0, ImageAspect_Portrait};
+enum ImageAspectScreenFilter { ImageAspectScreenFilter_Landscape = 0, ImageAspectScreenFilter_Portrait, ImageAspectScreenFilter_Any, ImageAspectScreenFilter_Monitor /* match monitors aspect */ };
 
 struct DisplayTimeWindow
 {
@@ -22,18 +23,24 @@ struct DisplayTimeWindow
 // options to consider when displaying an image
 struct ImageDisplayOptions
 {
-    ImageAspect onlyAspect = ImageAspect_Any;
+    ImageAspectScreenFilter onlyAspect = ImageAspectScreenFilter_Any;
     bool fitAspectAxisToWindow = false;
     QVector<DisplayTimeWindow> timeWindows;
 };
 
 // details of a particular image
-struct ImageDetails
+class ImageDetails
 {
+public:
+    ImageDetails();
+    ~ImageDetails();
+    bool isValidForScreenAspect(const ImageAspectScreenFilter aspectDisplay) const;
+    ImageAspect aspect() const;
+
+public:
     int width = 0;
     int height = 0;
     int rotation = 0;
-    ImageAspect aspect = ImageAspect_Any;
     std::string filename;
     ImageDisplayOptions options;
 };
diff --git a/src/main.cpp b/src/main.cpp
index 2b54d1b..3dd747a 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -51,7 +51,7 @@ bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
         if (appConfig.valid_aspects.find(optarg[0]) == std::string::npos)
         {
           std::cout << "Invalid Aspect option, defaulting to all" << std::endl;
-          appConfig.baseDisplayOptions.onlyAspect = ImageAspect_Any;
+          appConfig.baseDisplayOptions.onlyAspect = ImageAspectScreenFilter_Any;
         }
         else
         {
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index e942443..717c133 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -139,7 +139,7 @@ void MainWindow::checkWindowSize()
     if (imageAspectMatchesMonitor)
     {
       bool isLandscape = screenSize.width() > screenSize.height();
-      ImageAspect newAspect = isLandscape ? ImageAspect_Landscape : ImageAspect_Portrait;
+      ImageAspectScreenFilter newAspect = isLandscape ? ImageAspectScreenFilter_Landscape : ImageAspectScreenFilter_Portrait;
       if (newAspect != baseImageOptions.onlyAspect)
       {
         Log("Changing image orientation to ", newAspect);
@@ -218,14 +218,6 @@ void MainWindow::updateImage(bool immediately)
       currentImage.width = p.width();
       currentImage.height = p.height();
       currentImage.rotation = 0;
-      if (currentImage.width > currentImage.height) {
-        currentImage.aspect = ImageAspect_Landscape;
-      } else if (currentImage.height > currentImage.width) {
-        currentImage.aspect = ImageAspect_Portrait;
-      } else {
-        currentImage.aspect = ImageAspect_Any;
-      }
-
     }
     else
     {
@@ -331,13 +323,13 @@ QPixmap MainWindow::getScaledPixmap(const QPixmap& p)
 {
   if (currentImage.options.fitAspectAxisToWindow)
   {
-    if (currentImage.aspect == ImageAspect_Portrait)
+    if (currentImage.aspect() == ImageAspect_Portrait)
     {
       // potrait mode, make height of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToHeight(height(), Qt::SmoothTransformation);
       return pTemp.copy(0,0,width(),height());
     }
-    else if (currentImage.aspect == ImageAspect_Landscape)
+    else if (currentImage.aspect() == ImageAspect_Landscape)
     {
       // landscape mode, make width of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToWidth(width(), Qt::SmoothTransformation);
@@ -410,10 +402,10 @@ void MainWindow::warn(std::string text)
 void MainWindow::setBaseOptions(const ImageDisplayOptions &baseOptionsIn) 
 { 
   baseImageOptions = baseOptionsIn; 
-  if(baseImageOptions.onlyAspect == ImageAspect_Monitor)
+  if(baseImageOptions.onlyAspect == ImageAspectScreenFilter_Monitor)
   {
     imageAspectMatchesMonitor = true;
-    baseImageOptions.onlyAspect = width() >= height() ? ImageAspect_Landscape : ImageAspect_Portrait;
+    baseImageOptions.onlyAspect = width() >= height() ? ImageAspectScreenFilter_Landscape : ImageAspectScreenFilter_Portrait;
   }
 }
 
diff --git a/src/slide.pro b/src/slide.pro
index de08fca..04cc324 100644
--- a/src/slide.pro
+++ b/src/slide.pro
@@ -38,6 +38,7 @@ SOURCES += \
         overlay.cpp \
         imageselector.cpp \
         appconfig.cpp \
+        imagestructs.cpp \
         logger.cpp
 
 HEADERS += \

From b45e7dbda9cd89f41ec2eab3373bb763c172be95 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Thu, 9 Sep 2021 08:56:03 +1200
Subject: [PATCH 27/30] - merge from main

---
 README.md          |  5 ++++-
 src/appconfig.h    |  1 +
 src/main.cpp       |  9 +++++++--
 src/mainwindow.cpp | 24 +++++++++++++++---------
 src/mainwindow.h   |  4 +++-
 5 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 18521a5..d487fb6 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ This project is maintained by myself during my spare time. If you like and use i
 ## Usage
 
 ```
-slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur_radius] [-p image_folder|-i imageFile,...] [-r] [-O overlay_string] [-v] [--verbose] [--stretch] [-c path_to_config_json]
+slide [-t rotation_seconds] [-T transition_seconds] [-h/--overlay-color overlay_color(#rrggbb)] [-a aspect] [-o background_opacity(0..255)] [-b blur_radius] [-p image_folder|-i imageFile,...] [-r] [-O overlay_string] [-v] [--verbose] [--stretch] [-c path_to_config_json]
 ```
 
 * `image_folder`: where to search for images (.jpg files)
@@ -30,10 +30,13 @@ slide [-t rotation_seconds] [-a aspect] [-o background_opacity(0..255)] [-b blur
 * `-S` for sorted rotation (files ordered by name, first images then subfolders)
 * `rotation_seconds(default=30)`: time until next random image is chosen from the given folder
 * `aspect(default=a)`: the required aspect ratio of the picture to display. Valid values are 'a' (all), 'l' (landscape), 'p' (portrait) and 'm' (monitor). Monitor will match the aspect ratio of the display we are running on.
+* `transition_seconds(default=1)`: time of image transition animation. Default is 1 second, and transition animation will be disabled if the value is set to 0
+* `aspect(default=a)`: the required aspect ratio of the picture to display. Valid values are 'a' (all), 'l' (landscape) and 'p' (portrait)
 * `background_opacity(default=150)`: opacity of the background filling image between 0 (black background) and 255
 * `blur_radius(default=20)`: blur radius of the background filling image
 * `-v` or `--verbose`: Verbose debug output when running, plus a thumbnail of the original image in the bottom left of the screen
 * `--stretch`: When in aspect mode 'l','p' or 'm' crop the image rather than leaving a blurred background. For example, in landscape mode this will make images as wide as the screen and crop the top and bottom to fit.
+* `-h` or `--overlay-color` the color of the overlay text, in the form of 3 or 6 digits hex rgb string prefixed by `#`, for example `#00FF00` or `#0F0` for color 🟢
 * `-O` is used to create a overlay string.
   * It defines overlays for all four edges in the order `top-left;top-right;bottom-left;bottom-right`
   * All edges overlays are separated by `;`
diff --git a/src/appconfig.h b/src/appconfig.h
index c5b3df1..64b22e2 100644
--- a/src/appconfig.h
+++ b/src/appconfig.h
@@ -9,6 +9,7 @@
 struct Config {
   public:
     unsigned int rotationSeconds = 30;
+    unsigned int transitionTime = 1;
     int blurRadius = -1;
     int backgroundOpacity = -1;
     ImageDisplayOptions baseDisplayOptions;
diff --git a/src/main.cpp b/src/main.cpp
index 3dd747a..4a3b42d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -20,7 +20,7 @@
 #include <memory>
 
 void usage(std::string programName) {
-    std::cerr << "Usage: " << programName << " [-t rotation_seconds] [-a aspect('l','p','a', 'm')] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-s] [-v] [--verbose] [--stretch] [-c config_file_path]" << std::endl;
+    std::cerr << "Usage: " << programName << " [-t rotation_seconds] [-T transition_seconds] [-h/--overlay-color #rrggbb] [-a aspect('l','p','a', 'm')] [-o background_opacity(0..255)] [-b blur_radius] -p image_folder [-r] [-s] [-S] [-v] [--verbose] [--stretch] [-c config_file_path]" << std::endl;
 }
 
 bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
@@ -34,7 +34,7 @@ bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
     {"overlay-color", required_argument, 0,           'h'},
   };
   int option_index = 0;
-  while ((opt = getopt_long(argc, argv, "b:p:t:o:O:a:i:c:h:rsSv", long_options, &option_index)) != -1) {
+  while ((opt = getopt_long(argc, argv, "b:p:t:T:o:O:a:i:c:h:rsSv", long_options, &option_index)) != -1) {
     switch (opt) {
       case 0:
           /* If this option set a flag, do nothing else now. */
@@ -61,6 +61,9 @@ bool parseCommandLine(AppConfig &appConfig, int argc, char *argv[]) {
       case 't':
         appConfig.rotationSeconds = atoi(optarg);
         break;
+      case 'T':
+	      appConfig.transitionTime =atoi(optarg);
+        break;
       case 'b':
         appConfig.blurRadius = atoi(optarg);
         break;
@@ -129,6 +132,8 @@ void ConfigureWindowFromSettings(MainWindow &w, const AppConfig &appConfig)
       w.setBackgroundOpacity(appConfig.backgroundOpacity);
   }
 
+  w.setTransitionTime(appConfig.transitionTime);
+
   if (!appConfig.overlayHexRGB.isEmpty())
   {
     QRegularExpression hexRGBMatcher("^#([0-9A-Fa-f]{3}){1,2}$");
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 717c133..5c3ffcd 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -119,8 +119,9 @@ bool MainWindow::event(QEvent* event)
 
 void MainWindow::resizeEvent(QResizeEvent* event)
 {
-  QMainWindow::resizeEvent(event);
-  updateImage(true);
+   QMainWindow::resizeEvent(event);
+   this->findChild<QLabel*>("image")->clear();
+   updateImage();
 }
 
 void MainWindow::checkWindowSize()
@@ -133,7 +134,7 @@ void MainWindow::checkWindowSize()
     {
       Log("Resizing Window", screenSize.width(), "," , screenSize.height() );
       setFixedSize(screenSize);
-      updateImage(true);
+      updateImage();
     }
 
     if (imageAspectMatchesMonitor)
@@ -166,7 +167,7 @@ void MainWindow::setImage(const ImageDetails &imageDetails)
     {
       pendingReply->abort();
     }
-    updateImage(false);
+    updateImage();
 }
 
 void MainWindow::fileDownloaded(QNetworkReply* netReply) 
@@ -179,12 +180,12 @@ void MainWindow::fileDownloaded(QNetworkReply* netReply)
     {
       downloadedData = netReply->readAll();
       netReply->deleteLater();
-      updateImage(false);
+      updateImage();
     }
   }
 }
 
-void MainWindow::updateImage(bool immediately)
+void MainWindow::updateImage()
 {
     checkWindowSize();
     if (currentImage.filename == "")
@@ -203,7 +204,7 @@ void MainWindow::updateImage(bool immediately)
 
     QLabel *label = this->findChild<QLabel*>("image");
     const QPixmap* oldImage = label->pixmap();
-    if (oldImage != NULL && !immediately)
+    if (oldImage != NULL && transitionSeconds > 0)
     {
       QPalette palette;
       palette.setBrush(QPalette::Background, *oldImage);
@@ -256,13 +257,13 @@ void MainWindow::updateImage(bool immediately)
 
     label->setPixmap(background);
 
-    if (oldImage != NULL && !immediately)
+    if (oldImage != NULL && transitionSeconds > 0)
     {
       auto effect = new QGraphicsOpacityEffect(label);
       effect->setOpacity(0.0);
       label->setGraphicsEffect(effect);
       QPropertyAnimation* animation = new QPropertyAnimation(effect, "opacity");
-      animation->setDuration(1000);
+      animation->setDuration(transitionSeconds*1000);
       animation->setStartValue(0);
       animation->setEndValue(1);
       animation->start(QAbstractAnimation::DeleteWhenStopped);
@@ -393,6 +394,11 @@ void MainWindow::setOverlayHexRGB(QString overlayHexRGB)
     this->overlayHexRGB = overlayHexRGB;
 }
 
+void MainWindow::setTransitionTime(unsigned int transitionSeconds)
+{
+    this->transitionSeconds = transitionSeconds;
+}
+
 void MainWindow::warn(std::string text)
 {
   QLabel *label = this->findChild<QLabel*>("image");
diff --git a/src/mainwindow.h b/src/mainwindow.h
index fcfac94..916d249 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -28,6 +28,7 @@ public:
     void setImage(const ImageDetails &imageDetails);
     void setBlurRadius(unsigned int blurRadius);
     void setBackgroundOpacity(unsigned int opacity);
+    void setTransitionTime(unsigned int transitionSeconds);
     void warn(std::string text);
     void setOverlay(std::unique_ptr<Overlay> &overlay);
     void setBaseOptions(const ImageDisplayOptions &baseOptionsIn);
@@ -52,13 +53,14 @@ private:
     QNetworkReply *pendingReply = nullptr;
     QSize lastScreenSize = {0,0};
     QString overlayHexRGB = "#FFFF";
+    unsigned int transitionSeconds = 1;
 
     std::unique_ptr<Overlay> overlay;
     ImageSwitcher *switcher = nullptr;
 
     void drawText(QPixmap& image, int margin, int fontsize, QString text, int alignment);
 
-    void updateImage(bool immediately);
+    void updateImage();
     int getImageRotation();
 
     QPixmap getBlurredBackground(const QPixmap& originalSize, const QPixmap& scaled);

From 87315a7bdab801bd8898a6be394cdc471992b7c9 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sat, 23 Oct 2021 14:03:53 +1300
Subject: [PATCH 28/30] - fix spew from QDir when not using a config file

---
 .gitignore        |  1 +
 src/appconfig.cpp | 16 +++++++++++++++-
 src/main.cpp      |  5 +++++
 3 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index d46ff1d..6e96e51 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@ make
 .git
 build
 .vscode
+test_config/slide.options.json
diff --git a/src/appconfig.cpp b/src/appconfig.cpp
index a9fb920..fcbb783 100644
--- a/src/appconfig.cpp
+++ b/src/appconfig.cpp
@@ -49,6 +49,11 @@ void SetJSONBool(bool &value, QJsonObject jsonDoc, const char *key) {
 }
 
 Config loadConfiguration(const std::string &configFilePath, const Config &currentConfig) {
+  if(configFilePath.empty())
+  {
+    return currentConfig;
+  }
+
   QString jsonFile(configFilePath.c_str());
   QDir directory;
   if(!directory.exists(jsonFile))
@@ -130,7 +135,7 @@ QString getAppConfigFilePath(const std::string &configPath) {
   std::string userConfigFolder = "~/.config/slide/";
   std::string systemConfigFolder = "/etc/slide";
   QString baseConfigFilename("slide.options.json");
-  
+
   QDir directory(userConfigFolder.c_str());
   QString jsonFile = "";
   if (!configPath.empty())
@@ -218,6 +223,11 @@ QVector<PathEntry> parsePathEntry(QJsonObject &jsonMainDoc, bool baseRecursive,
 }
 
 AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
+  if(commandLineConfig.configPath.empty())
+  {
+    return commandLineConfig;
+  }
+
   QString jsonFile = getAppConfigFilePath(commandLineConfig.configPath);
   QDir directory;
   if(!directory.exists(jsonFile))
@@ -272,6 +282,10 @@ AppConfig loadAppConfiguration(const AppConfig &commandLineConfig) {
 }
 
 Config getConfigurationForFolder(const std::string &folderPath, const Config &currentConfig) {
+  if(folderPath.empty())
+  {
+    return currentConfig;
+  }
   QDir directory(folderPath.c_str());
   QString jsonFile = directory.filePath(QString("options.json"));
   if(directory.exists(jsonFile))
diff --git a/src/main.cpp b/src/main.cpp
index 4a3b42d..6ec6f74 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -210,6 +210,11 @@ std::unique_ptr<ImageSelector> GetSelectorForApp(const AppConfig& appConfig)
 
 void ReloadConfigIfNeeded(AppConfig &appConfig, MainWindow &w, ImageSwitcher *switcher)
 {  
+  if(appConfig.configPath.empty())
+  {
+    return;
+  }
+  
   QString jsonFile = getAppConfigFilePath(appConfig.configPath);
   QDir directory;
   if(!directory.exists(jsonFile))

From cf45a045ff5ea73560b460b01d86fdbaa23d1138 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sat, 23 Oct 2021 15:53:56 +1300
Subject: [PATCH 29/30] - Fix image stretching not filling the frame when you
 have really wide (or tall) images. Check that stretching on the main
 dimension will end up the right size, otherwise stretch the otherway

---
 src/mainwindow.cpp | 28 ++++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 5c3ffcd..de72901 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -299,8 +299,10 @@ void MainWindow::setOverlay(std::unique_ptr<Overlay> &o)
 QPixmap MainWindow::getBlurredBackground(const QPixmap& originalSize, const QPixmap& scaled)
 {
     if (currentImage.options.fitAspectAxisToWindow) {
-      // our scaled version will just fill the whole screen, us it directly
-      return scaled.copy();
+      // our scaled version will just fill the whole screen, use it directly
+      //Log("Using scaled image");
+      QRect rect((scaled.width() - width())/2, 0, width(), height());
+      return scaled.copy(rect);
     } else if (scaled.width() < width()) {
       QPixmap background = blur(originalSize.scaledToWidth(width(), Qt::SmoothTransformation));
       QRect rect(0, (background.height() - height())/2, width(), height());
@@ -324,18 +326,32 @@ QPixmap MainWindow::getScaledPixmap(const QPixmap& p)
 {
   if (currentImage.options.fitAspectAxisToWindow)
   {
-    if (currentImage.aspect() == ImageAspect_Portrait)
+    bool stretchWidth = currentImage.aspect() == ImageAspect_Landscape;
+    bool stretchHeight = currentImage.aspect() == ImageAspect_Portrait;
+    // check the stretched image will naturally fill the screen for its aspect ratio
+    if (stretchHeight && (width() > ((double)height()/p.height())*p.width()))
+    {
+      // stretched via height won't fill the width, so stretch the other way
+      stretchHeight = false;
+      stretchWidth = true;
+    }
+    else if (stretchWidth && (height() > ((double)width()/p.width())*p.height()))
+    {
+      // stretched via width won't fill the width, so stretch the other way
+      stretchWidth = false;
+      stretchHeight = true;
+    }
+
+    if (stretchHeight)
     {
       // potrait mode, make height of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToHeight(height(), Qt::SmoothTransformation);
       return pTemp.copy(0,0,width(),height());
     }
-    else if (currentImage.aspect() == ImageAspect_Landscape)
+    else if (stretchWidth)
     {
       // landscape mode, make width of image fit screen and crop top/bottom
       QPixmap pTemp = p.scaledToWidth(width(), Qt::SmoothTransformation);
-      //int imageTempWidth = pTemp.width();
-      //int imageTempHeight = pTemp.height();
       return pTemp.copy(0,0,width(),height());
     }
   }

From 190ff6a508164f7e75532e95aefd569fb92d3db7 Mon Sep 17 00:00:00 2001
From: Alfred Reynolds <alfred@mazuma.net.au>
Date: Sat, 13 Nov 2021 13:42:39 +1300
Subject: [PATCH 30/30] - Remove network/image download code (as it is unused)

---
 src/main.cpp          |  4 ----
 src/mainwindow.cpp    | 51 +------------------------------------------
 src/mainwindow.h      |  7 ------
 src/pathtraverser.cpp |  2 --
 src/pathtraverser.h   |  3 ---
 src/slide.pro         |  2 +-
 6 files changed, 2 insertions(+), 67 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 6ec6f74..e80c628 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -7,7 +7,6 @@
 #include "logger.h"
 
 #include <QApplication>
-#include <QNetworkAccessManager>
 #include <QRegularExpression>
 #include <iostream>
 #include <sys/file.h>
@@ -261,11 +260,8 @@ int main(int argc, char *argv[])
   Log( "Rotation Time: ", appConfig.rotationSeconds );
   Log( "Overlay input: ", appConfig.overlay );
   
-  QNetworkAccessManager webCtrl; 
-
   MainWindow w;
   ConfigureWindowFromSettings(w, appConfig);
-  w.setNetworkManager(&webCtrl);
   w.show();
 
   std::unique_ptr<ImageSelector> selector = GetSelectorForApp(appConfig);
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index de72901..582f888 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -18,8 +18,6 @@
 #include <QGraphicsPixmapItem>
 #include <QApplication>
 #include <QScreen>
-#include <QNetworkReply>
-#include <sstream>
 
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
@@ -162,46 +160,15 @@ void MainWindow::checkWindowSize()
 void MainWindow::setImage(const ImageDetails &imageDetails)
 {
     currentImage = imageDetails;
-    downloadedData.clear();
-    if (pendingReply)
-    {
-      pendingReply->abort();
-    }
     updateImage();
 }
 
-void MainWindow::fileDownloaded(QNetworkReply* netReply) 
-{
-  if (netReply == pendingReply)
-  {
-    pendingReply = nullptr;
-    QNetworkReply::NetworkError err = netReply->error();
-    if (err == QNetworkReply::NoError)
-    {
-      downloadedData = netReply->readAll();
-      netReply->deleteLater();
-      updateImage();
-    }
-  }
-}
-
 void MainWindow::updateImage()
 {
     checkWindowSize();
     if (currentImage.filename == "")
       return;
 
-    if (currentImage.filename.find("https://") != std::string::npos && downloadedData.isNull())
-    {
-      if (pendingReply == nullptr)
-      {
-        QNetworkRequest request(QUrl(currentImage.filename.c_str()));
-        pendingReply = networkManager->get(request);
-        connect( networkManager, SIGNAL (finished(QNetworkReply*)), this, SLOT (fileDownloaded(QNetworkReply*)));
-      }
-      return;
-    }
-
     QLabel *label = this->findChild<QLabel*>("image");
     const QPixmap* oldImage = label->pixmap();
     if (oldImage != NULL && transitionSeconds > 0)
@@ -212,18 +179,7 @@ void MainWindow::updateImage()
     }
 
     QPixmap p;
-    if (!downloadedData.isNull())
-    {
-      p.loadFromData(downloadedData);
-      // BUG BUG have the selector update this?
-      currentImage.width = p.width();
-      currentImage.height = p.height();
-      currentImage.rotation = 0;
-    }
-    else
-    {
-      p.load( currentImage.filename.c_str() );
-    }
+    p.load( currentImage.filename.c_str() );
 
     Log("size:", p.width(), "x", p.height(), "(window:", width(), ",", height(), ")");
 
@@ -440,8 +396,3 @@ const ImageDisplayOptions &MainWindow::getBaseOptions()
 {
    return baseImageOptions; 
 }
-
-void MainWindow::setNetworkManager(QNetworkAccessManager *networkManagerIn)
-{
-  networkManager = networkManagerIn;
-}
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 916d249..329a809 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -3,7 +3,6 @@
 
 #include <QMainWindow>
 #include <QPixmap>
-#include <QNetworkAccessManager>
 #include "imagestructs.h"
 #include "imageselector.h"
 
@@ -34,12 +33,9 @@ public:
     void setBaseOptions(const ImageDisplayOptions &baseOptionsIn);
     const ImageDisplayOptions &getBaseOptions();
     void setImageSwitcher(ImageSwitcher *switcherIn);
-    void setNetworkManager(QNetworkAccessManager *networkManagerIn);
     void setOverlayHexRGB(QString overlayHexRGB);
 public slots:
     void checkWindowSize();
-private slots:
-  void fileDownloaded(QNetworkReply* pReply);
 private:
     Ui::MainWindow *ui;
 
@@ -48,9 +44,6 @@ private:
     ImageDisplayOptions baseImageOptions;
     bool imageAspectMatchesMonitor = false;
     ImageDetails currentImage;
-    QByteArray downloadedData;
-    QNetworkAccessManager *networkManager = nullptr;
-    QNetworkReply *pendingReply = nullptr;
     QSize lastScreenSize = {0,0};
     QString overlayHexRGB = "#FFFF";
     unsigned int transitionSeconds = 1;
diff --git a/src/pathtraverser.cpp b/src/pathtraverser.cpp
index 1be7974..73ee6ec 100644
--- a/src/pathtraverser.cpp
+++ b/src/pathtraverser.cpp
@@ -6,8 +6,6 @@
 #include <QDirIterator>
 #include <QDir>
 #include <QFileInfo>
-#include <QDomDocument>
-#include <QDomAttr>
 #include <iostream>
 #include <stdlib.h>     /* srand, rand */
 
diff --git a/src/pathtraverser.h b/src/pathtraverser.h
index c018081..412183a 100644
--- a/src/pathtraverser.h
+++ b/src/pathtraverser.h
@@ -4,9 +4,6 @@
 #include <iostream>
 #include <QDir>
 #include <QStringList>
-#include <QNetworkAccessManager>
-#include <QNetworkRequest>
-#include <QNetworkReply>
 #include "imageselector.h"
 
 static const QStringList supportedFormats={"jpg","jpeg","png","tif","tiff"};
diff --git a/src/slide.pro b/src/slide.pro
index 04cc324..0cffcbd 100644
--- a/src/slide.pro
+++ b/src/slide.pro
@@ -4,7 +4,7 @@
 #
 #-------------------------------------------------
 
-QT       += core gui network xml
+QT       += core gui
 CONFIG += qt 
 CONFIG += debug
 CONFIG += c++1z