Refactor provider module. Support starting without mode.

src/providers.nim

@@ -1,4 +1,4 @@
-import os, sets, random, httpClient, json, strformat
+import os, sets, random, httpClient, json, strformat, options
 import gintro/[gdkpixbuf, gobject]
 import commands
 
@@ -12,20 +12,19 @@ type
   FileOpResult* = object of OpResult
     file*: string
 
-  ProviderKind* {.pure.} = enum
+  Mode* {.pure.} = enum   ## Options for the display mode
+    None = "none"         ## No images will be displayed
     Foxes = "foxes"       ## Some nice foxes
     Inspiro = "inspiro"   ## Inspiring nonsense
     File = "file"         ## Images from a local path
 
   ImageProvider* = ref object of RootObj
-    verbose: bool
+    ## Manages images that should be displayed
-    case kind: ProviderKind
+    verbose: bool         ## Additional logging for the image provider
-    of ProviderKind.Foxes, ProviderKind.Inspiro:
+    mode* : Mode          ## Selects the API that is used to get images
-      url: string
+    path*: Option[string] ## Path on the local file syetem that will be used in `file` mode
-    of ProviderKind.File:
+    exts: HashSet[string] ## Allowed extensions that the `file` mode will display
-      exts: HashSet[string]
+    files: seq[string]    ## Currently loaded list of images in `file` mode
-      path*: string
-      files*: seq[string]
 
 var
   client = newHttpClient()  ## For loading images from the web
@@ -34,28 +33,21 @@ var
 # Constructors
 ########################
 
-proc newFileProvider(path: string): ImageProvider =
+proc newImageProvider(verbose: bool, mode: Mode, path: Option[string]): ImageProvider =
-  ## Create an image provider to access images from the local file system 
   randomize()
-  result = ImageProvider(kind: ProviderKind.File, path: path, exts: supportedExts.toHashSet)
+  ImageProvider(verbose: verbose, mode: mode, path: path, exts: supportedExts.toHashSet)
 
-proc newInspiroProvider(): ImageProvider =
+proc newImageProvider*(verbose: bool): ImageProvider =
-  ## Create an image provider for the inspiro bot API
+  newImageProvider(verbose, Mode.None, none(string))
-  ImageProvider(kind: ProviderKind.Inspiro, url: inspiroUrl)
 
-proc newFoxProvider(): ImageProvider =
+proc newImageProvider*(verbose: bool, path: string): ImageProvider =
-  ## Create an image provider to access the API at "https://randomfox.ca/floof/".
+  newImageProvider(verbose, Mode.None, some(path))
-  ImageProvider(kind: ProviderKind.Foxes, url: foxesUrl)
 
-proc newImageProvider*(kind: ProviderKind, filePath: string = ""): ImageProvider =
+proc newImageProvider*(verbose: bool, mode: Mode): ImageProvider =
-  ## Create a new `ImageProvider` for the API.
+  newImageProvider(verbose, mode, none(string))
-  case kind
+
-  of ProviderKind.Foxes:
+proc newImageProvider*(verbose: bool, mode: Mode, path: string): ImageProvider =
-    newFoxProvider()
+  newImageProvider(verbose, mode, some(path))
-  of ProviderKind.Inspiro:
-    newInspiroProvider()
-  of ProviderKind.File:
-    newFileProvider(filePath)
 
 proc newFileOpResultError(msg: string): FileOpResult =
   FileOpResult(success: false, errorMsg: msg)
@@ -77,7 +69,7 @@ proc log(ip: ImageProvider, msg: string) =
 proc getFox(ip: ImageProvider): FileOpResult =
   ## Download image from the fox API
   try:
-    let urlData = client.getContent(ip.url)
+    let urlData = client.getContent(foxesUrl)
     let info = parseJson(urlData)
     let imageData = client.getContent(info["image"].getStr)
     let dlFile = fmt"{tmpFile}.download"
@@ -93,7 +85,7 @@ proc getFox(ip: ImageProvider): FileOpResult =
 proc getInspiro(ip: ImageProvider): FileOpResult =
   ## Download and save image from the inspiro API
   try:
-    let imageUrl = client.getContent(ip.url)
+    let imageUrl = client.getContent(inspiroUrl)
     ip.log fmt"Downloading inspiro image from: '{imageUrl}'"
     let imageData = client.getContent(imageUrl)
     let dlFile = fmt"{tmpFile}.download"
@@ -105,32 +97,35 @@ proc getInspiro(ip: ImageProvider): FileOpResult =
 
 proc getLocalFile(ip: var ImageProvider): FileOpResult =
   ## Provide an image from a local folder
+
   # First, check if there are still images left to be loaded.
   # If not reread all files from the path
   if ip.files.len < 1:
-    if ip.path == "":
+    if ip.path.isNone:
       return newFileOpResultError("No path for image loading")
     ip.log "Reloading file list..."
-    for file in walkDirRec(ip.path):
+    for file in walkDirRec(ip.path.get):
       let split = splitFile(file)
       if ip.exts.contains(split.ext):
         ip.files.add(file)
     ip.log fmt"Loaded {ip.files.len} files"
     shuffle(ip.files)
+
   # Remove the current file after
   result = newFileOpResult(ip.files[0])
   ip.files.delete(0)
 
 proc getFileName(ip: var ImageProvider): FileOpResult =
   ## Get the temporary file name of the next file to display
-  case ip.kind
+  case ip.mode
-  of ProviderKind.File:
+  of Mode.File:
     return ip.getLocalFile()
-  of ProviderKind.Foxes:
+  of Mode.Foxes:
     return ip.getFox()
-  of ProviderKind.Inspiro:
+  of Mode.Inspiro:
     return ip.getInspiro()
-  return newFileOpResultError("Not implemented")
+  else:
+    return newFileOpResultError("Not implemented")
 
 ########################
 # Exported procs
@@ -139,6 +134,9 @@ proc getFileName(ip: var ImageProvider): FileOpResult =
 proc next*(ip: var ImageProvider, width, height: int): FileOpResult =
   ## Uses the image provider to get a new image ready to display.
   ## `width` and `height` should be the size of the window.
+  if ip.mode == Mode.None:
+    return newFileOpResultError("No mode active")
+
   let op = ip.getFileName()
   if not op.success: return op
 

src/randopix.nim

@@ -44,7 +44,7 @@ proc notify(label: Label, message: string = "") =
 proc newArgs(): Option[Args] =
   let p = newParser("randopix"):
     help(fmt"Version {version} - Display random images from different sources")
-    option("-m", "--mode", help="The image source mode.", choices=enumToStrings(ProviderKind))
+    option("-m", "--mode", help="The image source mode.", choices=enumToStrings(Mode))
     option("-p", "--path", help="Path to a directory with images for the 'file' mode")
     option("-t", "--timeout", help="Seconds before the image is refreshed", default="300")
     flag("-w", "--windowed", help="Do not start in fullscreen mode")
@@ -52,8 +52,20 @@ proc newArgs(): Option[Args] =
 
   try:
     let opts = p.parse(commandLineParams())
-    let mode = some(parseEnum[ProviderKind](opts.mode))
+
-    imageProvider = newImageProvider(mode.get, opts.path)
+    # Parse the starting mode
+    var startMode: Mode
+    try:
+      startMode= parseEnum[Mode](opts.mode)
+    except ValueError:
+      startMode = Mode.None
+
+    # Create the image provider
+    if opts.path != "":
+      imageProvider = newImageProvider(opts.verbose, startMode, opts.path)
+    else:
+      imageProvider = newImageProvider(opts.verbose, startMode)
+
     ## Timeout is given in seconds as an argument
     var timeout = 3000
     try:
@@ -66,44 +78,48 @@ proc newArgs(): Option[Args] =
       verbose: opts.verbose,
       timeout: timeout))
   except:
-    echo getCurrentExceptionMsg()
     echo p.help
 
 proc updateImage(image: Image): bool =
   ## Updates the UI with a new image
   try:
-    if (args.verbose): log "Refreshing..."
+    if args.verbose: log "Refreshing..."
+
+    if imageProvider.mode == Mode.None:
+      log "No display mode"
+      label.notify "No mode selected"
+      return true
 
     var wWidth, wHeight: int
     window.getSize(wWidth, wHeight)
 
     let op = imageProvider.next(wWidth, wHeight)
     result = op.success
-    if op.success:
+    if not op.success:
-      image.setFromFile(op.file)
-    else:
       label.notify op.errorMsg
+      return
+
+    image.setFromFile(op.file)
+    label.notify
   except:
     let
       e = getCurrentException()
       msg = getCurrentExceptionMsg()
     log "Got exception ", repr(e), " with message ", msg
+    label.notify "Error while refreshing image, retrying..."
     return false
 
 proc timedUpdate(image: Image): bool =
-  let ok = updateImage(image);
+  discard updateImage(image);
-  if not ok:
-    label.notify "Error while refreshing image, retrying..."
-  else:
-    label.notify
   updateTimeout = int(timeoutAdd(uint32(args.timeout), timedUpdate, image))
   return false
 
 proc forceUpdate(action: SimpleAction; parameter: Variant; image: Image): void =
-  log "Force refreshing image now"
+  log "Refreshing image..."
+  label.notify "Refreshing image..."
   if updateTimeout > 0:
     discard updateTimeout.remove
-  discard image.timedUpdate()
+  updateTimeout = int(timeoutAdd(500, timedUpdate, image))
 
 proc checkServerChannel(image: Image): bool =
   ## Check the channel from the control server for incomming commands
@@ -127,7 +143,6 @@ proc checkServerChannel(image: Image): bool =
 
   sleep(100)
   result = true
-  # discard idleAdd(checkServerChannel, parameter)
 
 proc toggleFullscreen(action: SimpleAction; parameter: Variant; window: ApplicationWindow) =
   ## Fullscreen toggle event