Imported Upstream version 0.4.0~alpha1upstream/0.4.0_alpha1

1 files changed, 2028 insertions, 5968 deletions

diff --git a/rapid/rapid.py b/rapid/rapid.py
index f41c79f..efd8145 100755
--- a/rapid/rapid.py
+++ b/rapid/rapid.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 # -*- coding: latin1 -*-
 
-### Copyright (C) 2007, 2008, 2009, 2010 Damon Lynch <damonlynch@gmail.com>
+### Copyright (C) 2011 Damon Lynch <damonlynch@gmail.com>
 
 ### This program is free software; you can redistribute it and/or modify
 ### it under the terms of the GNU General Public License as published by
@@ -17,19 +17,8 @@
 ### along with this program; if not, write to the Free Software
 ### Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-#needed for python 2.5, unneeded for python 2.6
-from __future__ import with_statement 
 
-import sys
-import os
-import shutil
-import time
-import datetime
-import atexit
 import tempfile
-import types
-import webbrowser
-import operator
 
 import dbus
 import dbus.bus
@@ -37,1536 +26,79 @@ import dbus.service
 from dbus.mainloop.glib import DBusGMainLoop
 DBusGMainLoop(set_as_default=True)
 
-from threading import Thread, Lock
-from thread import error as thread_error
-from thread import get_ident
-
-import gtk.gdk as gdk
-import pango
-import gobject
-
-try:
-    import gio
-    import glib
-    using_gio = True
-except ImportError:
-    import gnomevfs
-    using_gio = False
-
-import prefs
-import paths
-import gnomeglade
-
 from optparse import OptionParser
 
-import pynotify
+import gtk
+import gtk.gdk as gdk
 
-import idletube as tube
+import webbrowser
 
-import config
+import sys, time, types, os, datetime
 
-from config import  STATUS_CANNOT_DOWNLOAD, STATUS_DOWNLOADED, \
-                    STATUS_DOWNLOADED_WITH_WARNING, \
-                    STATUS_DOWNLOAD_FAILED, \
-                    STATUS_DOWNLOAD_PENDING, \
-                    STATUS_BACKUP_PROBLEM, \
-                    STATUS_NOT_DOWNLOADED, \
-                    STATUS_DOWNLOAD_AND_BACKUP_FAILED, \
-                    STATUS_WARNING
-                    
-import common
-import misc
-import higdefaults as hd
+import gobject, pango, cairo, array, pangocairo, gio
 
-from media import getDefaultPhotoLocation, getDefaultVideoLocation, \
-                  getDefaultBackupPhotoIdentifier, \
-                  getDefaultBackupVideoIdentifier
-                  
-import ValidatedEntry
-                  
-from media import CardMedia
+from multiprocessing import Process, Pipe, Queue, Event, Value, Array, current_process, log_to_stderr
+from ctypes import c_int, c_bool, c_char
 
-import media
+import logging
+logger = log_to_stderr()
 
-import metadata
-import videometadata
-from videometadata import DOWNLOAD_VIDEO
+# Rapid Photo Downloader modules
 
-import renamesubfolderprefs as rn
+import rpdfile
+                  
 import problemnotification as pn
+import thumbnail as tn
+import rpdmultiprocessing as rpdmp
 
-import tableplusminus as tpm
-
-__version__ = config.version
-
-try: 
-    import pygtk 
-    pygtk.require("2.0") 
-except: 
-    pass 
-try: 
-    import gtk 
-    import gtk.glade 
-except: 
-    sys.exit(1)
-
-try:
-    from dropshadow import image_to_pixbuf, pixbuf_to_image, DropShadow
-    DROP_SHADOW = True
-except:
-    DROP_SHADOW = False
-
-
-#~ DROP_SHADOW = False # for testing
-    
-from common import Configi18n
-global _
-_ = Configi18n._
-
-#Translators: if neccessary, for guidance in how to translate this program, you may see http://damonlynch.net/translate.html 
-PROGRAM_NAME = _('Rapid Photo Downloader')
-
-TINY_SCREEN = gtk.gdk.screen_height() <= config.TINY_SCREEN_HEIGHT
-#~ TINY_SCREEN = True
-
-def today():
-    return datetime.date.today().strftime('%Y-%m-%d')
-
-
-
-def cmd_line(msg):    
-    if verbose:
-        print msg
-
-exiting = False
-
-def updateDisplay(display_queue):
-
-    try:
-        if display_queue.size() != 0:
-            call, args = display_queue.get()
-            if not exiting:
-                call(*args)
-#            else do not update display
-        else:
-            sys.stderr.write("Empty display queue!\n")
-        return True
-    
-    except tube.EOInformation:
-        for w in workers.getStartedWorkers():
-            w.join()
-
-        gtk.main_quit()
-        
-        return False
-
-
-class Queue(tube.Tube):
-    def __init__(self, maxSize = config.MAX_NO_READERS):
-        tube.Tube.__init__(self, maxSize)
-
-    def setMaxSize(self, maxSize):
-        self.maxsize = maxSize
-
-
-# Module wide values -
-#   set up thesse variable in global name space, and initialize with proper 
-#   values later
-#   this is ugly but I don't know a better way :(
-
-display_queue = Queue()
-media_collection_treeview = selection_hbox = log_dialog = None
-
-job_code = None
-need_job_code_for_renaming = False
-
-class ThreadManager:
-    """
-    Manages the threads that actually download photos and videos
-    """
-    _workers = []
-    
-    
-    def append(self, w):
-        self._workers.append(w)
-            
-    def __getitem__(self, i):
-        return self._workers[i]
-        
-    def __len__(self):
-        return len(self._workers)
-        
-    def disableWorker(self, thread_id):
-        """
-        set so a worker will not run, or if it is running, make it quit and therefore complete
-        """
-        
-        self._workers[thread_id].manuallyDisabled = True
-        if self._workers[thread_id].hasStarted:
-            self._workers[thread_id].quit()
-            
-        else:
-            self._workers[thread_id].doNotStart = True
-        
-    def _isReadyToStart(self, w):
-        """
-        Returns True if the worker is ready to start
-        and has not been disabled
-        """
-        return not w.hasStarted and not w.doNotStart and not w.manuallyDisabled
-        
-    def _isReadyToDownload(self, w):
-       return w.scanComplete and not w.downloadStarted and not w.doNotStart and w.isAlive() and not w.manuallyDisabled
-       
-    def _isScanning(self, w):
-        return w.isAlive() and w.hasStarted and not w.scanComplete and not w.manuallyDisabled
-       
-    def _isDownloading(self,  w):
-        return w.downloadStarted and w.isAlive() and not w.downloadComplete
-        
-    def _isPaused(self, w):
-        return w.downloadStarted and not w.running and not w.downloadComplete and not w.manuallyDisabled and w.isAlive()
-        
-    def _isFinished(self, w):
-        """
-        Returns True if the worker has finished running
-        
-        It does not signify it finished a download
-        """
-        
-        return (w.hasStarted and not w.isAlive()) or w.manuallyDisabled
-                
-    def completedDownload(self,  w):
-        return w.completedDownload
-    
-    def firstWorkerReadyToStart(self):
-        for w in self._workers:
-            if self._isReadyToStart(w):
-                return w
-        return None
-
-    def firstWorkerReadyToDownload(self):
-        for w in self._workers:
-            if self._isReadyToDownload(w):
-                return w
-        return None
-
-    def startWorkers(self):
-        for w in self.getReadyToStartWorkers():
-            #for some reason, very occassionally a thread that has been started shows up in this list, so must filter them out
-            if not w.isAlive():
-                w.start()      
-            
-    def quitAllWorkers(self):
-        global exiting 
-        exiting = True
-        for w in self._workers:
-            w.quit()
-
-    def getWorkers(self):
-        for w in self._workers:
-            yield w
-            
-    def getNonFinishedWorkers(self):
-        for w in self._workers:
-            if not self._isFinished(w):
-                yield w
-                
-    def getStartedWorkers(self):
-        for w in self._workers:
-            if w.hasStarted:
-                yield w
-    
-    def getReadyToStartWorkers(self):
-        for w in self._workers:
-            if self._isReadyToStart(w):
-                yield w
-
-    def getReadyToDownloadWorkers(self):
-        for w in self._workers:
-            if self._isReadyToDownload(w):
-                yield w
-                
-    def getNotDownloadingWorkers(self):
-        for w in self._workers:
-            if w.hasStarted and not w.downloadStarted:
-                yield w
-                
-    def getNotDownloadingAndNotFinishedWorkers(self):
-        for w in self._workers:
-            if w.hasStarted and not w.downloadStarted and not self._isFinished(w):
-                yield w
-        
-
-    def noReadyToStartWorkers(self):
-        n = 0
-        for w in self._workers:
-            if self._isReadyToStart(w):
-                n += 1
-        return n
-        
-    def noScanningWorkers(self):
-        n = 0
-        for w in self._workers:
-            if self._isScanning(w):
-                n += 1
-        return n
-        
-    def getScanningWorkers(self):
-        for w in self._workers:
-            if self._isScanning(w):
-                yield w
-        
-    def scanComplete(self, threads):
-        """
-        Returns True only if the list of threads have completed their scan
-        """
-        for thread_id in threads:
-            if not self[thread_id].scanComplete:
-                return False
-        return True
-    
-    def noReadyToDownloadWorkers(self):
-        n = 0
-        for w in self._workers:
-            if self._isReadyToDownload(w):
-                n += 1
-        return n
-        
-    def getRunningWorkers(self):
-        for w in self._workers:
-            if w.hasStarted and w.isAlive():
-                yield w
-                
-    def getDownloadingWorkers(self):
-        for w in self._workers:
-            if self._isDownloading(w):
-                yield w
-
-    def getPausedDownloadingWorkers(self):
-        for w in self._workers:
-            if self._isPaused(w):
-                yield w            
-
-    def getWaitingForJobCodeWorkers(self):
-        for w in self._workers:
-            if w.waitingForJobCode:
-                yield w
-                
-    def getAutoStartWorkers(self):
-        for w in self._workers:
-            if w.autoStart:
-                yield w
-    
-    def getFinishedWorkers(self):
-        for w in self._workers:
-            if self._isFinished(w):
-                yield w
-    
-    def noDownloadingWorkers(self):
-        i = 0
-        for w in self._workers:
-            if self._isDownloading(w):
-                i += 1
-        return i
-
-    def noRunningWorkers(self):
-        i = 0
-        for w in self._workers:
-            if w.hasStarted and w.isAlive():
-                i += 1
-        return i
-        
-    def noPausedWorkers(self):
-        i = 0
-        for w in self._workers:
-            if self._isPaused(w):
-                i += 1
-        return i
-        
-    def getNextThread_id(self):
-        return len(self._workers)
-        
-    def printWorkerStatus(self, worker=None):
-        if worker:
-            l = [worker]
-        else:
-            l = range(len(self._workers))
-        for i in l: 
-            print "\nThread %i\n=======\n" % i
-            w = self._workers[i]
-            print "Volume / source:",  w.cardMedia.prettyName(limit=0)
-            print "Do not start:", w.doNotStart
-            print "Started:", w.hasStarted
-            print "Running:", w.running
-            print "Scan completed:",  w.scanComplete
-            print "Download started:",  w.downloadStarted
-            print "Download completed:",  w.downloadComplete
-            print "Finished:", self._isFinished(w)
-            print "Alive:",  w.isAlive()
-            print "Manually disabled:",  w.manuallyDisabled,  "\n"
-
-                
-        
-workers = ThreadManager()
-
-class RapidPreferences(prefs.Preferences):
-    if TINY_SCREEN:
-        zoom = 120
-    else:
-        zoom = config.MIN_THUMBNAIL_SIZE * 2
-        
-    defaults = {
-        "program_version": prefs.Value(prefs.STRING, ""),
-        "download_folder": prefs.Value(prefs.STRING, 
-                                        getDefaultPhotoLocation()),
-        "video_download_folder": prefs.Value(prefs.STRING, 
-                                        getDefaultVideoLocation()),
-        "subfolder": prefs.ListValue(prefs.STRING_LIST, rn.DEFAULT_SUBFOLDER_PREFS),
-        "video_subfolder": prefs.ListValue(prefs.STRING_LIST, rn.DEFAULT_VIDEO_SUBFOLDER_PREFS),
-        "image_rename": prefs.ListValue(prefs.STRING_LIST, [rn.FILENAME, 
-                                        rn.NAME_EXTENSION,
-                                        rn.ORIGINAL_CASE]),
-        "video_rename": prefs.ListValue(prefs.STRING_LIST, [rn.FILENAME, 
-                                        rn.NAME_EXTENSION,
-                                        rn.ORIGINAL_CASE]),
-        "device_autodetection": prefs.Value(prefs.BOOL, True),
-        "device_location": prefs.Value(prefs.STRING, os.path.expanduser('~')), 
-        "device_autodetection_psd": prefs.Value(prefs.BOOL,  False),
-        "device_whitelist": prefs.ListValue(prefs.STRING_LIST,  ['']), 
-        "device_blacklist": prefs.ListValue(prefs.STRING_LIST,  ['']), 
-        "backup_images": prefs.Value(prefs.BOOL, False),
-        "backup_device_autodetection": prefs.Value(prefs.BOOL, True),
-        "backup_identifier": prefs.Value(prefs.STRING, 
-                                        getDefaultBackupPhotoIdentifier()),
-        "video_backup_identifier": prefs.Value(prefs.STRING, 
-                                        getDefaultBackupVideoIdentifier()),
-        "backup_location": prefs.Value(prefs.STRING, os.path.expanduser('~')),
-        "strip_characters": prefs.Value(prefs.BOOL, True),
-        "auto_download_at_startup": prefs.Value(prefs.BOOL, False),
-        "auto_download_upon_device_insertion": prefs.Value(prefs.BOOL, False),
-        "auto_unmount": prefs.Value(prefs.BOOL, False),
-        "auto_exit": prefs.Value(prefs.BOOL, False),
-        "auto_delete": prefs.Value(prefs.BOOL, False),
-        "download_conflict_resolution": prefs.Value(prefs.STRING, 
-                                        config.SKIP_DOWNLOAD),
-        "backup_duplicate_overwrite": prefs.Value(prefs.BOOL, False),
-        "display_selection": prefs.Value(prefs.BOOL, True),
-        "display_size_column": prefs.Value(prefs.BOOL, True),
-        "display_filename_column": prefs.Value(prefs.BOOL, False),
-        "display_type_column": prefs.Value(prefs.BOOL, True),
-        "display_path_column": prefs.Value(prefs.BOOL, False),
-        "display_device_column": prefs.Value(prefs.BOOL, False),
-        "display_preview_folders": prefs.Value(prefs.BOOL, True),
-        "show_log_dialog": prefs.Value(prefs.BOOL, False),
-        "day_start": prefs.Value(prefs.STRING,  "03:00"), 
-        "downloads_today": prefs.ListValue(prefs.STRING_LIST, [today(), '0']), 
-        "stored_sequence_no": prefs.Value(prefs.INT,  0), 
-        "job_codes": prefs.ListValue(prefs.STRING_LIST,  [_('New York'),  
-               _('Manila'),  _('Prague'),  _('Helsinki'),   _('Wellington'), 
-               _('Tehran'), _('Kampala'),  _('Paris'), _('Berlin'),  _('Sydney'), 
-               _('Budapest'), _('Rome'),  _('Moscow'),  _('Delhi'), _('Warsaw'), 
-               _('Jakarta'),  _('Madrid'),  _('Stockholm')]),
-        "synchronize_raw_jpg": prefs.Value(prefs.BOOL, False),
-        "hpaned_pos": prefs.Value(prefs.INT, 0),
-        "vpaned_pos": prefs.Value(prefs.INT, 0),
-        "main_window_size_x": prefs.Value(prefs.INT, 0),
-        "main_window_size_y": prefs.Value(prefs.INT, 0),
-        "main_window_maximized": prefs.Value(prefs.INT, 0),
-        "show_warning_downloading_from_camera": prefs.Value(prefs.BOOL, True),
-        "preview_zoom": prefs.Value(prefs.INT, zoom),
-        }
-
-    def __init__(self):
-        prefs.Preferences.__init__(self, config.GCONF_KEY, self.defaults)
-
-    def getAndMaybeResetDownloadsToday(self):
-        v = self.getDownloadsToday()
-        if v <= 0:
-            self.resetDownloadsToday()
-        return v
-
-    def getDownloadsToday(self):
-        """Returns the preference value for the number of downloads performed today 
-        
-        If value is less than zero, that means the date has changed"""
-        
-        hour,  minute = self.getDayStart()
-        adjustedToday = datetime.datetime.strptime("%s %s:%s" % (self.downloads_today[0], hour,  minute), "%Y-%m-%d %H:%M") 
-        
-        now = datetime.datetime.today()
-
-        if  now < adjustedToday :
-            try:
-                return int(self.downloads_today[1])
-            except ValueError:
-                sys.stderr.write(_("Invalid Downloads Today value.\n"))
-                sys.stderr.write(_("Resetting value to zero.\n"))
-                self.setDownloadsToday(self.downloads_today[0] ,  0)
-                return 0
-        else:
-            return -1
-                
-    def setDownloadsToday(self, date,  value=0):
-            self.downloads_today = [date,  str(value)]
-            
-    def incrementDownloadsToday(self):
-        """ returns true if day changed """
-        v = self.getDownloadsToday()
-        if v >= 0:
-            self.setDownloadsToday(self.downloads_today[0] ,  v + 1)
-            return False
-        else:
-            self.resetDownloadsToday(1)
-            return True
-
-    def resetDownloadsToday(self,  value=0):
-        now = datetime.datetime.today()
-        hour,  minute = self.getDayStart()
-        t = datetime.time(hour,  minute)
-        if now.time() < t:
-            date = today()
-        else:
-            d = datetime.datetime.today() + datetime.timedelta(days=1)
-            date = d.strftime(('%Y-%m-%d'))
-            
-        self.setDownloadsToday(date,  value)
-        
-    def setDayStart(self,  hour,  minute):
-        self.day_start = "%s:%s" % (hour,  minute)
-
-    def getDayStart(self):
-        try:
-            t1,  t2 = self.day_start.split(":")
-            return (int(t1),  int(t2))
-        except ValueError:
-            sys.stderr.write(_("'Start of day' preference value is corrupted.\n"))
-            sys.stderr.write(_("Resetting to midnight.\n"))
-            self.day_start = "0:0"
-            return 0, 0
-
-    def getSampleJobCode(self):
-        if self.job_codes:
-            return self.job_codes[0]
-        else:
-            return ''
-            
-    def reset(self):
-        """
-        resets all preferences to default values
-        """
-        
-        prefs.Preferences.reset(self)
-        self.program_version = __version__
-            
-class ImageRenameTable(tpm.TablePlusMinus):
-
-    def __init__(self, parentApp, adjustScrollWindow):
-  
-        tpm.TablePlusMinus.__init__(self, 1, 3)
-        self.parentApp = parentApp
-        self.adjustScrollWindow = adjustScrollWindow
-        if not hasattr(self, "errorTitle"):
-            self.errorTitle = _("Error in Photo Rename preferences")
-                    
-        self.table_type = self.errorTitle[len("Error in "):]
-        self.i = 0
-
-        if adjustScrollWindow:
-            self.scrollBar = self.adjustScrollWindow.get_vscrollbar()
-            #this next line does not work on early versions of pygtk :(
-            self.scrollBar.connect('visibility-notify-event', self.scrollbar_visibility_change)
-            self.connect("size-request", self.size_adjustment)
-            self.connect("add",  self.size_adjustment)
-            self.connect("remove",  self.size_adjustment)
-
-            # get scrollbar thickness from parent app scrollbar - very hackish, but what to do??
-            self.bump = 16# self.parentApp.parentApp.image_scrolledwindow.get_hscrollbar().allocation.height
-            self.haveVerticalScrollbar = False
-
-            # vbar is '1' if there is not vertical scroll bar
-            # if there is  a vertical scroll bar, then it will have a the width of the bar
-            #self.vbar = self.adjustScrollWindow.get_vscrollbar().allocation.width
-
-        self.getParentAppPrefs()
-        self.getPrefsFactory()
-        self.prefsFactory.setDownloadStartTime(datetime.datetime.now())
-        
-        try:
-            self.prefsFactory.checkPrefsForValidity()
-            
-        except (rn.PrefValueInvalidError, rn.PrefLengthError, 
-                rn.PrefValueKeyComboError,  rn.PrefKeyError),  e:
-
-            sys.stderr.write(self.errorTitle + "\n")
-            sys.stderr.write(_("Sorry,these preferences contain an error:\n"))
-            sys.stderr.write(self.prefsFactory.formatPreferencesForPrettyPrint() + "\n")
-            
-            # the preferences were invalid
-            # reset them to their default
-
-            self.prefList = self.prefsFactory.defaultPrefs
-            self.getPrefsFactory()
-            self.updateParentAppPrefs()
-
-            msg = "%s.\n" % e
-            msg += _("Resetting to default values." + "\n")
-            sys.stderr.write(msg)
-            
-            
-            misc.run_dialog(self.errorTitle, msg, 
-                parentApp,
-                gtk.MESSAGE_ERROR)
-        
-        for row in self.prefsFactory.getWidgetsBasedOnPreferences():
-            self.append(row)
-                      
-    def updatePreferences(self):
-        prefList = []
-        for row in self.pm_rows:                
-            for col in range(self.pm_noColumns):
-                widget = row[col]
-                if widget:
-                    name = widget.get_name()
-                    if name == 'GtkComboBox':
-                        value = widget.get_active_text()
-                    elif name == 'GtkEntry':
-                        value = widget.get_text()
-                    else:
-                        sys.stderr.write("Program error: Unknown preference widget!")
-                        value = ''
-                else:
-                    value = ''
-                prefList.append(value)
-
-        self.prefList = prefList
-        self.updateParentAppPrefs()
-        self.prefsFactory.prefList = prefList
-        self.updateExample()
-            
-    
-    def scrollbar_visibility_change(self, widget, event):
-        if event.state == gdk.VISIBILITY_UNOBSCURED:
-            self.haveVerticalScrollbar = True
-            self.adjustScrollWindow.set_size_request(self.adjustScrollWindow.allocation.width + self.bump, -1)
+import preferencesdialog
+import prefsrapid
 
-            
-    def size_adjustment(self, widget, arg2):
-        """
-        Adjust scrolledwindow width in preferences dialog to reflect width of image rename table
-        
-        The algorithm is complicated by the need to take into account the presence of a vertical scrollbar,
-        which might be added as the user adds more rows
-        
-        The pygtk code behaves inconsistently depending on the pygtk version
-        """
-        
-        if self.adjustScrollWindow:
-            self.haveVerticalScrollbar = self.scrollBar.allocation.width > 1 or self.haveVerticalScrollbar
-            if not self.haveVerticalScrollbar:
-                if self.allocation.width > self.adjustScrollWindow.allocation.width:
-                    self.adjustScrollWindow.set_size_request(self.allocation.width, -1)
-            else:
-                if self.allocation.width > self.adjustScrollWindow.allocation.width - self.bump:
-                    self.adjustScrollWindow.set_size_request(self.allocation.width + self.bump, -1)
-                    self.bump = 0
-       
-    def getParentAppPrefs(self):
-        self.prefList = self.parentApp.prefs.image_rename
-        
-    
-    def getPrefsFactory(self):
-        self.prefsFactory = rn.ImageRenamePreferences(self.prefList, self,  
-              sequences = sequences)
-        
-    def updateParentAppPrefs(self):
-        self.parentApp.prefs.image_rename = self.prefList
-        
-    def updateExampleJobCode(self):
-        job_code = self.parentApp.prefs.getSampleJobCode()
-        if not job_code:
-            job_code = _('Job code')
-        self.prefsFactory.setJobCode(job_code)
-        
-    def updateExample(self):
-        self.parentApp.updateImageRenameExample()
-    
-    def getDefaultRow(self):
-        return self.prefsFactory.getDefaultRow()
-        
-    def on_combobox_changed(self, widget, rowPosition):
-        
-        for col in range(self.pm_noColumns):
-            if self.pm_rows[rowPosition][col] == widget:
-                break
-        selection = []
-        for i in range(col + 1):
-            # ensure it is a combo box we are getting the value from
-            w = self.pm_rows[rowPosition][i]
-            name = w.get_name()
-            if name == 'GtkComboBox':
-                selection.append(w.get_active_text())
-            else:
-                selection.append(w.get_text())
-                
-        for i in range(col + 1, self.pm_noColumns):
-            selection.append('')
-            
-        if col <> (self.pm_noColumns - 1):
-            widgets = self.prefsFactory.getWidgetsBasedOnUserSelection(selection)
-            
-            for i in range(col + 1, self.pm_noColumns):
-                oldWidget = self.pm_rows[rowPosition][i]
-                if oldWidget:
-                    self.remove(oldWidget)
-                    if oldWidget in self.pm_callbacks:
-                        del self.pm_callbacks[oldWidget]
-                newWidget = widgets[i]
-                self.pm_rows[rowPosition][i] = newWidget
-                if newWidget:
-                    self._createCallback(newWidget, rowPosition)
-                    self.attach(newWidget, i, i+1, rowPosition, rowPosition + 1)
-                    newWidget.show()
-        self.updatePreferences()
-
-        
-    def on_entry_changed(self, widget, rowPosition):
-        self.updatePreferences()
-
-    def on_rowAdded(self, rowPosition):
-        """
-        Update preferences, as a row has been added
-        """
-        self.updatePreferences()
-        
-        # if this was the last row or 2nd to last row, and another has just been added, move vertical scrollbar down
-        if rowPosition in range(self.pm_noRows - 3,  self.pm_noRows - 2):
-            adjustment = self.parentApp.rename_scrolledwindow.get_vadjustment()
-            adjustment.set_value(adjustment.upper)
-        
-
-    def on_rowDeleted(self, rowPosition):
-        """
-        Update preferences, as a row has been deleted
-        """
-        self.updatePreferences()        
-
-class VideoRenameTable(ImageRenameTable):
-    def __init__(self, parentApp, adjustScollWindow):    
-        self.errorTitle = _("Error in Video Rename preferences")
-        ImageRenameTable.__init__(self,  parentApp,  adjustScollWindow)
-
-    def getParentAppPrefs(self):
-        self.prefList = self.parentApp.prefs.video_rename
-    
-    def getPrefsFactory(self):
-        self.prefsFactory = rn.VideoRenamePreferences(self.prefList, self,
-                                                    sequences = sequences)
-        
-    def updateParentAppPrefs(self):
-        self.parentApp.prefs.video_rename = self.prefList
-
-    def updateExample(self):
-        self.parentApp.updateVideoRenameExample()
+import tableplusminus as tpm
+import generatename as gn
 
-class SubfolderTable(ImageRenameTable):
-    def __init__(self, parentApp, adjustScollWindow):    
-        self.errorTitle = _("Error in Photo Download Subfolders preferences")
-        ImageRenameTable.__init__(self, parentApp, adjustScollWindow)
+from metadatavideo import DOWNLOAD_VIDEO
+import metadataphoto
+import metadatavideo
 
-    def getParentAppPrefs(self):
-        self.prefList = self.parentApp.prefs.subfolder
-    
-    def getPrefsFactory(self):
-        self.prefsFactory = rn.SubfolderPreferences(self.prefList, self)
-        
-    def updateParentAppPrefs(self):
-        self.parentApp.prefs.subfolder = self.prefList
+import scan as scan_process
+import copyfiles
+import subfolderfile
 
-    def updateExample(self):
-        self.parentApp.updatePhotoDownloadFolderExample()
-        
-class VideoSubfolderTable(ImageRenameTable):
-    def __init__(self, parentApp, adjustScollWindow): 
-        self.errorTitle = _("Error in Video Download Subfolders preferences")
-        ImageRenameTable.__init__(self, parentApp, adjustScollWindow)
+import device as dv
+import utilities
 
-    def getParentAppPrefs(self):
-        self.prefList = self.parentApp.prefs.video_subfolder
-    
-    def getPrefsFactory(self):
-        self.prefsFactory = rn.VideoSubfolderPreferences(self.prefList, self)
-        
-    def updateParentAppPrefs(self):
-        self.parentApp.prefs.video_subfolder = self.prefList
-
-    def updateExample(self):
-        self.parentApp.updateVideoDownloadFolderExample()        
-
-class PreferencesDialog(gnomeglade.Component):
-    def __init__(self, parentApp):
-        gnomeglade.Component.__init__(self, 
-                                    paths.share_dir(config.GLADE_FILE), 
-                                    "preferencesdialog")
-        
-        self.widget.set_transient_for(parentApp.widget)
-        self.prefs = parentApp.prefs
-        
-        parentApp.preferencesDialogDisplayed = True
-        
-        self.parentApp = parentApp
+import config
+__version__ = config.version
 
-        self._setupTabSelector()
-        
-        self._setupControlSpacing()
-        
-        if DOWNLOAD_VIDEO:
-            self.file_types = _("photos and videos")
-        else:
-            self.file_types = _("photos")
+import paths
 
-        # get example photo and video data
-        try:
-            w = workers.firstWorkerReadyToDownload()
-            mediaFile = w.firstImage() 
-            self.sampleImageName = mediaFile.name
-            # assume the metadata is already read
-            self.sampleImage = mediaFile.metadata
-        except:
-            self.sampleImage = metadata.DummyMetaData()
-            self.sampleImageName = 'IMG_0524.CR2'
-            
-        try:
-            mediaFile = w.firstVideo()
-            self.sampleVideoName = mediaFile.name
-            self.sampleVideo = mediaFile.metadata
-            self.videoFallBackDate = mediaFile.modificationTime
-        except:
-            self.sampleVideo = videometadata.DummyMetaData()
-            self.sampleVideoName = 'MVI_1379.MOV'
-            self.videoFallBackDate = datetime.datetime.now()
-            
-        
-        # setup tabs
-        self._setupPhotoDownloadFolderTab()
-        self._setupImageRenameTab()
-        self._setupVideoDownloadFolderTab()
-        self._setupVideoRenameTab()                
-        self._setupRenameOptionsTab()
-        self._setupJobCodeTab()
-        self._setupDeviceTab()
-        self._setupBackupTab()
-        self._setupAutomationTab()
-        self._setupErrorTab()
-        
-        if not DOWNLOAD_VIDEO:
-            self.disableVideoControls()
-
-        self.widget.realize()
-        
-        #set the width of the left column for selecting values
-        #note: this must be called after self.widget.realize(), or else the width calculation will fail
-        width_of_widest_sel_row = self.treeview.get_background_area(1, self.treeview_column)[2]
-        self.scrolled_window.set_size_request(width_of_widest_sel_row + 2, -1)
-
-        #set the minimum width of the scolled window holding the photo rename table
-        if self.rename_scrolledwindow.get_vscrollbar():
-            extra = self.rename_scrolledwindow.get_vscrollbar().allocation.width + 10
-        else:
-            extra = 10
-        self.rename_scrolledwindow.set_size_request(self.rename_table.allocation.width + extra,   -1)
-
-        self.widget.show()
-
-    def on_preferencesdialog_destroy(self,  widget):
-        """ Delete variables from memory that cause a file descriptor to be created on a mounted media"""
-        del self.sampleImage,  self.rename_table.prefsFactory,  self.subfolder_table.prefsFactory
-        
-    def _setupTabSelector(self):
-        self.notebook.set_show_tabs(0)
-        self.model = gtk.ListStore(type(""))
-        column = gtk.TreeViewColumn()
-        rentext = gtk.CellRendererText()
-        column.pack_start(rentext, expand=0)
-        column.set_attributes(rentext, text=0)
-        self.treeview_column = column
-        self.treeview.append_column(column)
-        self.treeview.props.model = self.model
-        for c in self.notebook.get_children():
-            label = self.notebook.get_tab_label(c).get_text()
-            if not label.startswith("_"):
-                self.model.append( (label,) )
-        
-
-        # select the first value in the list store
-        self.treeview.set_cursor(0,column)
-    
-    def on_download_folder_filechooser_button_selection_changed(self, widget):
-        self.prefs.download_folder = widget.get_current_folder()
-        self.updatePhotoDownloadFolderExample()
-        
-    def on_video_download_folder_filechooser_button_selection_changed(self, widget):
-        self.prefs.video_download_folder = widget.get_current_folder()
-        self.updateVideoDownloadFolderExample()
-    
-    def on_backup_folder_filechooser_button_selection_changed(self, widget):
-        self.prefs.backup_location = widget.get_current_folder()
-        self.updateBackupExample()
-        
-    def on_device_location_filechooser_button_selection_changed(self, widget):
-        self.prefs.device_location = widget.get_current_folder()
-        
-    def _setupControlSpacing(self):
-        """
-        set spacing of some but not all controls
-        """
-        
-        self._setupTableSpacing(self.download_folder_table) 
-        self._setupTableSpacing(self.video_download_folder_table) 
-        self.download_folder_table.set_row_spacing(2, 
-                                hd.VERTICAL_CONTROL_SPACE)
-        self.video_download_folder_table.set_row_spacing(2, 
-                                hd.VERTICAL_CONTROL_SPACE)
-        self._setupTableSpacing(self.rename_example_table)
-        self._setupTableSpacing(self.video_rename_example_table)
-        self.devices_table.set_col_spacing(0, hd.NESTED_CONTROLS_SPACE)        
-      
-        self._setupTableSpacing(self.backup_table)
-        self.backup_table.set_col_spacing(1, hd.NESTED_CONTROLS_SPACE)
-        self.backup_table.set_col_spacing(2, hd.CONTROL_LABEL_SPACE)
-        self._setupTableSpacing(self.compatibility_table)
-        self.compatibility_table.set_row_spacing(0, 
-                                            hd.VERTICAL_CONTROL_LABEL_SPACE)                                                    
-        self._setupTableSpacing(self.error_table)
-    
-    
-    def _setupTableSpacing(self, table):
-        table.set_col_spacing(0, hd.NESTED_CONTROLS_SPACE)
-        table.set_col_spacing(1, hd.CONTROL_LABEL_SPACE)
-
-    def _setupSubfolderTable(self):
-        self.subfolder_table = SubfolderTable(self, None)
-        self.subfolder_vbox.pack_start(self.subfolder_table)
-        self.subfolder_table.show_all()
-        
-    def _setupVideoSubfolderTable(self):
-        self.video_subfolder_table = VideoSubfolderTable(self, None)
-        self.video_subfolder_vbox.pack_start(self.video_subfolder_table)
-        self.video_subfolder_table.show_all()
-
-    def _setupPhotoDownloadFolderTab(self):
-        self.download_folder_filechooser_button = gtk.FileChooserButton(
-                            _("Select a folder to download photos to"))
-        self.download_folder_filechooser_button.set_current_folder(
-                            self.prefs.download_folder)
-        self.download_folder_filechooser_button.set_action(
-                            gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
-        self.download_folder_filechooser_button.connect("selection-changed", 
-                    self.on_download_folder_filechooser_button_selection_changed)
-                            
-        self.download_folder_table.attach(
-                            self.download_folder_filechooser_button, 
-                            2, 3, 2, 3, yoptions = gtk.SHRINK)
-        self.download_folder_filechooser_button.show()        
-
-        self._setupSubfolderTable()
-        self.updatePhotoDownloadFolderExample()
-        
-    def _setupVideoDownloadFolderTab(self):
-        self.video_download_folder_filechooser_button = gtk.FileChooserButton(
-                            _("Select a folder to download videos to"))
-        self.video_download_folder_filechooser_button.set_current_folder(
-                            self.prefs.video_download_folder)
-        self.video_download_folder_filechooser_button.set_action(
-                            gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
-        self.video_download_folder_filechooser_button.connect("selection-changed", 
-                    self.on_video_download_folder_filechooser_button_selection_changed)
-                            
-        self.video_download_folder_table.attach(
-                            self.video_download_folder_filechooser_button, 
-                            2, 3, 2, 3, yoptions = gtk.SHRINK)
-        self.video_download_folder_filechooser_button.show()        
-        self._setupVideoSubfolderTable()
-        self.updateVideoDownloadFolderExample()        
-    
-    def _setupImageRenameTab(self):
+import gettext
+gettext.bindtextdomain(config.APP_NAME)
+gettext.textdomain(config.APP_NAME)
 
-        self.rename_table = ImageRenameTable(self, self.rename_scrolledwindow)
-        self.rename_table_vbox.pack_start(self.rename_table)
-        self.rename_table.show_all()
-        self.original_name_label.set_markup("<i>%s</i>" % self.sampleImageName)
-        self.updateImageRenameExample()
-        
-    def _setupVideoRenameTab(self):
+from gettext import gettext as _
 
-        self.video_rename_table = VideoRenameTable(self, self.video_rename_scrolledwindow)
-        self.video_rename_table_vbox.pack_start(self.video_rename_table)
-        self.video_rename_table.show_all()
-        self.video_original_name_label.set_markup("<i>%s</i>" % self.sampleVideoName)
-        self.updateVideoRenameExample()
-                
-    def _setupRenameOptionsTab(self):
-        
-        # sequence numbers
-        self.downloads_today_entry = ValidatedEntry.ValidatedEntry(ValidatedEntry.bounded(ValidatedEntry.v_int, int, 0))
-        self.stored_number_entry = ValidatedEntry.ValidatedEntry(ValidatedEntry.bounded(ValidatedEntry.v_int, int, 1))
-        self.downloads_today_entry.connect('changed', self.on_downloads_today_entry_changed)
-        self.stored_number_entry.connect('changed', self.on_stored_number_entry_changed)
-        v = self.prefs.getAndMaybeResetDownloadsToday()
-        self.downloads_today_entry.set_text(str(v))
-        # make the displayed value of stored sequence no 1 more than actual value
-        # so as not to confuse the user
-        self.stored_number_entry.set_text(str(self.prefs.stored_sequence_no+1))
-        self.sequence_vbox.pack_start(self.downloads_today_entry, expand=True, fill=True)
-        self.sequence_vbox.pack_start(self.stored_number_entry, expand=False)
-        self.downloads_today_entry.show()
-        self.stored_number_entry.show()
-        hour, minute = self.prefs.getDayStart()
-        self.hour_spinbutton.set_value(float(hour))
-        self.minute_spinbutton.set_value(float(minute))
-
-        self.synchronize_raw_jpg_checkbutton.set_active(
-                            self.prefs.synchronize_raw_jpg)
-        
-        #compatibility
-        self.strip_characters_checkbutton.set_active(
-                            self.prefs.strip_characters)
-        
-    def _setupJobCodeTab(self):
-        self.job_code_liststore = gtk.ListStore(str)
-        column = gtk.TreeViewColumn()
-        rentext = gtk.CellRendererText()
-        rentext.connect('edited', self.on_job_code_edited)
-        rentext .set_property('editable', True)
-
-        column.pack_start(rentext, expand=0)
-        column.set_attributes(rentext, text=0)
-        self.job_code_treeview_column = column
-        self.job_code_treeview.append_column(column)
-        self.job_code_treeview.props.model = self.job_code_liststore
-        for code in self.prefs.job_codes:
-            self.job_code_liststore.append((code, ))
-            
-        # set multiple selections
-        self.job_code_treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
-        
-        self.remove_all_job_code_button.set_image(gtk.image_new_from_stock(
-                                                gtk.STOCK_CLEAR,
-                                                gtk.ICON_SIZE_BUTTON))  
-    def _setupDeviceTab(self):
-
-        self.device_location_filechooser_button = gtk.FileChooserButton(
-                            _("Select a folder containing %(file_types)s") % {'file_types':self.file_types})
-        self.device_location_filechooser_button.set_current_folder(
-                            self.prefs.device_location)
-        self.device_location_filechooser_button.set_action(
-                            gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
-                            
-        self.device_location_filechooser_button.connect("selection-changed", 
-                    self.on_device_location_filechooser_button_selection_changed)
-
-        self.devices2_table.attach(self.device_location_filechooser_button,
-                            1, 2, 1, 2, xoptions = gtk.EXPAND|gtk.FILL,  yoptions = gtk.SHRINK)
-        self.device_location_filechooser_button.show()
-        self.autodetect_device_checkbutton.set_active(
-                            self.prefs.device_autodetection)
-        self.autodetect_psd_checkbutton.set_active(
-                            self.prefs.device_autodetection_psd)
-                            
-        self.updateDeviceControls()
-        
-
-    def _setupBackupTab(self):
-        self.backup_folder_filechooser_button = gtk.FileChooserButton(
-                            _("Select a folder in which to backup %(file_types)s") % {'file_types':self.file_types})
-        self.backup_folder_filechooser_button.set_current_folder(
-                            self.prefs.backup_location)
-        self.backup_folder_filechooser_button.set_action(
-                            gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
-        self.backup_folder_filechooser_button.connect("selection-changed", 
-                    self.on_backup_folder_filechooser_button_selection_changed)
-        self.backup_table.attach(self.backup_folder_filechooser_button,
-                            3, 4, 8, 9, yoptions = gtk.SHRINK)
-        self.backup_folder_filechooser_button.show()
-        self.backup_identifier_entry.set_text(self.prefs.backup_identifier)
-        self.video_backup_identifier_entry.set_text(self.prefs.video_backup_identifier)
-        
-        #setup controls for manipulating sensitivity
-        self._backupControls0 = [self.auto_detect_backup_checkbutton]
-        self._backupControls1 = [self.backup_identifier_explanation_label,
-                                self.backup_identifier_label,
-                                self.backup_identifier_entry,
-                                self.example_backup_path_label,
-                                self.backup_example_label,]
-        self._backupControls2 = [self.backup_location_label,
-                                self.backup_folder_filechooser_button,
-                                self.backup_location_explanation_label]
-        self._backupControls = self._backupControls0 + self._backupControls1 + \
-                                self._backupControls2
-                                
-        self._backupVideoControls = [self.video_backup_identifier_label,
-                                self.video_backup_identifier_entry]
-        
-        #assign values to checkbuttons only when other controls
-        #have been setup, because their toggle signal is activated
-        #when a value is assigned
-        
-        self.backup_checkbutton.set_active(self.prefs.backup_images)
-        self.auto_detect_backup_checkbutton.set_active(
-                            self.prefs.backup_device_autodetection)
-        self.updateBackupControls()
-        self.updateBackupExample()
-    
-    def _setupAutomationTab(self):
-        self.auto_startup_checkbutton.set_active(
-                        self.prefs.auto_download_at_startup)
-        self.auto_insertion_checkbutton.set_active(
-                        self.prefs.auto_download_upon_device_insertion)
-        self.auto_unmount_checkbutton.set_active(
-                        self.prefs.auto_unmount)
-        self.auto_exit_checkbutton.set_active(
-                        self.prefs.auto_exit)
-        self.auto_delete_checkbutton.set_active(
-                        self.prefs.auto_delete)
-
-        
-    def _setupErrorTab(self):
-        if self.prefs.download_conflict_resolution == config.SKIP_DOWNLOAD:
-            self.skip_download_radiobutton.set_active(True)
-        else:
-            self.add_identifier_radiobutton.set_active(True)
-            
-        if self.prefs.backup_duplicate_overwrite:
-            self.backup_duplicate_overwrite_radiobutton.set_active(True)
-        else:
-            self.backup_duplicate_skip_radiobutton.set_active(True)
 
-    
-    def updateExampleFileName(self, display_table, rename_table, sample, sampleName, example_label, fallback_date = None):
-        problem = pn.Problem()
-        if hasattr(self, display_table):
-            rename_table.updateExampleJobCode()
-            rename_table.prefsFactory.initializeProblem(problem)
-            name = rename_table.prefsFactory.generateNameUsingPreferences(
-                    sample, sampleName,
-                    self.prefs.strip_characters, sequencesPreliminary=False, fallback_date=fallback_date)
-        else:
-            name = ''
-            
-        # since this is markup, escape it
-        text = "<i>%s</i>" % common.escape(name)
-        
-        if problem.has_problem():
-            text += "\n"
-            # Translators: please do not modify or leave out html formatting tags like <i> and <b>. These are used to format the text the users sees
-            text += _("<i><b>Warning:</b> There is insufficient metadata to fully generate the name. Please use other renaming options.</i>")
+from utilities import format_size_for_user
+from utilities import register_iconsets
 
-        example_label.set_markup(text)        
-    
-    def updateImageRenameExample(self):
-        """ 
-        Displays example image name to the user 
-        """
-        self.updateExampleFileName('rename_table', self.rename_table, self.sampleImage,  self.sampleImageName, self.new_name_label)
 
-        
-    def updateVideoRenameExample(self):
-        """
-        Displays example video name to the user
-        """
-        self.updateExampleFileName('video_rename_table', self.video_rename_table, self.sampleVideo,  self.sampleVideoName, self.video_new_name_label, self.videoFallBackDate)
-            
-    def updateDownloadFolderExample(self, display_table, subfolder_table, download_folder, sample, sampleName, example_download_path_label, subfolder_warning_label, fallback_date = None):
-        """ 
-        Displays example subfolder name(s) to the user 
-        """
-        
-        problem = pn.Problem()
-        if hasattr(self, display_table):
-            subfolder_table.updateExampleJobCode()
-            subfolder_table.prefsFactory.initializeProblem(problem)
-            path = subfolder_table.prefsFactory.generateNameUsingPreferences(
-                            sample, sampleName,
-                            self.prefs.strip_characters, fallback_date = fallback_date)
-        else:
-            path = ''
-        
-        text = os.path.join(download_folder, path)
-        # since this is markup, escape it
-        path = common.escape(text)
-        if problem.has_problem():
-            warning = _("<i><b>Warning:</b> There is insufficient metadata to fully generate subfolders. Please use other subfolder naming options.</i>" )
-        else:
-            warning = ""
-        # Translators: you should not modify or leave out the %s. This is a code used by the programming language python to insert a value that thes user will see
-        example_download_path_label.set_markup(_("<i>Example: %s</i>") % text)
-        subfolder_warning_label.set_markup(warning)
-        
-    def updatePhotoDownloadFolderExample(self):
-        if hasattr(self, 'subfolder_table'):
-            self.updateDownloadFolderExample('subfolder_table', self.subfolder_table, self.prefs.download_folder, self.sampleImage, self.sampleImageName, self.example_photo_download_path_label, self.photo_subfolder_warning_label)
-        
-    def updateVideoDownloadFolderExample(self):
-        if hasattr(self, 'video_subfolder_table'):
-            self.updateDownloadFolderExample('video_subfolder_table', self.video_subfolder_table, self.prefs.video_download_folder, self.sampleVideo, self.sampleVideoName, self.example_video_download_path_label, self.video_subfolder_warning_label, self.videoFallBackDate)
-        
-    def on_hour_spinbutton_value_changed(self, spinbutton):
-        hour = spinbutton.get_value_as_int()
-        minute = self.minute_spinbutton.get_value_as_int()
-        self.prefs.setDayStart(hour, minute)
-        self.on_downloads_today_entry_changed(self.downloads_today_entry)
-        
-    def on_minute_spinbutton_value_changed(self, spinbutton):
-        hour = self.hour_spinbutton.get_value_as_int()
-        minute = spinbutton.get_value_as_int()
-        self.prefs.setDayStart(hour, minute)
-        self.on_downloads_today_entry_changed(self.downloads_today_entry)
-
-    def on_downloads_today_entry_changed(self, entry):
-        # do not update value if a download is occurring - it will mess it up!
-        if workers.noDownloadingWorkers() <> 0:
-            cmd_line(_("Downloads today value not updated, as a download is currently occurring"))
-        else:            
-            v = entry.get_text()
-            try:
-                v = int(v)
-            except:
-                v = 0
-            if v < 0:
-                v = 0
-            self.prefs.resetDownloadsToday(v)
-            sequences.setDownloadsToday(v)
-            self.updateImageRenameExample()
-        
-    def on_stored_number_entry_changed(self, entry):
-        # do not update value if a download is occurring - it will mess it up!        
-        if workers.noDownloadingWorkers() <> 0:
-            cmd_line(_("Stored number value not updated, as a download is currently occurring"))
-        else:
-            v = entry.get_text()
-            try:
-                # the displayed value of stored sequence no 1 more than actual value
-                # so as not to confuse the user
-                v = int(v) - 1
-            except:
-                v = 0
-            if v < 0:
-                v = 0
-            self.prefs.stored_sequence_no = v
-            sequences.setStoredSequenceNo(v)
-            self.updateImageRenameExample()
-
-    def _updateSubfolderPrefOnError(self, newPrefList):
-        self.prefs.subfolder = newPrefList
-
-    def _updateVideoSubfolderPrefOnError(self, newPrefList):
-        self.prefs.video_subfolder = newPrefList
-        
-    
-    def checkSubfolderValuesValidOnExit(self, usersPrefList, updatePrefFunction, filetype, defaultPrefList):
-        """
-        Checks that the user has not entered in any inappropriate values
-        
-        If they have, filters out bad values and warns the user 
-        """
-        filtered,  prefList = rn.filterSubfolderPreferences(usersPrefList)
-        if filtered:
-            cmd_line(_("The %(filetype)s subfolder preferences had some unnecessary values removed.") % {'filetype': filetype})
-            if prefList:
-                updatePrefFunction(prefList)
-            else:
-                #Preferences list is now empty
-                msg = _("The %(filetype)s subfolder preferences entered are invalid and cannot be used.\nThey will be reset to their default values.") % {'filetype': filetype}
-                sys.stderr.write(msg + "\n")
-                misc.run_dialog(PROGRAM_NAME, msg)
-                updatePrefFunction(self.prefs.get_default(defaultPrefList))
-    
-    def on_response(self, dialog, arg):
-        if arg == gtk.RESPONSE_HELP:
-            webbrowser.open("http://www.damonlynch.net/rapid/documentation")
-        else:
-            # arg==gtk.RESPONSE_CLOSE, or the user hit the 'x' to close the window
-            self.prefs.backup_identifier = self.backup_identifier_entry.get_property("text")
-            self.prefs.video_backup_identifier = self.video_backup_identifier_entry.get_property("text")
-            
-            #check subfolder preferences for bad values
-            self.checkSubfolderValuesValidOnExit(self.prefs.subfolder, self._updateSubfolderPrefOnError, _("photo"), "subfolder")
-            self.checkSubfolderValuesValidOnExit(self.prefs.video_subfolder, self._updateVideoSubfolderPrefOnError, _("video"), "video_subfolder")
+from config import  STATUS_CANNOT_DOWNLOAD, STATUS_DOWNLOADED, \
+                    STATUS_DOWNLOADED_WITH_WARNING, \
+                    STATUS_DOWNLOAD_FAILED, \
+                    STATUS_DOWNLOAD_PENDING, \
+                    STATUS_BACKUP_PROBLEM, \
+                    STATUS_NOT_DOWNLOADED, \
+                    STATUS_DOWNLOAD_AND_BACKUP_FAILED, \
+                    STATUS_WARNING
                     
-            self.widget.destroy()
-            self.parentApp.preferencesDialogDisplayed = False
-            self.parentApp.postPreferenceChange()
-            
-
-
+DOWNLOADED = [STATUS_DOWNLOADED, STATUS_DOWNLOADED_WITH_WARNING, STATUS_BACKUP_PROBLEM]
 
-    def on_add_job_code_button_clicked(self,  button):
-        j = JobCodeDialog(self.widget,  self.prefs.job_codes,  None, self.add_job_code,  False, True, True)
-
-
-    def add_job_code(self,  dialog,  userChoseCode,  job_code,  autoStart, downloadSelected):
-        dialog.destroy()
-        if userChoseCode:
-            if job_code and job_code not in self.prefs.job_codes:
-                self.job_code_liststore.prepend((job_code,  ))
-                self.update_job_codes()
-                selection = self.job_code_treeview.get_selection()
-                selection.unselect_all()
-                selection.select_path((0, ))
-                #scroll to the top
-                adjustment = self.job_code_scrolledwindow.get_vadjustment()
-                adjustment.set_value(adjustment.lower)
-
-    def on_remove_job_code_button_clicked(self,  button):
-        """ remove selected job codes (can be multiple selection)"""
-        selection = self.job_code_treeview.get_selection()
-        model, selected = selection.get_selected_rows()
-        iters = [model.get_iter(path) for path in selected]
-        # only delete if a jobe code is selected
-        if iters:
-            no = len(iters)
-            path = None
-            for i in range(0, no):
-                iter = iters[i]
-                if i == no - 1:
-                    path = model.get_path(iter) 
-                model.remove(iter)
-            
-            # now that we removed the selection, play nice with 
-            # the user and select the next item
-            selection.select_path(path)
-            
-            #  if there was no selection that meant the user
-            # removed the last entry, so we try to select the 
-            # last item
-            if not selection.path_is_selected(path):
-                 row = path[0]-1
-                 # test case for empty lists
-                 if row >= 0:
-                    selection.select_path((row,))
-
-        self.update_job_codes()
-        self.updateImageRenameExample()
-        self.updateVideoRenameExample()
-        self.updatePhotoDownloadFolderExample()
-        self.updateVideoDownloadFolderExample()
-        
-    def on_remove_all_job_code_button_clicked(self,  button):
-        j = RemoveAllJobCodeDialog(self.widget,  self.remove_all_job_code)
-        
-    def remove_all_job_code(self, dialog, userSelected):
-        dialog.destroy()
-        if userSelected:
-            self.job_code_liststore.clear()
-            self.update_job_codes()
-            self.updateImageRenameExample()
-            self.updateVideoRenameExample()
-            self.updatePhotoDownloadFolderExample()
-            self.updateVideoDownloadFolderExample()
-        
-    def on_job_code_edited(self,  widget,  path,  new_text):
-        iter = self.job_code_liststore.get_iter(path)
-        self.job_code_liststore.set_value(iter,  0,  new_text)
-        self.update_job_codes()
-        self.updateImageRenameExample()
-        self.updateVideoRenameExample()
-        self.updatePhotoDownloadFolderExample()
-        self.updateVideoDownloadFolderExample()
-
-    def update_job_codes(self):
-        """ update preferences with list of job codes"""
-        job_codes = []
-        for row in self.job_code_liststore:
-            job_codes.append(row[0])
-        self.prefs.job_codes = job_codes
-        
-    def on_auto_startup_checkbutton_toggled(self, checkbutton):
-        self.prefs.auto_download_at_startup = checkbutton.get_active()
-        
-    def on_auto_insertion_checkbutton_toggled(self, checkbutton):
-        self.prefs.auto_download_upon_device_insertion = checkbutton.get_active()
-        
-    def on_auto_unmount_checkbutton_toggled(self, checkbutton):
-        self.prefs.auto_unmount = checkbutton.get_active()
-        
-
-    def on_auto_delete_checkbutton_toggled(self, checkbutton):
-        self.prefs.auto_delete = checkbutton.get_active()
-
-    def on_auto_exit_checkbutton_toggled(self, checkbutton):
-        self.prefs.auto_exit = checkbutton.get_active()
-        
-    def on_autodetect_device_checkbutton_toggled(self, checkbutton):
-        self.prefs.device_autodetection = checkbutton.get_active()
-        self.updateDeviceControls()
-
-    def on_autodetect_psd_checkbutton_toggled(self,  checkbutton):
-        self.prefs.device_autodetection_psd = checkbutton.get_active()
-        
-    def on_backup_duplicate_overwrite_radiobutton_toggled(self,  widget):
-        self.prefs.backup_duplicate_overwrite = widget.get_active()
-            
-    def on_backup_duplicate_skip_radiobutton_toggled(self,  widget):
-        self.prefs.backup_duplicate_overwrite = not widget.get_active()
-    
-    def on_treeview_cursor_changed(self, tree):
-        path, column = tree.get_cursor()
-        self.notebook.set_current_page(path[0])
-
-    def on_synchronize_raw_jpg_checkbutton_toggled(self, check_button):
-        self.prefs.synchronize_raw_jpg = check_button.get_active()
-        
-    def on_strip_characters_checkbutton_toggled(self, check_button):
-        self.prefs.strip_characters = check_button.get_active()
-        self.updateImageRenameExample()
-        self.updatePhotoDownloadFolderExample()
-        self.updateVideoDownloadFolderExample()
-        
-    def on_add_identifier_radiobutton_toggled(self, widget):
-        if widget.get_active():
-            self.prefs.download_conflict_resolution = config.ADD_UNIQUE_IDENTIFIER
-        else:
-            self.prefs.download_conflict_resolution = config.SKIP_DOWNLOAD
-            
-
-    def updateDeviceControls(self):
-        """
-        Sets sensitivity of image device controls
-        """
-        controls = [self.device_location_explanation_label,
-                    self.device_location_label,
-                    self.device_location_filechooser_button]
-
-        if self.prefs.device_autodetection:
-            for c in controls:
-                c.set_sensitive(False)
-            self.autodetect_psd_checkbutton.set_sensitive(True)
-            self.autodetect_image_devices_label.set_sensitive(True)
-        else:
-            for c in controls:
-                c.set_sensitive(True)
-            self.autodetect_psd_checkbutton.set_sensitive(False)
-            self.autodetect_image_devices_label.set_sensitive(False)
-    
-    def updateBackupControls(self):
-        """
-        Sets sensitivity of backup related widgets
-        """
-        
-        if not self.backup_checkbutton.get_active():
-            for c in self._backupControls + self._backupVideoControls:
-                c.set_sensitive(False)
-
-        else:
-            for c in self._backupControls0:
-                c.set_sensitive(True)
-            self.updateBackupControlsAuto()
-
-    def updateBackupControlsAuto(self):
-        """
-        Sets sensitivity of subset of backup related widgets
-        """
-
-        if self.auto_detect_backup_checkbutton.get_active():
-            for c in self._backupControls1:
-                c.set_sensitive(True)
-            for c in self._backupControls2:
-                c.set_sensitive(False)
-            for c in self._backupVideoControls:
-                c.set_sensitive(False)
-            if DOWNLOAD_VIDEO:
-                for c in self._backupVideoControls:
-                    c.set_sensitive(True)
-        else:
-            for c in self._backupControls1:
-                c.set_sensitive(False)
-            for c in self._backupControls2:
-                c.set_sensitive(True)
-            if DOWNLOAD_VIDEO:
-                for c in self._backupVideoControls:
-                    c.set_sensitive(False)                
-            
-    def disableVideoControls(self):
-        """
-        Disables video preferences if video downloading is disabled
-        (probably because the appropriate libraries to enable
-        video metadata extraction are not installed)
-        """        
-        controls = [self.example_video_filename_label, 
-                    self.original_video_filename_label,
-                    self.new_video_filename_label,
-                    self.video_new_name_label,
-                    self.video_original_name_label,
-                    self.video_rename_scrolledwindow,
-                    self.video_folders_hbox,
-                    self.video_backup_identifier_label,
-                    self.video_backup_identifier_entry
-                    ]
-        for c in controls:
-            c.set_sensitive(False)
-            
-        self.videos_cannot_be_downloaded_label.show()
-        self.folder_videos_cannot_be_downloaded_label.show()
-        self.folder_videos_cannot_be_downloaded_hbox.show()
-    
-    def on_auto_detect_backup_checkbutton_toggled(self, widget):
-        self.prefs.backup_device_autodetection = widget.get_active()
-        self.updateBackupControlsAuto()
-        
-    def on_backup_checkbutton_toggled(self, widget):
-        self.prefs.backup_images = self.backup_checkbutton.get_active()
-        self.updateBackupControls()
-
-    def on_backup_identifier_entry_changed(self, widget):
-        self.updateBackupExample()
-    
-    def on_video_backup_identifier_entry_changed(self, widget):
-        self.updateBackupExample()
-
-    def on_backup_scan_folder_on_entry_changed(self, widget):
-        self.updateBackupExample()        
-
-    def updateBackupExample(self):
-        # Translators: this value is used as an example device when automatic backup device detection is enabled. You should translate this.
-        drive1 = os.path.join(config.MEDIA_LOCATION, _("externaldrive1"))
-        # Translators: this value is used as an example device when automatic backup device detection is enabled. You should translate this.
-        drive2 = os.path.join(config.MEDIA_LOCATION, _("externaldrive2"))
-
-        path = os.path.join(drive1, self.backup_identifier_entry.get_text())
-        path2 = os.path.join(drive2, self.backup_identifier_entry.get_text())
-        path3 = os.path.join(drive2, self.video_backup_identifier_entry.get_text())
-        path = common.escape(path)
-        path2 = common.escape(path2)
-        path3 = common.escape(path3)
-        if DOWNLOAD_VIDEO:
-            example = "<i>%s</i>\n<i>%s</i>\n<i>%s</i>" % (path, path2, path3)
-        else:
-            example = "<i>%s</i>\n<i>%s</i>" % (path, path2)
-        self.example_backup_path_label.set_markup(example)
+#Translators: if neccessary, for guidance in how to translate this program, you may see http://damonlynch.net/translate.html 
+PROGRAM_NAME = _('Rapid Photo Downloader')
+__version__ = config.version
 
-        
-def file_types_by_number(noImages, noVideos):
-    """ 
-    returns a string to be displayed to the user that can be used
-    to show if a value refers to photos or videos or both, or just one
-    of each
-    """
-    if (noVideos > 0) and (noImages > 0):
-        v = _('photos and videos')
-    elif (noVideos == 0) and (noImages == 0):
-        v = _('photos or videos')
-    elif noVideos > 0:
-        if noVideos > 1:
-            v = _('videos')
-        else:
-            v = _('video')
-    else:
-        if noImages > 1:
-            v = _('photos')
-        else:
-            v = _('photo')
-    return v
-    
 def date_time_human_readable(date, with_line_break=True):
     if with_line_break:
         return _("%(date)s\n%(time)s") % {'date':date.strftime("%x"), 'time':date.strftime("%X")}
@@ -1588,1498 +120,19 @@ def date_time_subseconds_human_readable(date, subseconds):
              'second':date.strftime("%S"),
              'subsecond': subseconds}
 
-def generateSubfolderAndName(mediaFile, problem, subfolderPrefsFactory, 
-                            renamePrefsFactory, 
-                            nameUsesJobCode, subfolderUsesJobCode, 
-                            strip_characters, fallback_date):
-                                
-    subfolderPrefsFactory.initializeProblem(problem)
-    mediaFile.sampleSubfolder = subfolderPrefsFactory.generateNameUsingPreferences(
-                                mediaFile.metadata, mediaFile.name, 
-                                strip_characters, 
-                                fallback_date = fallback_date)
-
-    mediaFile.samplePath = os.path.join(mediaFile.downloadFolder, mediaFile.sampleSubfolder)
-    
-    renamePrefsFactory.initializeProblem(problem)
-    mediaFile.sampleName = renamePrefsFactory.generateNameUsingPreferences(
-                            mediaFile.metadata, mediaFile.name, strip_characters, 
-                            sequencesPreliminary=False,
-                            fallback_date = fallback_date)
-        
-    if not (mediaFile.sampleName or nameUsesJobCode) or not (mediaFile.sampleSubfolder or subfolderUsesJobCode):
-        if not (mediaFile.sampleName or nameUsesJobCode) and not (mediaFile.sampleSubfolder or subfolderUsesJobCode):
-            area = _("subfolder and filename")
-        elif not (mediaFile.sampleName or nameUsesJobCode):
-            area = _("filename")
-        else:
-            area = _("subfolder")
-        problem.add_problem(None, pn.ERROR_IN_NAME_GENERATION, {'filetype': mediaFile.displayNameCap, 'area': area})
-        problem.add_extra_detail(pn.NO_DATA_TO_NAME, {'filetype': area})
-        mediaFile.problem = problem
-        mediaFile.status = STATUS_CANNOT_DOWNLOAD
-    elif problem.has_problem():
-        mediaFile.problem = problem
-        mediaFile.status = STATUS_WARNING
-    else:
-        mediaFile.status = STATUS_NOT_DOWNLOADED
-
-def getGenericPhotoImage():
-    return gtk.gdk.pixbuf_new_from_file(paths.share_dir('glade3/photo.png'))
-    
-def getGenericVideoImage():
-    return gtk.gdk.pixbuf_new_from_file(paths.share_dir('glade3/video.png'))
-
-class NeedAJobCode():
-    """
-    Convenience class to check whether a job code is missing for a given
-    file type (photo or video)
-    """
-    def __init__(self, prefs):
-        self.imageRenameUsesJobCode = rn.usesJobCode(prefs.image_rename)
-        self.imageSubfolderUsesJobCode = rn.usesJobCode(prefs.subfolder)
-        self.videoRenameUsesJobCode = rn.usesJobCode(prefs.video_rename)
-        self.videoSubfolderUsesJobCode = rn.usesJobCode(prefs.video_subfolder)
-                
-    def needAJobCode(self, job_code, is_image):
-        if is_image:
-            return not job_code and (self.imageRenameUsesJobCode or self.imageSubfolderUsesJobCode)
-        else:
-            return not job_code and (self.videoRenameUsesJobCode or self.videoSubfolderUsesJobCode)
-        
-
-class CopyPhotos(Thread):
-    """Copies photos from source to destination, backing up if needed"""
-    def __init__(self, thread_id, parentApp, fileRenameLock,  fileSequenceLock, 
-                statsLock,  downloadedFilesLock,
-                downloadStats, autoStart = False, cardMedia = None):
-        self.parentApp = parentApp
-        self.thread_id = thread_id
-        self.ctrl = True
-        self.running = False
-        self.manuallyDisabled = False
-        # enable the capacity to block oneself with a lock
-        # the lock will be first set when the thread begins
-        # it will then be locked when the thread needs to be paused
-        # releasing it will cause the code to restart from where it 
-        # left off
-        self.lock = Lock()
-        
-        self.fileRenameLock = fileRenameLock
-        self.fileSequenceLock = fileSequenceLock
-        self.statsLock = statsLock
-        self.downloadedFilesLock = downloadedFilesLock
-        
-        self.downloadStats = downloadStats
-        
-        self.hasStarted = False
-        self.doNotStart = False
-        self.waitingForJobCode = False
-        
-        self.autoStart = autoStart
-        self.cardMedia = cardMedia
-        
-        self.initializeDisplay(thread_id, self.cardMedia)
-               
-        self.scanComplete = self.downloadStarted = self.downloadComplete = False
-        
-        # Need to account for situations where the user adjusts their preferences when the program is scanning
-        # Here the sample filenames and paths will be out of date, and they will need to be updated
-        # This flag indicates whether that is the case or not
-        self.scanResultsStale = False # name and subfolder
-        self.scanResultsStaleDownloadFolder = False #download folder only
-        
-        self.noErrors = self.noWarnings = 0
-        self.videoTempWorkingDir = self.photoTempWorkingDir = ''
-        
-        if DOWNLOAD_VIDEO:
-            self.types_searched_for = _('photos or videos')
-        else:
-            self.types_searched_for = _('photos')            
-        
-        Thread.__init__(self)
-        
-
-    def initializeDisplay(self, thread_id, cardMedia = None):
-
-        if self.cardMedia:
-            media_collection_treeview.addCard(thread_id, self.cardMedia.prettyName(), 
-                                                                '', progress=0.0,  
-                                                                # This refers to when a device like a hard drive is having its contents scanned,
-                                                                # looking for photos or videos. It is visible initially in the progress bar for each device 
-                                                                # (which normally holds "x photos and videos").
-                                                                # It maybe displayed only briefly if the contents of the device being scanned is small.
-                                                                progressBarText=_('scanning...'))
-
-    def firstImage(self):
-        """
-        returns class mediaFile of the first photo
-        """
-        mediaFile = self.cardMedia.firstImage()
-        return mediaFile
-
-    def firstVideo(self):
-        """
-        returns class mediaFile of the first video
-        """
-        mediaFile = self.cardMedia.firstVideo()
-        return mediaFile
-                        
-    def handlePreferencesError(self,  e,  prefsFactory):
-            sys.stderr.write(_("Sorry,these preferences contain an error:\n"))
-            sys.stderr.write(prefsFactory.formatPreferencesForPrettyPrint() + "\n")
-            msg = str(e)
-            sys.stderr.write(msg + "\n")
-        
-    def initializeFromPrefs(self, notifyOnError):
-        """
-        Setup thread so that user preferences are handled
-        """
-        
-        def checkPrefs(prefsFactory):
-            try:
-                prefsFactory.checkPrefsForValidity()
-            except (rn.PrefValueInvalidError, rn.PrefLengthError, 
-                    rn.PrefValueKeyComboError, rn.PrefKeyError), e:
-                if notifyOnError:
-                    self.handlePreferencesError(e, prefsFactory)
-                raise rn.PrefError
-                
-        self.prefs = self.parentApp.prefs
-        
-        #Image and Video filename preferences
-        sample_download_start_time = datetime.datetime.now()
-
-        self.imageRenamePrefsFactory = rn.ImageRenamePreferences(self.prefs.image_rename, self, 
-                                                                 self.fileSequenceLock, sequences)
-        self.imageRenamePrefsFactory.setDownloadStartTime(sample_download_start_time)
-        checkPrefs(self.imageRenamePrefsFactory)
-           
-        self.videoRenamePrefsFactory = rn.VideoRenamePreferences(self.prefs.video_rename, self, 
-                                                                 self.fileSequenceLock, sequences)
-        self.videoRenamePrefsFactory.setDownloadStartTime(sample_download_start_time)
-        checkPrefs(self.videoRenamePrefsFactory)
-        
-        #Image and Video subfolder preferences
-
-        self.subfolderPrefsFactory = rn.SubfolderPreferences(self.prefs.subfolder, self)
-        self.subfolderPrefsFactory.setDownloadStartTime(sample_download_start_time)
-        checkPrefs(self.subfolderPrefsFactory)
-
-        self.videoSubfolderPrefsFactory = rn.VideoSubfolderPreferences(self.prefs.video_subfolder, self)
-        self.videoSubfolderPrefsFactory.setDownloadStartTime(sample_download_start_time)
-        checkPrefs(self.videoSubfolderPrefsFactory)
-        
-        # copy this variable, as it is used heavily in the loop
-        # and it is perhaps relatively expensive to read
-        self.stripCharacters = self.prefs.strip_characters
-
-    def run(self):
-        """
-        Copy photos from device to local drive, and if requested, backup
-        
-        1.  Should the image be downloaded?
-            1.a  generate file name 
-                1.a.1  generate sequence numbers if needed
-                1.a.2  FIFO queue sequence numbers to indicate that they could 
-                          potentially be used in a filename
-            1.b  check to see if a file exists with the same name in the place it will 
-                   be downloaded to
-            1.c if it exisits, and unique identifiers are not being used:
-                1.b.1  if using sequence numbers or letters, then potentially any of the 
-                          sequence numbers in the queue could be used to make the filename
-                    1.b.1.a  generate and check each filename using sequence numbers in the queue
-                    1.b.1.b  if one of these filenames is unique, then image needs to be downloaded
-                1.b.2  do not do not download
-
-        
-        2.  Download the image
-            2.a  copy it to temporary folder (this takes time)
-            2.b  is the file name still unique? Perhaps a new file was created with this name in the meantime
-                   (either by another thread or another program)
-                2.b.1  don't allow any other thread to rename a file
-                2.b.2  check file name
-                2.b.3  adding suffix if it is not unique, being careful not to overwrite any existing file with a suffix
-                2.b.4  rename it to the "real" name, effectively performing a mv
-                2.b.5  allow other threads to rename files
-        
-        3.  Backup the image, using the same filename as was used when it was downloaded
-            3.a  does a file with the same name already exist on the backup medium?
-            3.b  if so, user preferences determine whether it should be overwritten or not
-        """
-
-        def checkDownloadPath(path):
-            """
-            Checks to see if download folder exists.
-            
-            Creates it if it does not exist.
-            
-            Returns False if the path could not be created.
-            """
-            
-            try:
-                if not os.path.isdir(path):
-                    os.makedirs(path)
-                return True
-                    
-            except:
-                display_queue.put((media_collection_treeview.removeCard,  (self.thread_id, )))
-                msg = _("The following download path could not be created:\n")
-                msg += _("%(path)s: ") % {'path': path}
-                logError(config.CRITICAL_ERROR, _("Download cannot proceed"), msg)
-                cmd_line(_("Download cannot proceed"))
-                cmd_line(msg)
-                display_queue.put((self.parentApp.downloadFailed,  (self.thread_id, )))
-                display_queue.close("rw")                     
-                return False                
-                
-        def getPrefs(notifyOnError):
-            try:
-                self.initializeFromPrefs(notifyOnError)
-                return True
-            except rn.PrefError:
-                if notifyOnError:
-                    display_queue.put((media_collection_treeview.removeCard,  (self.thread_id, )))
-                    msg = _("There is an error in the program preferences.")
-                    msg += _("\nPlease check preferences, restart the program, and try again.")
-                    logError(config.CRITICAL_ERROR, _("Download cannot proceed"), msg)
-                    cmd_line(_("Download cannot proceed"))
-                    cmd_line(msg)
-                    display_queue.put((self.parentApp.downloadFailed,  (self.thread_id, )))
-                    display_queue.close("rw")                     
-                return False
-        
-
-                    
-        def scanMedia():
-            """
-            Scans media for photos and videos
-            """
-                       
-            # load images to display for when a thumbnail cannot be extracted or created
-            
-            self.photoThumbnail = getGenericPhotoImage()
-            self.videoThumbnail = getGenericVideoImage()
-                
-            imageRenameUsesJobCode = rn.usesJobCode(self.prefs.image_rename)
-            imageSubfolderUsesJobCode = rn.usesJobCode(self.prefs.subfolder)
-            videoRenameUsesJobCode = rn.usesJobCode(self.prefs.video_rename)
-            videoSubfolderUsesJobCode = rn.usesJobCode(self.prefs.video_subfolder)
-            
-            def loadFileMetadata(mediaFile):
-                """
-                loads the metadate for the file, and additional information if required
-                """
-                
-                problem = pn.Problem()
-                try:
-                    mediaFile.loadMetadata()
-                except:
-                    mediaFile.status = STATUS_CANNOT_DOWNLOAD
-                    mediaFile.metadata = None
-                    problem.add_problem(None, pn.CANNOT_DOWNLOAD_BAD_METADATA, {'filetype': mediaFile.displayNameCap})
-                    mediaFile.problem = problem
-                else:
-                    # generate sample filename and subfolder
-                    if mediaFile.isImage:
-                        fallback_date = None
-                        subfolderPrefsFactory = self.subfolderPrefsFactory
-                        renamePrefsFactory = self.imageRenamePrefsFactory
-                        nameUsesJobCode = imageRenameUsesJobCode
-                        subfolderUsesJobCode = imageSubfolderUsesJobCode                        
-                    else:
-                        fallback_date = mediaFile.modificationTime
-                        subfolderPrefsFactory = self.videoSubfolderPrefsFactory
-                        renamePrefsFactory = self.videoRenamePrefsFactory
-                        nameUsesJobCode = videoRenameUsesJobCode
-                        subfolderUsesJobCode = videoSubfolderUsesJobCode
-                        
-                    generateSubfolderAndName(mediaFile, problem, subfolderPrefsFactory, renamePrefsFactory, 
-                                            nameUsesJobCode, subfolderUsesJobCode, 
-                                            self.prefs.strip_characters, fallback_date)
-                    # generate thumbnail
-                    mediaFile.generateThumbnail(self.videoTempWorkingDir)
-                    
-                if mediaFile.thumbnail is None:
-                    addGenericThumbnail(mediaFile)
-
-            
-            def addGenericThumbnail(mediaFile):
-                """
-                Adds a generic thumbnail to the mediafile, which
-                can be very useful when previews are disabled
-                """
-                mediaFile.genericThumbnail = True
-                if mediaFile.isImage:
-                    mediaFile.thumbnail = self.photoThumbnail
-                else:
-                    mediaFile.thumbnail = self.videoThumbnail                
-            
-            def downloadable(name):
-                isImage = media.isImage(name)
-                isVideo = media.isVideo(name)
-                download = (DOWNLOAD_VIDEO and (isImage or isVideo) or 
-                        ((not DOWNLOAD_VIDEO) and isImage))
-                return (download, isImage, isVideo)
-                
-            def addFile(name, path, size, modificationTime, device, volume, isImage):
-                """
-                Add an image or video to the list of scanned files to be shown to the user for potential downloading
-                """
-
-                if isImage:
-                    downloadFolder = self.prefs.download_folder
-                else:
-                    downloadFolder = self.prefs.video_download_folder
-                    
-                mediaFile = media.MediaFile(self.thread_id, name, path, size, modificationTime, device, downloadFolder, volume, isImage)
-                loadFileMetadata(mediaFile)
-                # modificationTime is very useful for quick sorting
-                imagesAndVideos.append((mediaFile, modificationTime))
-                display_queue.put((self.parentApp.addFile, (mediaFile,)))
-                
-                if isImage:
-                    self.noImages += 1
-                else:
-                    self.noVideos += 1
-
-            
-            def gio_scan(path, fileSizeSum):
-                """recursive function to scan a directory and its subdirectories
-                for photos and possibly videos"""
-                
-                children = path.enumerate_children('standard::name,standard::type,standard::size,time::modified')
-
-                for child in children:
-                    if not self.running:
-                        self.lock.acquire()
-                        self.running = True
-                    
-                    if not self.ctrl:
-                        return None
-                        
-                    if child.get_file_type() == gio.FILE_TYPE_DIRECTORY:
-                        fileSizeSum = gio_scan(path.get_child(child.get_name()), fileSizeSum)
-                        if fileSizeSum == None:
-                            # this value will be None only if the thread is exiting
-                            return None
-                    elif child.get_file_type() == gio.FILE_TYPE_REGULAR:
-                        name = child.get_name()
-                        download, isImage, isVideo = downloadable(name)
-                        if download:
-                            size = child.get_size()
-                            modificationTime = child.get_modification_time()
-                            addFile(name, path.get_path(), size, modificationTime, self.cardMedia.prettyName(limit=0), self.cardMedia.volume, isImage)
-                            fileSizeSum += size
-
-                return fileSizeSum
-            
-                        
-            imagesAndVideos = []
-            fileSizeSum = 0
-            self.noVideos = 0
-            self.noImages = 0
-                        
-            if not using_gio or not self.cardMedia.volume:
-                for root, dirs, files in os.walk(self.cardMedia.getPath()):
-                    for name in files:
-                        if not self.running:
-                            self.lock.acquire()
-                            self.running = True
-                        
-                        if not self.ctrl:
-                            return None
-                        
-
-                        download, isImage, isVideo = downloadable(name)
-                        if download:
-                            fullFileName = os.path.join(root, name)
-                            size = os.path.getsize(fullFileName)
-                            modificationTime = os.path.getmtime(fullFileName)
-                            addFile(name, root, size, modificationTime, self.cardMedia.prettyName(limit=0), self.cardMedia.volume, isImage)
-                            fileSizeSum += size
-
-                            
-            else:
-                # using gio and have a volume
-                # make call to recursive function to scan volume
-                fileSizeSum = gio_scan(self.cardMedia.volume.volume.get_root(), fileSizeSum)
-                if fileSizeSum == None:
-                    # thread exiting
-                    return None
-                
-            # sort in place based on modification time
-            imagesAndVideos.sort(key=operator.itemgetter(1))
-            noFiles = len(imagesAndVideos)
-            
-            self.scanComplete = True
-            
-            self.display_file_types = file_types_by_number(self.noImages, self.noVideos)
-
-            
-            if noFiles:
-                self.cardMedia.setMedia(imagesAndVideos, fileSizeSum, noFiles)
-                # Translators: as already, mentioned the %s value should not be modified or left out. It may be moved if necessary.
-                # It refers to the actual number of photos that can be copied. For example, the user might see the following:
-                # '0 of 512 photos' or '0 of 10 videos' or '0 of 202 photos and videos'.
-                # This particular text is displayed to the user before the download has started.
-                display = _("%(number)s %(filetypes)s") % {'number':noFiles, 'filetypes':self.display_file_types}
-                display_queue.put((media_collection_treeview.updateCard, (self.thread_id,  self.cardMedia.sizeOfImagesAndVideos())))
-                display_queue.put((media_collection_treeview.updateProgress, (self.thread_id, 0.0, display, 0)))
-                display_queue.put((self.parentApp.setDownloadButtonSensitivity, ()))
-                
-                # Translators: as you have already seen, the text can contain values that should not be modified or left out by you, for example %s.
-                # This text is another example of that, but it is is a little more complex. Here there are two values which will be displayed
-                # to the user when they run the program, signifying the number of photos found, and the device they were found on.
-                # %(number)s should be left exactly as is: 'number' should not be translated. The same applies to %(device)s: 'device' should
-                # not be translated. Generally speaking, if translating the sentence requires it, you can move items like '%(xyz)s' around 
-                # in a sentence, but you should never modify them or leave them out.
-                cmd_line(_("Device scan complete: found %(number)s %(filetypes)s on %(device)s") % 
-                           {'number': noFiles, 'filetypes':self.display_file_types,
-                            'device': self.cardMedia.prettyName(limit=0)})
-                return True
-            else:
-                # it might be better to display "0 of 0" here
-                display_queue.put((media_collection_treeview.removeCard,  (self.thread_id, )))
-                cmd_line(_("Device scan complete: no %(filetypes)s found on %(device)s") % {'device':self.cardMedia.prettyName(limit=0), 'filetypes':self.types_searched_for})
-                return False
-            
-            
-        def logError(severity, problem, details, resolution=None):
-            display_queue.put((log_dialog.addMessage, (self.thread_id, severity, problem, details, 
-                            resolution)))
-            if severity == config.WARNING:
-                self.noWarnings += 1
-            else:
-                self.noErrors += 1
-
-        def notifyAndUnmount(umountAttemptOK):
-            if not self.cardMedia.volume:
-                unmountMessage = ""
-                notificationName = PROGRAM_NAME
-            else:
-                notificationName  = self.cardMedia.volume.get_name()
-                if self.prefs.auto_unmount and umountAttemptOK:
-                    self.cardMedia.volume.unmount(self.on_volume_unmount)
-                    # This message informs the user that the device (e.g. camera, hard drive or memory card) was automatically unmounted and they can now remove it
-                    unmountMessage = _("The device can now be safely removed")
-                else:
-                    unmountMessage = ""
-            
-            file_types = file_types_by_number(noImagesDownloaded, noVideosDownloaded)
-            file_types_skipped = file_types_by_number(noImagesSkipped, noVideosSkipped)
-            message = _("%(noFiles)s %(filetypes)s downloaded") % {'noFiles':noFilesDownloaded, 'filetypes': file_types}
-            noFilesSkipped = noImagesSkipped + noVideosSkipped
-            if noFilesSkipped:
-                message += "\n" + _("%(noFiles)s %(filetypes)s failed to download") % {'noFiles':noFilesSkipped, 'filetypes':file_types_skipped}
-            
-            if self.noWarnings:
-                message = "%s\n%s " % (message,  self.noWarnings) + _("warnings") 
-            if self.noErrors:
-                message = "%s\n%s " % (message,  self.noErrors) + _("errors")
-                
-            if unmountMessage:
-                message = "%s\n%s" % (message,  unmountMessage)                
-                
-            n = pynotify.Notification(notificationName,  message)
-            
-            if self.cardMedia.volume:
-                icon = self.cardMedia.volume.get_icon_pixbuf(self.parentApp.notification_icon_size)
-            else:
-                icon = self.parentApp.application_icon
-            
-            n.set_icon_from_pixbuf(icon)
-            n.show()            
-
-        def createTempDir(baseDir):
-            """
-            Create a temporary directory in which to download the photos to.
-            
-            Returns the directory if it was created, else returns None.
-            
-            Don't want to put it in system temp folder, as that is likely
-            to be on another partition and hence copying files from it
-            to the actual download folder will be slow!"""
-            try:
-                t = tempfile.mkdtemp(prefix='rapid-tmp-', 
-                                                dir=baseDir)
-                return t
-            except OSError, (errno, strerror):
-                if not self.cardMedia.volume:
-                    image_device = _("Source: %s\n") % self.cardMedia.getPath()
-                else:
-                    _("Device: %s\n") % self.cardMedia.volume.get_name()
-                destination = _("Destination: %s") % baseDir
-                logError(config.CRITICAL_ERROR, _('Could not create temporary download directory'), 
-                             image_device + destination,
-                            _("Download cannot proceed"))
-                cmd_line(_("Error:") + " " + _('Could not create temporary download directory'))
-                cmd_line(image_device + destination)
-                cmd_line(_("Download cannot proceed"))
-                display_queue.put((media_collection_treeview.removeCard,  (self.thread_id, )))
-                display_queue.put((self.parentApp.downloadFailed,  (self.thread_id, )))
-                display_queue.close("rw")
-                self.running = False
-                self.lock.release()
-                return None      
-            
-        def setupBackup():
-            """
-            Check for presence of backup path or volumes, and return the number of devices being used (1 in case of a path)
-            """
-            no_devices = 0
-            if self.prefs.backup_images:
-                no_devices = len(self.parentApp.backupVolumes)          
-                if not self.prefs.backup_device_autodetection:
-                    if not os.path.isdir(self.prefs.backup_location):
-                        # the user has manually specified a path, but it
-                        # does not exist. This is a problem.
-                        try:
-                            os.makedirs(self.prefs.backup_location)
-                        except:
-                            logError(config.SERIOUS_ERROR, _("Backup path does not exist"),
-                                        _("The path %s could not be created") % path, 
-                                        _("No backups can occur")
-                                    )
-                            no_devices = 0
-            return no_devices
-        
-        def checkIfNeedAJobCode():
-            needAJobCode = NeedAJobCode(self.prefs)
-            
-            for f in self.cardMedia.imagesAndVideos:
-                mediaFile = f[0]
-                if mediaFile.status in [STATUS_WARNING, STATUS_NOT_DOWNLOADED]:
-                    if needAJobCode.needAJobCode(mediaFile.jobcode, mediaFile.isImage):
-                        return True
-            return False
-            
-        def createBothTempDirs():
-            self.photoTempWorkingDir = createTempDir(photoBaseDownloadDir)
-            created = self.photoTempWorkingDir is not None
-            if created and DOWNLOAD_VIDEO:
-                self.videoTempWorkingDir = createTempDir(videoBaseDownloadDir)
-                created = self.videoTempWorkingDir is not None
-                
-            return created
-
-
-        def checkProblemWithNameGeneration(mediaFile):
-            if mediaFile.problem.has_problem():
-                logError(config.WARNING, 
-                    mediaFile.problem.get_title(),
-                    _("Source: %(source)s\nDestination: %(destination)s\n%(problem)s") % 
-                    {'source': mediaFile.fullFileName, 'destination': mediaFile.downloadFullFileName, 'problem': mediaFile.problem.get_problems()})
-                mediaFile.status = STATUS_DOWNLOADED_WITH_WARNING
-                    
-        def fileAlreadyExists(mediaFile, identifier=None):
-            """ Notify the user that the photo or video could not be downloaded because it already exists"""
-            
-            # get information on when the existing file was last modified
-            try:
-                modificationTime = os.path.getmtime(mediaFile.downloadFullFileName)
-                dt = datetime.datetime.fromtimestamp(modificationTime)
-                date = dt.strftime("%x")
-                time = dt.strftime("%X")
-            except:
-                sys.stderr.write("WARNING: could not determine the file modification time of an existing file\n")
-                date = time = ''
-                
-            if not identifier:
-                mediaFile.problem.add_problem(None, pn.FILE_ALREADY_EXISTS_NO_DOWNLOAD, {'filetype':mediaFile.displayNameCap})
-                mediaFile.problem.add_extra_detail(pn.EXISTING_FILE, {'filetype': mediaFile.displayName, 'date': date, 'time': time})
-                mediaFile.status = STATUS_DOWNLOAD_FAILED
-                log_status = config.SERIOUS_ERROR
-                problem_text = pn.extra_detail_definitions[pn.EXISTING_FILE] % {'date':date, 'time':time, 'filetype': mediaFile.displayName}
-            else:
-                mediaFile.problem.add_problem(None, pn.UNIQUE_IDENTIFIER_ADDED, {'filetype':mediaFile.displayNameCap})
-                mediaFile.problem.add_extra_detail(pn.UNIQUE_IDENTIFIER, {'identifier': identifier, 'filetype': mediaFile.displayName, 'date': date, 'time': time})
-                mediaFile.status = STATUS_DOWNLOADED_WITH_WARNING
-                log_status = config.WARNING
-                problem_text = pn.extra_detail_definitions[pn.UNIQUE_IDENTIFIER] % {'identifier': identifier, 'filetype': mediaFile.displayName, 'date': date, 'time': time}
-                
-            logError(log_status, mediaFile.problem.get_title(),
-                _("Source: %(source)s\nDestination: %(destination)s")
-                % {'source': mediaFile.fullFileName, 'destination': mediaFile.downloadFullFileName},
-                problem_text)
-
-        def downloadCopyingError(mediaFile, inst=None, errno=None, strerror=None):
-            """Notify the user that an error occurred (most likely at the OS / filesystem level) when coyping a photo or video"""
-            
-            if errno != None and strerror != None:
-                mediaFile.problem.add_problem(None, pn.DOWNLOAD_COPYING_ERROR_W_NO, {'filetype': mediaFile.displayName})
-                mediaFile.problem.add_extra_detail(pn.DOWNLOAD_COPYING_ERROR_W_NO_DETAIL, {'errorno': errno, 'strerror': strerror})
-
-            else:
-                mediaFile.problem.add_problem(None, pn.DOWNLOAD_COPYING_ERROR, {'filetype': mediaFile.displayName})
-                if not inst:
-                    # hopefully inst will never be None, but just to be safe...
-                    inst = _("Please check your system and try again.") 
-                mediaFile.problem.add_extra_detail(pn.DOWNLOAD_COPYING_ERROR_DETAIL, inst)
-
-            logError(config.SERIOUS_ERROR, mediaFile.problem.get_title(), mediaFile.problem.get_problems())
-            mediaFile.status = STATUS_DOWNLOAD_FAILED
-                
-        def sameNameDifferentExif(image_name, mediaFile):
-            """Notify the user that a file was already downloaded with the same name, but the exif information was different"""
-            i1_ext, i1_date_time, i1_subseconds = downloaded_files.extExifDateTime(image_name)
-            detail = {'image1': "%s%s" % (image_name, i1_ext), 
-                'image1_date': i1_date_time.strftime("%x"),
-                'image1_time': time_subseconds_human_readable(i1_date_time, i1_subseconds), 
-                'image2':      mediaFile.name, 
-                'image2_date': mediaFile.metadata.dateTime().strftime("%x"),
-                'image2_time': time_subseconds_human_readable(
-                                    mediaFile.metadata.dateTime(), 
-                                    mediaFile.metadata.subSeconds())}
-            mediaFile.problem.add_problem(None, pn.SAME_FILE_DIFFERENT_EXIF, detail)
-
-            msg = pn.problem_definitions[pn.SAME_FILE_DIFFERENT_EXIF][1] % detail
-            logError(config.WARNING,_('Photos detected with the same filenames, but taken at different times'), msg)
-            mediaFile.status = STATUS_DOWNLOADED_WITH_WARNING
-
-        def generateSubfolderAndFileName(mediaFile):
-            """
-            Generates subfolder and file names for photos and videos
-            """
-            
-            skipFile = alreadyDownloaded = False
-            sequence_to_use = None
-            
-            if mediaFile.isVideo:
-                fileRenameFactory = self.videoRenamePrefsFactory
-                subfolderFactory = self.videoSubfolderPrefsFactory
-            else:
-                # file is an photo
-                fileRenameFactory = self.imageRenamePrefsFactory                
-                subfolderFactory = self.subfolderPrefsFactory
-            
-            fileRenameFactory.setJobCode(mediaFile.jobcode)
-            subfolderFactory.setJobCode(mediaFile.jobcode)
-
-            mediaFile.problem = pn.Problem()
-            subfolderFactory.initializeProblem(mediaFile.problem)
-            fileRenameFactory.initializeProblem(mediaFile.problem)
-            
-            # Here we cannot assume that the subfolder value will contain something -- the user may have changed the preferences after the scan
-            mediaFile.downloadSubfolder = subfolderFactory.generateNameUsingPreferences(
-                                                    mediaFile.metadata, mediaFile.name, 
-                                                    self.stripCharacters, fallback_date = mediaFile.modificationTime)
-
-
-            if self.prefs.synchronize_raw_jpg and usesImageSequenceElements and mediaFile.isImage:
-                #synchronizing RAW and JPEG only applies to photos, not videos
-                image_name, image_ext = os.path.splitext(mediaFile.name)
-                with self.downloadedFilesLock:
-                    i, sequence_to_use = downloaded_files.matching_pair(image_name, image_ext, mediaFile.metadata.dateTime(), mediaFile.metadata.subSeconds())
-                    if i == -1:
-                        # this exact file has already been downloaded (same extension, same filename, and same exif date time subsecond info)
-                        if not addUniqueIdentifier:
-                            logError(config.SERIOUS_ERROR,_('Photo has already been downloaded'), 
-                                        _("Source: %(source)s") % {'source': mediaFile.fullFileName})
-                            mediaFile.problem.add_problem(None, pn.FILE_ALREADY_DOWNLOADED, {'filetype': mediaFile.displayNameCap})
-                            skipFile = True
-                            
-                
-            # pass the subfolder the image will go into, as this is needed to determine subfolder sequence numbers 
-            # indicate that sequences chosen should be queued
-            
-            if not skipFile:
-                mediaFile.downloadName = fileRenameFactory.generateNameUsingPreferences(
-                                                            mediaFile.metadata, mediaFile.name, self.stripCharacters,  mediaFile.downloadSubfolder,  
-                                                            sequencesPreliminary = True,
-                                                            sequence_to_use = sequence_to_use,
-                                                            fallback_date = mediaFile.modificationTime)
-
-                mediaFile.downloadPath = os.path.join(mediaFile.downloadFolder, mediaFile.downloadSubfolder)
-                mediaFile.downloadFullFileName = os.path.join(mediaFile.downloadPath, mediaFile.downloadName)
-                    
-                if not mediaFile.downloadName or not mediaFile.downloadSubfolder:
-                    if not mediaFile.downloadName and not mediaFile.downloadSubfolder:
-                        area = _("subfolder and filename")
-                    elif not mediaFile.downloadName:
-                        area = _("filename")
-                    else:
-                        area = _("subfolder")
-                    problem.add_problem(None, pn.ERROR_IN_NAME_GENERATION, {'filetype': mediaFile.displayNameCap, 'area': area})
-                    problem.add_extra_detail(pn.NO_DATA_TO_NAME, {'filetype': area})
-                    skipFile = True
-                    logError(config.SERIOUS_ERROR, pn.problem_definitions[ERROR_IN_NAME_GENERATION][1] % {'filetype': mediaFile.displayNameCap, 'area': area})
-            
-            if not skipFile:
-                checkProblemWithNameGeneration(mediaFile)
-            else:
-                self.sizeDownloaded += mediaFile.size * (no_backup_devices + 1)
-                mediaFile.status = STATUS_DOWNLOAD_FAILED
-                
-            return (skipFile, sequence_to_use)
-        
-        def progress_callback(amount_downloaded, total):
-            if (amount_downloaded - self.bytes_downloaded > 2097152) or (amount_downloaded == total):
-                chunk_downloaded = amount_downloaded - self.bytes_downloaded
-                self.bytes_downloaded = amount_downloaded
-                percentComplete = (float(self.sizeDownloaded + amount_downloaded) / sizeFiles) * 100
-
-                display_queue.put((media_collection_treeview.updateProgress, (self.thread_id, percentComplete, None, chunk_downloaded)))        
-        
-        def downloadFile(mediaFile, sequence_to_use):
-            """
-            Downloads the photo or video file to the specified subfolder 
-            """
-            
-            if not mediaFile.isImage:
-                renameFactory = self.videoRenamePrefsFactory
-            else:
-                renameFactory = self.imageRenamePrefsFactory
-            
-            def progress_callback_no_update(amount_downloaded, total):
-                pass
-                
-            try:
-                fileDownloaded = False
-                if not os.path.isdir(mediaFile.downloadPath):
-                    os.makedirs(mediaFile.downloadPath)
-                
-                nameUniqueBeforeCopy = True
-                downloadNonUniqueFile = True
-                
-                # do a preliminary check to see if a file with the same name already exists
-                if os.path.exists(mediaFile.downloadFullFileName):
-                    nameUniqueBeforeCopy = False
-                    if not addUniqueIdentifier:
-                        downloadNonUniqueFile = False
-                        if (usesVideoSequenceElements and not mediaFile.isImage) or (usesImageSequenceElements and mediaFile.isImage and not self.prefs.synchronize_raw_jpg):
-                            # potentially, a unique file name could still be generated
-                            # investigate this possibility
-                            with self.fileSequenceLock:
-                                for possibleName in renameFactory.generateNameSequencePossibilities(
-                                                        mediaFile.metadata, 
-                                                        mediaFile.name, self.stripCharacters, mediaFile.downloadSubfolder,
-                                                        fallback_date = mediaFile.modificationTime):
-                                    if possibleName:
-                                        # no need to check for any problems here, it's just a temporary name
-                                        possibleFile = os.path.join(mediaFile.downloadPath, possibleName)
-                                        possibleTempFile = os.path.join(tempWorkingDir, possibleName)
-                                        if not os.path.exists(possibleFile) and not os.path.exists(possibleTempFile):
-                                            downloadNonUniqueFile = True
-                                            break
-
-                                        
-                    if not downloadNonUniqueFile:
-                        fileAlreadyExists(mediaFile)
-
-                copy_succeeded = False
-                if nameUniqueBeforeCopy or downloadNonUniqueFile:
-                    tempWorkingfile = os.path.join(tempWorkingDir, mediaFile.downloadName)
-                    if using_gio:
-                        g_dest = gio.File(path=tempWorkingfile)
-                        g_src = gio.File(path=mediaFile.fullFileName)
-                        try:
-                            if not g_src.copy(g_dest, progress_callback, cancellable=gio.Cancellable()):
-                                downloadCopyingError(mediaFile)
-                            else:
-                                copy_succeeded = True
-                        except glib.GError, inst:
-                            downloadCopyingError(mediaFile, inst=inst)
-                    else:
-                        shutil.copy2(mediaFile.fullFileName, tempWorkingfile)
-                        copy_succeeded = True
-                    
-                    if copy_succeeded:
-                        with self.fileRenameLock:
-                            doRename = True
-                            if usesSequenceElements:
-                                with self.fileSequenceLock:
-                                    # get a filename and use this as the "real" filename
-                                    if sequence_to_use is None and self.prefs.synchronize_raw_jpg and mediaFile.isImage:
-                                        # must check again, just in case the matching pair has been downloaded in the meantime
-                                        image_name, image_ext = os.path.splitext(mediaFile.name)
-                                        with self.downloadedFilesLock:
-                                            i, sequence_to_use = downloaded_files.matching_pair(image_name, image_ext, mediaFile.metadata.dateTime(), mediaFile.metadata.subSeconds())
-                                            if i == -99:
-                                                sameNameDifferentExif(image_name, mediaFile)
-
-                                    mediaFile.downloadName = renameFactory.generateNameUsingPreferences(
-                                                                    mediaFile.metadata, mediaFile.name, self.stripCharacters, mediaFile.downloadSubfolder,  
-                                                                    sequencesPreliminary = False,
-                                                                    sequence_to_use = sequence_to_use,
-                                                                    fallback_date = mediaFile.modificationTime)
-                                                                    
-                                if not mediaFile.downloadName:
-                                    # there was a serious error generating the filename
-                                    doRename = False                            
-                                else:
-                                    mediaFile.downloadFullFileName = os.path.join(mediaFile.downloadPath, mediaFile.downloadName)
-                            # check if the file exists again
-                            if os.path.exists(mediaFile.downloadFullFileName):
-                                if not addUniqueIdentifier:
-                                    doRename = False
-                                    fileAlreadyExists(mediaFile)
-                                else:
-                                    # add  basic suffix to make the filename unique
-                                    name = os.path.splitext(mediaFile.downloadName)
-                                    suffixAlreadyUsed = True
-                                    while suffixAlreadyUsed:
-                                        if mediaFile.downloadFullFileName in duplicate_files:
-                                            duplicate_files[mediaFile.downloadFullFileName] +=  1
-                                        else:
-                                            duplicate_files[mediaFile.downloadFullFileName] = 1
-                                        identifier = '_%s' % duplicate_files[mediaFile.downloadFullFileName]
-                                        mediaFile.downloadName = name[0] + identifier + name[1]
-                                        possibleNewFile = os.path.join(mediaFile.downloadPath, mediaFile.downloadName)
-                                        suffixAlreadyUsed = os.path.exists(possibleNewFile)
-
-                                    fileAlreadyExists(mediaFile, identifier)
-                                    mediaFile.downloadFullFileName = possibleNewFile
-                                    
-
-                            if doRename:
-                                rename_succeeded = False
-                                if using_gio:
-                                    g_dest = gio.File(path=mediaFile.downloadFullFileName)
-                                    g_src = gio.File(path=tempWorkingfile)
-                                    try:
-                                        if not g_src.move(g_dest, progress_callback_no_update, cancellable=gio.Cancellable()):
-                                            downloadCopyingError(mediaFile)
-                                        else:
-                                            rename_succeeded = True
-                                    except glib.GError, inst:
-                                        downloadCopyingError(mediaFile, inst=inst)
-                                else:
-                                    os.rename(tempWorkingfile, mediaFile.downloadFullFileName)
-                                    rename_succeeded = True
-                                        
-                                if rename_succeeded:
-                                    fileDownloaded = True
-                                    if mediaFile.status != STATUS_DOWNLOADED_WITH_WARNING:
-                                        mediaFile.status = STATUS_DOWNLOADED
-                                    if usesImageSequenceElements:
-                                        if self.prefs.synchronize_raw_jpg and mediaFile.isImage:
-                                            name, ext = os.path.splitext(mediaFile.name)
-                                            if sequence_to_use is None:
-                                                with self.fileSequenceLock:
-                                                    seq = renameFactory.sequences.getFinalSequence()
-                                            else:
-                                                seq = sequence_to_use
-                                            with self.downloadedFilesLock:
-                                                downloaded_files.add_download(name, ext, mediaFile.metadata.dateTime(), mediaFile.metadata.subSeconds(), seq) 
-
-                                        
-                                        with self.fileSequenceLock:
-                                            if sequence_to_use is None:
-                                                renameFactory.sequences.imageCopySucceeded()
-                                                if usesStoredSequenceNo:
-                                                    self.prefs.stored_sequence_no += 1
-                                                
-                                    with self.fileSequenceLock:
-                                        if sequence_to_use is None:
-                                            if self.prefs.incrementDownloadsToday():
-                                                # A new day, according the user's preferences of what time a day begins, has started
-                                                cmd_line(_("New day has started - resetting 'Downloads Today' sequence number"))
-                                                
-                                                sequences.setDownloadsToday(0)
-                    
-            except (IOError, OSError), (errno, strerror):
-                downloadCopyingError(mediaFile, errno=errno, strerror=strerror)              
-            
-            if usesSequenceElements:
-                if not fileDownloaded and sequence_to_use is None:
-                    renameFactory.sequences.imageCopyFailed()
-            
-            #update record keeping using in tracking progress
-            self.sizeDownloaded += mediaFile.size
-            self.bytes_downloaded_in_download = self.bytes_downloaded
-            
-            return fileDownloaded
-            
-
-        def backupFile(mediaFile, fileDownloaded, no_backup_devices):
-            """ 
-            Backup photo or video to path(s) chosen by the user
-            
-            there are three scenarios: 
-            (1) file has just been downloaded and should now be backed up
-            (2) file was already downloaded on some previous occassion and should still be backed up, because it hasn't been yet
-            (3) file has been backed up already (or at least, a file with the same name already exists)
-            
-            A backup medium can be used to backup photos or videos, or both. 
-            """
-
-            backed_up = False
-            fileNotBackedUpMessageDisplayed = False
-            error_encountered = False
-            expected_bytes_downloaded = self.sizeDownloaded + no_backup_devices * mediaFile.size
-            
-            if no_backup_devices:
-                for rootBackupDir in self.parentApp.backupVolumes:
-                    self.bytes_downloaded = 0
-                    if self.prefs.backup_device_autodetection:
-                        volume = self.parentApp.backupVolumes[rootBackupDir].get_name()
-                        if mediaFile.isImage:
-                            backupDir = os.path.join(rootBackupDir, self.prefs.backup_identifier)
-                        else:
-                            backupDir = os.path.join(rootBackupDir, self.prefs.video_backup_identifier)
-                    else:
-                        # photos and videos will be backed up into the same root folder, which the user has manually specified
-                        backupDir = rootBackupDir
-                        volume = backupDir # os.path.split(backupDir)[1]
-                                                
-                    # if user has chosen auto detection, then:
-                    # photos should only be backed up to photo backup locations
-                    # videos should only be backed up to video backup locations
-                    # if user did not choose autodetection, and the backup path doesn't exist, then
-                    # will try to create it
-                    if os.path.isdir(backupDir) or not self.prefs.backup_device_autodetection:
-
-                        backupPath = os.path.join(backupDir, mediaFile.downloadSubfolder)
-                        newBackupFile = os.path.join(backupPath, mediaFile.downloadName)
-                        copyBackup = True
-                        if os.path.exists(newBackupFile):
-                            # this check is of course not thread safe -- it doesn't need to be, because at this stage the file names are going to be unique
-                            # (the folder structure is the same as the actual download folders, and the file names are unique in them)
-                            copyBackup = self.prefs.backup_duplicate_overwrite  
-                            
-                            if copyBackup:
-                                mediaFile.problem.add_problem(None, pn.BACKUP_EXISTS_OVERWRITTEN, volume)
-                            else:
-                                mediaFile.problem.add_problem(None, pn.BACKUP_EXISTS, volume)
-                            severity = config.SERIOUS_ERROR
-                            fileNotBackedUpMessageDisplayed = True
-
-                            title = _("Backup of %(file_type)s already exists") % {'file_type': mediaFile.displayName}
-                            details = _("Source: %(source)s\nDestination: %(destination)s") \
-                                    % {'source': mediaFile.fullFileName, 'destination': newBackupFile}
-                            if copyBackup:
-                                resolution = _("Backup %(file_type)s overwritten") % {'file_type': mediaFile.displayName}
-                            else:
-                                if self.prefs.backup_device_autodetection:
-                                    volume = self.parentApp.backupVolumes[rootBackupDir].get_name()
-                                    resolution = _("%(file_type)s not backed up to %(volume)s") % {'file_type': mediaFile.displayNameCap, 'volume': volume}
-                                else:
-                                    resolution = _("%(file_type)s not backed up") % {'file_type': mediaFile.displayNameCap}                                
-                            logError(severity, title, details, resolution)
-
-                        if copyBackup:
-                            if fileDownloaded:
-                                fileToCopy = mediaFile.downloadFullFileName
-                            else:
-                                fileToCopy = mediaFile.fullFileName
-                            if os.path.isdir(backupPath):
-                                pathExists = True
-                            else:
-                                pathExists = False
-                                # create the backup subfolders
-                                if using_gio:
-                                    dirs = gio.File(backupPath)
-                                    try:
-                                        if dirs.make_directory_with_parents(cancellable=gio.Cancellable()):
-                                            pathExists = True
-                                    except glib.GError, inst:
-                                        fileNotBackedUpMessageDisplayed = True
-                                        mediaFile.problem.add_problem(None, pn.BACKUP_DIRECTORY_CREATION, volume)
-                                        mediaFile.problem.add_extra_detail('%s%s' % (pn.BACKUP_DIRECTORY_CREATION, volume), inst)
-                                        error_encountered = True
-                                        logError(config.SERIOUS_ERROR, _('Backing up error'), 
-                                                 _("Destination directory could not be created: %(directory)s\n") %
-                                                 {'directory': backupPath,  } +
-                                                 _("Source: %(source)s\nDestination: %(destination)s") % 
-                                                 {'source': mediaFile.fullFileName, 'destination': newBackupFile} + "\n" +
-                                                 _("Error: %(inst)s") % {'inst': inst}, 
-                                                 _('The %(file_type)s was not backed up.') % {'file_type': mediaFile.displayName}
-                                                 )                                        
-                                else:
-                                    # recreate folder structure in backup location
-                                    # cannot do os.makedirs(backupPath) - it can give bad results when using external drives
-                                    # we know backupDir exists 
-                                    # all the components of subfolder may not
-                                    folders = mediaFile.downloadSubfolder.split(os.path.sep)
-                                    folderToMake = backupDir 
-                                    for f in folders:
-                                        if f:
-                                            folderToMake = os.path.join(folderToMake,  f)
-                                            if not os.path.isdir(folderToMake):
-                                                try:
-                                                    os.mkdir(folderToMake)
-                                                    pathExists = True
-                                                except (IOError, OSError), (errno, strerror):
-                                                    fileNotBackedUpMessageDisplayed = True
-                                                    inst = "%s: %s" % (errno, strerror)
-                                                    mediaFile.problem.add_problem(None, pn.BACKUP_DIRECTORY_CREATION, volume)
-                                                    mediaFile.problem.add_extra_detail('%s%s' % (pn.BACKUP_DIRECTORY_CREATION, volume), inst)
-                                                    error_encountered = True
-                                                    logError(config.SERIOUS_ERROR, _('Backing up error'), 
-                                                             _("Destination directory could not be created: %(directory)s\n") %
-                                                             {'directory': backupPath,  } +
-                                                             _("Source: %(source)s\nDestination: %(destination)s") % 
-                                                             {'source': mediaFile.fullFileName, 'destination': newBackupFile} + "\n" +
-                                                             _("Error: %(errno)s %(strerror)s") % {'errno': errno,  'strerror': strerror}, 
-                                                             _('The %(file_type)s was not backed up.') % {'file_type': mediaFile.displayName}
-                                                             )
-
-                                                    break
-                                        
-                            if pathExists:
-                                if using_gio:
-                                    g_dest = gio.File(path=newBackupFile)
-                                    g_src = gio.File(path=fileToCopy)
-                                    if self.prefs.backup_duplicate_overwrite:
-                                        flags = gio.FILE_COPY_OVERWRITE
-                                    else:
-                                        flags = gio.FILE_COPY_NONE
-                                    try:
-                                        if not g_src.copy(g_dest, progress_callback, flags, cancellable=gio.Cancellable()):
-                                            fileNotBackedUpMessageDisplayed = True
-                                            mediaFile.problem.add_problem(None, pn.BACKUP_ERROR, volume)
-                                            error_encountered = True
-                                        else:
-                                            backed_up = True
-                                            if mediaFile.status == STATUS_DOWNLOAD_FAILED:
-                                                mediaFile.problem.add_problem(None, pn.NO_DOWNLOAD_WAS_BACKED_UP, volume)
-                                    except glib.GError, inst:
-                                        fileNotBackedUpMessageDisplayed = True
-                                        mediaFile.problem.add_problem(None, pn.BACKUP_ERROR, volume)
-                                        mediaFile.problem.add_extra_detail('%s%s' % (pn.BACKUP_ERROR, volume), inst)
-                                        error_encountered = True
-                                        logError(config.SERIOUS_ERROR, _('Backing up error'), 
-                                                _("Source: %(source)s\nDestination: %(destination)s") %
-                                                 {'source': fileToCopy, 'destination': newBackupFile} + "\n" +
-                                                _("Error: %(inst)s") % {'inst': inst},
-                                                _('The %(file_type)s was not backed up.')  % {'file_type': mediaFile.displayName}
-                                            )
-                                else:
-                                    try:
-                                        shutil.copy2(fileToCopy, newBackupFile)
-                                        backed_up = True
-                                        if mediaFile.status == STATUS_DOWNLOAD_FAILED:
-                                            mediaFile.problem.add_problem(None, pn.NO_DOWNLOAD_WAS_BACKED_UP, volume)
-                                        
-                                    except (IOError, OSError), (errno, strerror):
-                                        fileNotBackedUpMessageDisplayed = True
-                                        mediaFile.problem.add_problem(None, pn.BACKUP_ERROR, volume)
-                                        inst = "%s: %s" % (errno, strerror)
-                                        mediaFile.problem.add_extra_detail('%s%s' % (pn.BACKUP_ERROR, volume), inst)
-                                        error_encountered = True
-                                        logError(config.SERIOUS_ERROR, _('Backing up error'), 
-                                                _("Source: %(source)s\nDestination: %(destination)s") % 
-                                                 {'source': fileToCopy, 'destination': newBackupFile} + "\n" +
-                                                _("Error: %(errno)s %(strerror)s") % {'errno': errno,  'strerror': strerror},
-                                                _('The %(file_type)s was not backed up.')  % {'file_type': mediaFile.displayName}
-                                            )
-                    
-                    #update record keeping using in tracking progress
-                    self.sizeDownloaded += mediaFile.size
-                    self.bytes_downloaded_in_backup += self.bytes_downloaded
-
-            if not backed_up and not fileNotBackedUpMessageDisplayed:
-                # The file has not been backed up to any medium
-                mediaFile.problem.add_problem(None, pn.NO_BACKUP_PERFORMED, {'filetype': mediaFile.displayNameCap})
-
-                severity = config.SERIOUS_ERROR
-                problem = _("%(file_type)s could not be backed up") % {'file_type': mediaFile.displayName}
-                details = _("Source: %(source)s") % {'source': mediaFile.fullFileName}
-                if self.prefs.backup_device_autodetection:
-                    resolution = _("No suitable backup volume was found")
-                else:
-                    resolution = _("A backup location was not found")
-                logError(severity, problem, details, resolution)    
-
-            if backed_up and mediaFile.status == STATUS_DOWNLOAD_FAILED:
-                mediaFile.problem.add_extra_detail(pn.BACKUP_OK_TYPE, mediaFile.displayNameCap)
-            
-            if not backed_up:
-                if mediaFile.status == STATUS_DOWNLOAD_FAILED:
-                    mediaFile.status = STATUS_DOWNLOAD_AND_BACKUP_FAILED
-                else:
-                    mediaFile.status = STATUS_BACKUP_PROBLEM
-            elif error_encountered:
-                # it was backed up to at least one volume, but there was an error on another backup volume
-                if mediaFile.status != STATUS_DOWNLOAD_FAILED:
-                    mediaFile.status = STATUS_BACKUP_PROBLEM
-            
-            # Take into account instances where a backup device has been removed part way through a download
-            # (thereby making self.parentApp.backupVolumes have less items than expected)
-            if self.sizeDownloaded < expected_bytes_downloaded:
-                self.sizeDownloaded = expected_bytes_downloaded
-            return backed_up
-
-        
-        self.hasStarted = True
-        display_queue.open('w')
-
-        #Do not try to handle any preference errors here
-        getPrefs(False)
-        
-        #Check photo and video download path, create if necessary
-        photoBaseDownloadDir = self.prefs.download_folder
-        if not checkDownloadPath(photoBaseDownloadDir):
-            return # cleanup already done
-
-        if DOWNLOAD_VIDEO:
-            videoBaseDownloadDir = self.prefs.video_download_folder
-            if not checkDownloadPath(videoBaseDownloadDir):
-                return
-        else:
-            videoBaseDownloadDir = self.videoTempWorkingDir = None
-            
-        if not createBothTempDirs():
-            return 
-        
-        s = scanMedia()
-        if s is None:
-            if not self.ctrl:
-                self.running = False
-                display_queue.put((media_collection_treeview.removeCard, (self.thread_id, )))
-                display_queue.close("rw")
-                return
-            else:
-                sys.stderr.write("FIXME: scan returned None, but the thread is not meant to be exiting\n")
-        if not s:
-            cmd_line(_("This device has no %(types_searched_for)s to download from.") % {'types_searched_for': self.types_searched_for})
-            display_queue.put((self.parentApp.downloadFailed, (self.thread_id, )))
-            display_queue.close("rw")
-            self.running = False
-            return
-        
-        if self.scanResultsStale or self.scanResultsStaleDownloadFolder:
-            display_queue.put((self.parentApp.regenerateScannedDevices, (self.thread_id, )))
-        all_files_downloaded = False
-        
-        totalNonErrorFiles = self.cardMedia.numberOfFilesNotCannotDownload()
-        
-        if not self.autoStart:
-            # halt thread, waiting to be restarted so download proceeds
-            self.cleanUp()
-            self.running = False
-            self.lock.acquire()
-
-            if not self.ctrl:
-                # thread will restart at this point, when the program is exiting
-                # so must exit if self.ctrl indicates this
-
-                self.running = False
-                display_queue.close("rw")
-                return
-
-            self.running = True
-            if not createBothTempDirs():
-                return
-                
-        else:
-            if need_job_code_for_renaming:
-                if checkIfNeedAJobCode():
-                    if job_code == None:
-                        self.cleanUp()
-                        self.waitingForJobCode = True
-                        display_queue.put((self.parentApp.getJobCode, ()))
-                        self.running = False
-                        self.lock.acquire()
-
-                        if not self.ctrl:
-                            # thread is exiting
-                            display_queue.close("rw")
-                            return
-
-                        self.running = True                        
-                        self.waitingForJobCode = False
-                        if not createBothTempDirs():
-                            return
-                    else:
-                        # User has entered a job code, and it's in the global variable
-                        # Assign it to all those files that do not have one
-                        display_queue.put((self.parentApp.selection_vbox.selection_treeview.apply_job_code, (job_code, False, True, self.thread_id)))
-
-            # auto start could be false if the user hit cancel when prompted for a job code
-            if self.autoStart:
-                # set all in this thread to download pending
-                display_queue.put((self.parentApp.selection_vbox.selection_treeview.set_status_to_download_pending, (False, self.thread_id)))
-                # wait until all the files have had their status set to download pending, and once that is done, restart
-                self.running = False
-                self.lock.acquire()
-                self.running = True
-                
-                # set download started time
-                display_queue.put((self.parentApp.setDownloadStartTime, ()))
-
-        while not all_files_downloaded:
-
-            # set the download start time to be the time that the user clicked the download button, or if on auto start, the value just set
-            i = 0
-            while self.parentApp.download_start_time is None or i > 2:
-                time.sleep(0.5)
-                i += 1
-            
-            if self.parentApp.download_start_time:
-                start_time = self.parentApp.download_start_time
-            else:
-                # in a bizarre corner case situation, with mulitple cards of greatly varying size, 
-                # it's possible the start time was set above and then in the meantime unset (very unlikely, but conceivably it could happen)
-                # fall back to the current time in this less than satisfactory situation
-                start_time = datetime.datetime.now()
-                
-            self.imageRenamePrefsFactory.setDownloadStartTime(start_time)
-            self.subfolderPrefsFactory.setDownloadStartTime(start_time)
-            if DOWNLOAD_VIDEO:
-                self.videoRenamePrefsFactory.setDownloadStartTime(start_time)
-                self.videoSubfolderPrefsFactory.setDownloadStartTime(start_time)
-            
-            self.noErrors = self.noWarnings = 0
-            
-            if not getPrefs(True):
-                    self.running = False
-                    display_queue.close("rw")           
-                    return
-             
-            self.downloadStarted = True
-            cmd_line(_("Download has started from %s") % self.cardMedia.prettyName(limit=0))
-            
-            
-            noFiles, sizeFiles, fileIndex = self.cardMedia.sizeAndNumberDownloadPending()
-            cmd_line(_("Attempting to download %s files") % noFiles)
-                        
-            no_backup_devices = setupBackup()
-
-            # include the time it takes to copy to the backup volumes
-            sizeFiles = sizeFiles * (no_backup_devices + 1)
-            
-            display_queue.put((self.parentApp.timeRemaining.set, (self.thread_id, sizeFiles)))
-            
-            i = 0
-            self.sizeDownloaded = noFilesDownloaded = noImagesDownloaded = noVideosDownloaded = noImagesSkipped = noVideosSkipped = 0
-            filesDownloadedSuccessfully = []
-            self.bytes_downloaded_in_backup = 0
-            
-            display_queue.put((self.parentApp.addToTotalDownloadSize, (sizeFiles, )))
-            display_queue.put((self.parentApp.setOverallDownloadMark, ()))
-            display_queue.put((self.parentApp.postStartDownloadTasks,  ()))
-            
-            sizeFiles = float(sizeFiles)
-
-            addUniqueIdentifier = self.prefs.download_conflict_resolution == config.ADD_UNIQUE_IDENTIFIER
-            usesImageSequenceElements = self.imageRenamePrefsFactory.usesSequenceElements()
-            usesVideoSequenceElements = self.videoRenamePrefsFactory.usesSequenceElements()
-            usesSequenceElements = usesVideoSequenceElements or usesImageSequenceElements
-            
-            usesStoredSequenceNo = (self.imageRenamePrefsFactory.usesTheSequenceElement(rn.STORED_SEQ_NUMBER) or
-                                    self.videoRenamePrefsFactory.usesTheSequenceElement(rn.STORED_SEQ_NUMBER))
-            sequences.setUseOfSequenceElements(
-                self.imageRenamePrefsFactory.usesTheSequenceElement(rn.SESSION_SEQ_NUMBER), 
-                self.imageRenamePrefsFactory.usesTheSequenceElement(rn.SEQUENCE_LETTER))
-            
-            # reset the progress bar to update the status of this download attempt
-            progressBarText = _("%(number)s of %(total)s %(filetypes)s") % {'number':  0, 'total': noFiles, 'filetypes':self.display_file_types}
-            display_queue.put((media_collection_treeview.updateProgress, (self.thread_id, 0.0, progressBarText, 0)))
-            
-            
-            while i < noFiles:
-                # if the user pauses the download, then this will be triggered
-                if not self.running:
-                    self.lock.acquire()
-                    self.running = True
-                
-                if not self.ctrl:
-                    self.running = False
-                    self.cleanUp()
-                    display_queue.close("rw")
-                    return
-                
-                # get information about the image to deduce image name and path
-                mediaFile = self.cardMedia.imagesAndVideos[fileIndex[i]][0]
-                if not mediaFile.status == STATUS_DOWNLOAD_PENDING:
-                    sys.stderr.write("FIXME: Thread %s is trying to download a file that it should not be!!" % self.thread_id)
-                else:
-                    self.bytes_downloaded_in_download = self.bytes_downloaded_in_backup = self.bytes_downloaded = 0
-                    if mediaFile.isImage:
-                        tempWorkingDir = self.photoTempWorkingDir
-                        baseDownloadDir = photoBaseDownloadDir
-                    else:
-                        tempWorkingDir = self.videoTempWorkingDir
-                        baseDownloadDir = videoBaseDownloadDir
-                        
-                    skipFile, sequence_to_use = generateSubfolderAndFileName(mediaFile)
 
-                    if skipFile:
-                        if mediaFile.isImage:
-                            noImagesSkipped += 1
-                        else:
-                            noVideosSkipped += 1
-                    else:
-                        fileDownloaded = downloadFile(mediaFile, sequence_to_use)
-
-                        if self.prefs.backup_images:
-                            backed_up = backupFile(mediaFile, fileDownloaded, no_backup_devices)
-
-                        if fileDownloaded:
-                            noFilesDownloaded += 1
-                            if mediaFile.isImage:
-                                noImagesDownloaded += 1
-                            else:
-                                noVideosDownloaded += 1
-                            if self.prefs.backup_images and backed_up:
-                                filesDownloadedSuccessfully.append(mediaFile.fullFileName)
-                            elif not self.prefs.backup_images:
-                                filesDownloadedSuccessfully.append(mediaFile.fullFileName)
-                        else:
-                            if mediaFile.isImage:
-                                noImagesSkipped += 1
-                            else:
-                                noVideosSkipped += 1
-                                
-                    #update the selction treeview in the main window with the new status of the file
-                    display_queue.put((self.parentApp.update_status_post_download, (mediaFile.treerowref, )))
-
-                percentComplete = (float(self.sizeDownloaded) / sizeFiles) * 100
-                    
-                if self.sizeDownloaded == sizeFiles and (totalNonErrorFiles - noFiles):
-                    progressBarText = _("%(number)s of %(total)s %(filetypes)s (%(remaining)s remaining)") % {
-                                        'number':  i + 1, 'total': noFiles, 'filetypes':self.display_file_types,
-                                        'remaining': totalNonErrorFiles - noFiles}
-                else:
-                    progressBarText = _("%(number)s of %(total)s %(filetypes)s") % {'number':  i + 1, 'total': noFiles, 'filetypes':self.display_file_types}
-                
-                if using_gio:
-                    # do not want to update the progress bar any more than it has already been updated
-                    size = mediaFile.size * (no_backup_devices + 1) - self.bytes_downloaded_in_download - self.bytes_downloaded_in_backup
-                else:
-                    size = mediaFile.size * (no_backup_devices + 1)
-                display_queue.put((media_collection_treeview.updateProgress, (self.thread_id, percentComplete, progressBarText, size)))
-                
-                i += 1
-            
-            with self.statsLock:
-                self.downloadStats.adjust(self.sizeDownloaded, noImagesDownloaded, noVideosDownloaded, noImagesSkipped, noVideosSkipped, self.noWarnings, self.noErrors)
-                
-            if self.prefs.auto_delete:
-                j = 0
-                for imageOrVideo in filesDownloadedSuccessfully:
-                    try:
-                        os.unlink(imageOrVideo)
-                        j += 1
-                    except OSError, (errno, strerror):
-                        logError(config.SERIOUS_ERROR,  _("Could not delete photo or video from device"),  
-                                _("Photo: %(source)s\nError: %(errno)s %(strerror)s")
-                                % {'source': image, 'errno': errno,  'strerror': strerror})
-                    except:
-                        logError(config.SERIOUS_ERROR,  _("Could not delete photo or video from device"),  
-                                _("Photo: %(source)s"))
-                        
-                cmd_line(_("Deleted %(number)i %(filetypes)s from device") % {'number':j, 'filetypes':self.display_file_types})
-                
-            totalNonErrorFiles = totalNonErrorFiles - noFiles
-            if totalNonErrorFiles == 0:
-                all_files_downloaded = True
-                
-                # must manually delete these variables, or else the media cannot be unmounted (bug in some versions of pyexiv2 / exiv2)
-                # for some reason directories on the device remain open with read only access, even after these steps - I don't know why
-                del self.subfolderPrefsFactory, self.imageRenamePrefsFactory, self.videoSubfolderPrefsFactory, self.videoRenamePrefsFactory
-                for i in self.cardMedia.imagesAndVideos:
-                    i[0].metadata = None
-                
-            notifyAndUnmount(umountAttemptOK = all_files_downloaded)
-            cmd_line(_("Download complete from %s") % self.cardMedia.prettyName(limit=0))
-            display_queue.put((self.parentApp.notifyUserAllDownloadsComplete,()))
-            display_queue.put((self.parentApp.resetSequences,()))
-            
-            if all_files_downloaded:
-                self.downloadComplete = True
-            else:
-                self.cleanUp()
-                self.downloadStarted = False
-                self.running = False
-                self.lock.acquire()
-                if not self.ctrl:
-                    # thread will restart at this point, when the program is exiting
-                    # so must exit if self.ctrl indicates this
-
-                    self.running = False
-                    display_queue.close("rw")
-                    return
-                self.running = True
-                if not createBothTempDirs():
-                    return
-
-
-        display_queue.put((self.parentApp.exitOnDownloadComplete, ()))
-        display_queue.close("rw")
-
-        self.cleanUp()
-                
-        self.running = False
-        if noFiles:
-            self.lock.release()
-        
-    
-    def startStop(self):
-        if self.isAlive():
-            if self.running:
-                self.running = False
-            else:
-                try:
-                    self.lock.release()
-    
-                except thread_error:
-                    sys.stderr.write(str(self.thread_id) + " thread error\n")
-    
-    def cleanUp(self):
-        """
-        Deletes temporary files and folders
-        """
-
-        for tempWorkingDir in (self.videoTempWorkingDir, self.photoTempWorkingDir):
-            if tempWorkingDir:
-                # possibly delete any lingering files
-                if os.path.isdir(tempWorkingDir):
-                    tf = os.listdir(tempWorkingDir)
-                    if tf:
-                        for f in tf:
-                            os.remove(os.path.join(tempWorkingDir, f))
-                    os.rmdir(tempWorkingDir)
-                    
-    def quit(self):
-        """ 
-        Quits the thread 
-        
-        A thread can be in one of four states:
-        
-        Not started (not alive, nothing to do)
-        Started and actively running (alive)
-        Started and paused (alive)
-        Completed (not alive, nothing to do)
-        """
-        
-        # cleanup any temporary directories and files
-        self.cleanUp()
-        
-        if self.hasStarted:
-            if self.isAlive():            
-                self.ctrl = False
-                
-                if not self.running:
-                    released = False
-                    while not released:
-                        try:
-                            self.lock.release()
-                            released = True
-                        except thread_error:
-                            sys.stderr.write("Could not release lock for thread %s\n" % self.thread_id)
-                            
-                            
-
-    def on_volume_unmount(self,  data1,  data2):
-        """ needed for call to unmount volume"""
-        pass 
-
-
-class MediaTreeView(gtk.TreeView):
+class DeviceCollection(gtk.TreeView):
     """
-    TreeView display of devices and associated copying progress.
-    
-    Assumes a threaded environment.
+    TreeView display of devices and how many files have been copied, shown
+    immediately under the menu in the main application window.
     """
-    def __init__(self, parentApp):
+    def __init__(self, parent_app):
 
-        self.parentApp = parentApp
-        # device name, size of images on the device (human readable), copy progress (%), copy text
-        self.liststore = gtk.ListStore(str, str, float, str)
-        self.mapThreadToRow = {}
+        self.parent_app = parent_app
+        # device icon & name, size of images on the device (human readable), 
+        # copy progress (%), copy text
+        self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, str, float, str)
+        self.map_process_to_row = {}
 
         gtk.TreeView.__init__(self, self.liststore)
         
@@ -3088,587 +141,357 @@ class MediaTreeView(gtk.TreeView):
         selection = self.get_selection()
         selection.set_mode(gtk.SELECTION_NONE)
         
-        # Device refers to a thing like a camera, memory card in its reader, external hard drive, Portable Storage Device, etc.
-        column0 = gtk.TreeViewColumn(_("Device"), gtk.CellRendererText(), 
-                                    text=0)
+        
+        # Device refers to a thing like a camera, memory card in its reader, 
+        # external hard drive, Portable Storage Device, etc.
+        column0 = gtk.TreeViewColumn(_("Device"))
+        pixbuf_renderer = gtk.CellRendererPixbuf()
+        text_renderer = gtk.CellRendererText()
+        text_renderer.props.ellipsize = pango.ELLIPSIZE_MIDDLE
+        text_renderer.set_fixed_size(160, -1)        
+        column0.pack_start(pixbuf_renderer, expand=False)
+        column0.pack_start(text_renderer, expand=True)
+        column0.add_attribute(pixbuf_renderer, 'pixbuf', 0)
+        column0.add_attribute(text_renderer, 'text', 1)
         self.append_column(column0)
         
-        # Size refers to the total size of images on the device, typically in MB or GB
-        column1 = gtk.TreeViewColumn(_("Size"), gtk.CellRendererText(), text=1)
+        
+        # Size refers to the total size of images on the device, typically in
+        # MB or GB
+        column1 = gtk.TreeViewColumn(_("Size"), gtk.CellRendererText(), text=2)
         self.append_column(column1)
         
         column2 = gtk.TreeViewColumn(_("Download Progress"), 
-                                    gtk.CellRendererProgress(), value=2, text=3)
+                                    gtk.CellRendererProgress(),
+                                    value=3,
+                                    text=4)
         self.append_column(column2)
         self.show_all()
         
-    def addCard(self, thread_id, cardName, sizeFiles, progress = 0.0, progressBarText = ''):
+    def add_device(self, process_id, device, progress_bar_text = ''):
         
         # add the row, and get a temporary pointer to the row
-        iter = self.liststore.append((cardName, sizeFiles, progress, progressBarText))
+        size_files = ''
+        progress = 0.0
+        iter = self.liststore.append((device.get_icon(),
+                                      device.get_name(),
+                                      size_files,
+                                      progress,
+                                      progress_bar_text))
         
-        self._setThreadMap(thread_id, iter)
-        
-        # adjust scrolled window height, based on row height and number of ready to start downloads
-        if workers.noReadyToStartWorkers() >= 1 or workers.noRunningWorkers() > 0:
-            # please note, at program startup, self.rowHeight() will be less than it will be when already running
-            # e.g. when starting with 3 cards, it could be 18, but when adding 2 cards to the already running program
-            # (with one card at startup), it could be 21
-            height = (workers.noReadyToStartWorkers() + workers.noRunningWorkers() + 2) * (self.rowHeight())
-            self.parentApp.media_collection_scrolledwindow.set_size_request(-1,  height)
+        self._set_process_map(process_id, iter)
 
         
-    def updateCard(self, thread_id, totalSizeFiles):
+    def update_device(self, process_id, total_size_files):
         """
         Updates the size of the photos and videos on the device, displayed to the user
         """
-        if thread_id in self.mapThreadToRow:
-            iter = self._getThreadMap(thread_id)
-            self.liststore.set_value(iter, 1, totalSizeFiles)
+        if process_id in self.map_process_to_row:
+            iter = self._get_process_map(process_id)
+            self.liststore.set_value(iter, 2, total_size_files)
         else:
-            sys.stderr.write("FIXME: this card is unknown")
+            logger.error("This device is unknown")
     
-    def removeCard(self, thread_id):
-        if thread_id in self.mapThreadToRow:
-            iter = self._getThreadMap(thread_id)
+    def remove_device(self, process_id):
+        if process_id in self.map_process_to_row:
+            iter = self._get_process_map(process_id)
             self.liststore.remove(iter)
-            del self.mapThreadToRow[thread_id]
+            del self.map_process_to_row[process_id]
+            
+    def get_all_displayed_processes(self):
+        """
+        returns a list of the processes currently being displayed to the user 
+        """
+        return self.map_process_to_row.keys()
 
 
-    def _setThreadMap(self, thread_id, iter):
+    def _set_process_map(self, process_id, iter):
         """
         convert the temporary iter into a tree reference, which is 
         permanent
         """
 
         path = self.liststore.get_path(iter)
-        treerowRef = gtk.TreeRowReference(self.liststore, path)
-        self.mapThreadToRow[thread_id] = treerowRef
+        treerowref = gtk.TreeRowReference(self.liststore, path)
+        self.map_process_to_row[process_id] = treerowref
     
-    def _getThreadMap(self, thread_id):
+    def _get_process_map(self, process_id):
         """
-        return the tree iter for this thread
+        return the tree iter for this process
         """
         
-        if thread_id in self.mapThreadToRow:
-            treerowRef = self.mapThreadToRow[thread_id]
-            path = treerowRef.get_path()
+        if process_id in self.map_process_to_row:
+            treerowref = self.map_process_to_row[process_id]
+            path = treerowref.get_path()
             iter = self.liststore.get_iter(path)
             return iter
         else:
             return None
     
-    def updateProgress(self, thread_id, percentComplete, progressBarText, bytesDownloaded):
+    def update_progress(self, process_id, percent_complete, progress_bar_text, bytes_downloaded):
         
-        iter = self._getThreadMap(thread_id)
+        iter = self._get_process_map(process_id)
         if iter:
-            self.liststore.set_value(iter, 2, percentComplete)
-            if progressBarText:
-                self.liststore.set_value(iter, 3, progressBarText)
-            if percentComplete or bytesDownloaded:
-                self.parentApp.updateOverallProgress(thread_id, bytesDownloaded, percentComplete)
-        
+            if percent_complete:
+                self.liststore.set_value(iter, 3, percent_complete)
+            if progress_bar_text:
+                self.liststore.set_value(iter, 4, progress_bar_text)
+            if percent_complete or bytes_downloaded:
+                pass
+                #~ logger.info("Implement update overall progress")
 
-    def rowHeight(self):
-        if not self.mapThreadToRow:
-            return 0
-        else:
-            index = self.mapThreadToRow.keys()[0]
-            path = self.mapThreadToRow[index].get_path()
-            col = self.get_column(0)
-            return self.get_background_area(path, col)[3] + 1
 
+def create_cairo_image_surface(pil_image, image_width, image_height):
+        imgd = pil_image.tostring("raw","BGRA", 0, 1)
+        data = array.array('B',imgd)
+        stride = image_width * 4
+        image = cairo.ImageSurface.create_for_data(data, cairo.FORMAT_ARGB32,
+                                            image_width, image_height, stride)
+        return image
 
-class ShowWarningDialog(gtk.Dialog):
-    """
-    Displays a warning to the user that downloading directly from a 
-    camera does not always work well
-    """ 
-    def __init__(self, parent_window, postChoiceCB):
-        gtk.Dialog.__init__(self, _("Downloading From Cameras"), None,
-                   gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-                   (gtk.STOCK_OK, gtk.RESPONSE_OK))
-                        
-        self.postChoiceCB = postChoiceCB
+class ThumbnailCellRenderer(gtk.CellRenderer):
+    __gproperties__ = {
+        "image": (gobject.TYPE_PYOBJECT, "Image",
+        "Image", gobject.PARAM_READWRITE),
+        
+        "filename": (gobject.TYPE_STRING, "Filename", 
+        "Filename", '', gobject.PARAM_READWRITE),
         
-        primary_msg = _("Downloading directly from a camera may work poorly or not at all")
-        secondary_msg = _("Downloading from a card reader always works and is generally much faster. It is strongly recommended to use a card reader.")
+        "status": (gtk.gdk.Pixbuf, "Status",
+        "Status", gobject.PARAM_READWRITE),
+    }
+    
+    def __init__(self, checkbutton_height):
+        gtk.CellRenderer.__init__(self)
+        self.image = None
         
-        self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg'))
-
-        primary_label = gtk.Label()
-        primary_label.set_markup("<b>%s</b>" % primary_msg)
-        primary_label.set_line_wrap(True)
-        primary_label.set_alignment(0, 0.5)
-
-        secondary_label = gtk.Label()
-        secondary_label.set_text(secondary_msg)
-        secondary_label.set_line_wrap(True)
-        secondary_label.set_alignment(0, 0.5)
-
-        self.show_again_checkbutton = gtk.CheckButton(_('_Show this message again'), True)
-        self.show_again_checkbutton.set_active(True)
+        self.image_area_size = 100
+        self.text_area_size = 30
+        self.padding = 6
+        self.checkbutton_height = checkbutton_height
+        self.icon_width = 20
         
-        msg_vbox = gtk.VBox()
-        msg_vbox.pack_start(primary_label, False, False, padding=6)
-        msg_vbox.pack_start(secondary_label, False, False, padding=6)        
-        msg_vbox.pack_start(self.show_again_checkbutton)
+    def do_set_property(self, pspec, value):
+        setattr(self, pspec.name, value)
 
-        icon = parent_window.render_icon(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
-        image = gtk.Image()
-        image.set_from_pixbuf(icon)
-        image.set_alignment(0, 0)
-            
-        warning_hbox = gtk.HBox()
-        warning_hbox.pack_start(image, False, False, padding = 12)
-        warning_hbox.pack_start(msg_vbox, False, False, padding = 12)
-            
-        self.vbox.pack_start(warning_hbox, padding=6)
-
-        self.set_border_width(6)
-        self.set_has_separator(False)   
+    def do_get_property(self, pspec):
+        return getattr(self, pspec.name)
         
-        self.set_default_response(gtk.RESPONSE_OK)
-      
-        self.set_transient_for(parent_window)
-        self.show_all()
+    def do_render(self, window, widget, background_area, cell_area, expose_area, flags):
         
-        self.connect('response', self.on_response)
+        cairo_context = window.cairo_create()
         
-    def on_response(self,  device_dialog, response):
-        show_again = self.show_again_checkbutton.get_active()
-        self.postChoiceCB(self,  show_again)
-
-class UseDeviceDialog(gtk.Dialog):
-    def __init__(self,  parent_window,  path,  volume,  autostart, postChoiceCB):
-        gtk.Dialog.__init__(self, _('Device Detected'), None,
-                   gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-                   (gtk.STOCK_NO, gtk.RESPONSE_CANCEL, 
-                   gtk.STOCK_YES, gtk.RESPONSE_OK))
-                        
-        self.postChoiceCB = postChoiceCB
-        
-        self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg'))
-        # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt
-        prompt_label = gtk.Label(_('Should this device or partition be used to download photos or videos from?'))
-        prompt_label.set_line_wrap(True)
-        prompt_hbox = gtk.HBox()
-        prompt_hbox.pack_start(prompt_label, False, False, padding=6)
-        device_label = gtk.Label()
-        device_label.set_markup("<b>%s</b>" % volume.get_name(limit=0))
-        device_hbox = gtk.HBox()
-        device_hbox.pack_start(device_label, False, False)
-        path_label = gtk.Label()
-        path_label.set_markup("<i>%s</i>" % path)
-        path_hbox = gtk.HBox()
-        path_hbox.pack_start(path_label, False, False)
-        
-        icon = volume.get_icon_pixbuf(36)
-        if icon:
-            image = gtk.Image()
-            image.set_from_pixbuf(icon)
-            
-        # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt
-        self.always_checkbutton = gtk.CheckButton(_('_Remember this choice'),  True)
-
-        if icon:
-            device_hbox_icon = gtk.HBox(homogeneous=False, spacing=6)
-            device_hbox_icon.pack_start(image, False, False, padding = 6)
-            device_vbox = gtk.VBox(homogeneous=True, spacing=6)
-            device_vbox.pack_start(device_hbox, False, False)
-            device_vbox.pack_start(path_hbox, False, False)
-            device_hbox_icon.pack_start(device_vbox, False, False)
-            self.vbox.pack_start(device_hbox_icon, padding = 6)
-        else:
-            self.vbox.pack_start(device_hbox, padding=6)
-            self.vbox.pack_start(path_hbox, padding = 6)
-            
-        self.vbox.pack_start(prompt_hbox, padding=6)
-        self.vbox.pack_start(self.always_checkbutton,  padding=6)
-
-        self.set_border_width(6)
-        self.set_has_separator(False)   
+        x = cell_area.x
+        y = cell_area.y + self.checkbutton_height - 8
+        w = cell_area.width
+        h = cell_area.height
         
-        self.set_default_response(gtk.RESPONSE_OK)
-      
-       
-        self.set_transient_for(parent_window)
-        self.show_all()
-        self.path = path
-        self.volume = volume
-        self.autostart = autostart
-        
-        self.connect('response', self.on_response)
-        
-    def on_response(self,  device_dialog, response):
-        userSelected = False
-        permanent_choice = self.always_checkbutton.get_active()
-        if response == gtk.RESPONSE_OK:
-            userSelected = True
-            # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt
-            cmd_line(_("%s selected for downloading from" % self.volume.get_name(limit=0)))
-            if permanent_choice:
-                # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt
-                cmd_line(_("This device or partition will always be used to download from"))
-        else:
-            # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt
-            cmd_line(_("%s rejected as a download device" % self.volume.get_name(limit=0)))
-            if permanent_choice:
-                # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt
-                cmd_line(_("This device or partition will never be used to download from"))
-            
-        self.postChoiceCB(self,  userSelected,  permanent_choice,  self.path,  
-                          self.volume, self.autostart)
-                          
-class RemoveAllJobCodeDialog(gtk.Dialog):
-    def __init__(self, parent_window, postChoiceCB):
-        gtk.Dialog.__init__(self, _('Remove all Job Codes?'), None,
-                   gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-                   (gtk.STOCK_NO, gtk.RESPONSE_CANCEL, 
-                   gtk.STOCK_YES, gtk.RESPONSE_OK))
-                        
-        self.postChoiceCB = postChoiceCB        
-        self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg'))
         
-        prompt_hbox = gtk.HBox()
+        #constrain operations to cell area, allowing for a 1 pixel border 
+        #either side
+        #~ cairo_context.rectangle(x-1, y-1, w+2, h+2)
+        #~ cairo_context.clip()
         
-        icontheme = gtk.icon_theme_get_default()
-        icon = icontheme.load_icon('gtk-dialog-question', 36, gtk.ICON_LOOKUP_USE_BUILTIN)        
-        if icon:
-            image = gtk.Image()
-            image.set_from_pixbuf(icon)
-            prompt_hbox.pack_start(image, False, False, padding = 6)
-            
-        prompt_label = gtk.Label(_('Should all Job Codes be removed?'))
-        prompt_label.set_line_wrap(True)
-        prompt_hbox.pack_start(prompt_label, False, False, padding=6)
-                    
-        self.vbox.pack_start(prompt_hbox, padding=6)
-
-        self.set_border_width(6)
-        self.set_has_separator(False)   
-        
-        self.set_default_response(gtk.RESPONSE_OK)
-      
-       
-        self.set_transient_for(parent_window)
-        self.show_all()
-
+        #fill in the background with dark grey
+        #this ensures that a selected cell's fill does not make
+        #the text impossible to read
+        #~ cairo_context.rectangle(x, y, w, h)
+        #~ cairo_context.set_source_rgb(0.267, 0.267, 0.267)
+        #~ cairo_context.fill()
         
-        self.connect('response', self.on_response)
+        #image width and height
+        image_w = self.image.size[0]
+        image_h = self.image.size[1]
         
-    def on_response(self,  device_dialog, response):
-        userSelected = response == gtk.RESPONSE_OK
-        self.postChoiceCB(self, userSelected)   
+        #center the image horizontally
+        #bottom align vertically
+        #top left and right corners for the image:
+        image_x = x + ((w - image_w) / 2)
+        image_y = y + self.image_area_size - image_h
+
+        #convert PIL image to format suitable for cairo
+        image = create_cairo_image_surface(self.image, image_w, image_h)
+
+        # draw a light grey border of 1px around the image
+        cairo_context.set_source_rgb(0.66, 0.66, 0.66) #light grey, #a9a9a9
+        cairo_context.set_line_width(1)
+        cairo_context.rectangle(image_x-.5, image_y-.5, image_w+1, image_h+1)
+        cairo_context.stroke()
         
+        # draw a thin border around each cell
+        # ouch - nasty hardcoding :(
+        #~ cairo_context.set_source_rgb(0.33, 0.33, 0.33)
+        #~ cairo_context.rectangle(x-6.5, y-9.5, w+14, h+31)
+        #~ cairo_context.stroke()
         
-class JobCodeDialog(gtk.Dialog):
-    """ Dialog prompting for a job code"""
-    
-    def __init__(self, parent_window, job_codes,  default_job_code, postJobCodeEntryCB, autoStart, downloadSelected, entryOnly):
-        # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode
-        gtk.Dialog.__init__(self,  _('Enter a Job Code'), None,
-                   gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
-                   (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, 
-                   gtk.STOCK_OK, gtk.RESPONSE_OK))
-                        
+        #place the image
+        cairo_context.set_source_surface(image, image_x, image_y)
+        cairo_context.paint()
         
-        self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg'))
-        self.postJobCodeEntryCB = postJobCodeEntryCB
-        self.autoStart = autoStart
-        self.downloadSelected = downloadSelected
+        #text
+        context = pangocairo.CairoContext(cairo_context)
         
-        self.combobox = gtk.combo_box_entry_new_text()
-        for text in job_codes:
-            self.combobox.append_text(text)
-            
-        self.job_code_hbox = gtk.HBox(homogeneous = False)
+        text_y = y + self.image_area_size + 10
+        text_w = w - self.icon_width
+        text_x = x + self.icon_width
+        #~ context.rectangle(text_x, text_y, text_w, 15)
+        #~ context.clip()        
         
-        if len(job_codes) and not entryOnly:
-            # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode
-            task_label = gtk.Label(_('Enter a new Job Code, or select a previous one'))
-        else:
-            # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode
-            task_label = gtk.Label(_('Enter a new Job Code'))            
-        task_label.set_line_wrap(True)
-        task_hbox = gtk.HBox()
-        task_hbox.pack_start(task_label, False, False, padding=6)
+        layout = context.create_layout()
 
-        label = gtk.Label(_('Job Code:'))
-        self.job_code_hbox.pack_start(label, False, False, padding=6)
-        self.job_code_hbox.pack_start(self.combobox, True, True, padding=6)
+        width = text_w * pango.SCALE
+        layout.set_width(width)
+        
+        layout.set_alignment(pango.ALIGN_CENTER)
+        layout.set_ellipsize(pango.ELLIPSIZE_END)
         
-        self.set_border_width(6)
-        self.set_has_separator(False)
+        #font color and size
+        fg_color = pango.AttrForeground(65535, 65535, 65535, 0, -1)
+        font_size = pango.AttrSize(8192, 0, -1) # 8 * 1024 = 8192
+        font_family = pango.AttrFamily('sans', 0, -1)
+        attr = pango.AttrList()
+        attr.insert(fg_color)
+        attr.insert(font_size)
+        attr.insert(font_family)
+        layout.set_attributes(attr)
 
-        # make entry box have entry completion
-        self.entry = self.combobox.child
+        layout.set_text(self.filename)        
+
+        context.move_to(text_x, text_y)
+        context.show_layout(layout)
+
+        #status
+        cairo_context.set_source_pixbuf(self.status, x, y + self.image_area_size + 10)
+        cairo_context.paint()
         
-        completion = gtk.EntryCompletion()
-        completion.set_match_func(self.match_func)
-        completion.connect("match-selected",
-                             self.on_completion_match)
-        completion.set_model(self.combobox.get_model())
-        completion.set_text_column(0)
-        self.entry.set_completion(completion)
+    def do_get_size(self, widget, cell_area):
+        #~ return (0, 0, self.image_area_size, self.image_area_size + self.checkbutton_height + 10)
+        return (0, 0, self.image_area_size, self.image_area_size + self.text_area_size - self.checkbutton_height + 4)
         
-        # when user hits enter, close the dialog window
-        self.set_default_response(gtk.RESPONSE_OK)
-        self.entry.set_activates_default(True)
 
-        if default_job_code:
-            self.entry.set_text(default_job_code)
+gobject.type_register(ThumbnailCellRenderer)
+ 
+
+class ThumbnailDisplay(gtk.IconView):
+    def __init__(self, parent_app):
+        gtk.IconView.__init__(self)
+        self.rapid_app = parent_app
         
-        self.vbox.pack_start(task_hbox, False, False, padding = 6)
-        self.vbox.pack_start(self.job_code_hbox, False, False, padding=12)
+        self.batch_size = 10
         
-        self.set_transient_for(parent_window)
-        self.show_all()
-        self.connect('response', self.on_job_code_resp)
-            
-    def match_func(self, completion, key, iter):
-         model = completion.get_model()
-         return model[iter][0].lower().startswith(self.entry.get_text().lower())
-         
-    def on_completion_match(self, completion, model, iter):
-         self.entry.set_text(model[iter][0])
-         self.entry.set_position(-1)
-
-    def get_job_code(self):
-        return self.combobox.child.get_text()
+        self.thumbnail_manager = ThumbnailManager(self.thumbnail_results, self.batch_size)
+        self.preview_manager = PreviewManager(self.preview_results)
         
-    def on_job_code_resp(self,  jc_dialog, response):
-        userChoseCode = False
-        if response == gtk.RESPONSE_OK:
-            userChoseCode = True
-            cmd_line(_("Job Code entered"))  
-        else:
-            cmd_line(_("Job Code not entered"))
-        self.postJobCodeEntryCB(self, userChoseCode, self.get_job_code(), self.autoStart, self.downloadSelected)
-
-
-
-class SelectionTreeView(gtk.TreeView):
-    """
-    TreeView display of photos and videos available for download
-    
-    Assumes a threaded environment.
-    """
-    def __init__(self, parentApp):
-
-        self.parentApp = parentApp
-        self.rapidApp = parentApp.parentApp
+        self.treerow_index = {} 
+        self.process_index = {} 
         
-        self.liststore = gtk.ListStore(
-                         gtk.gdk.Pixbuf,        # 0 thumbnail icon
-                         str,                   # 1 name (for sorting)
-                         int,                   # 2 timestamp (for sorting), float converted into an int
-                         str,                   # 3 date (human readable)
-                         int,                   # 4 size (for sorting)
-                         str,                   # 5 size (human readable)
-                         int,                   # 6 isImage (for sorting)
-                         gtk.gdk.Pixbuf,        # 7 type (photo or video)
-                         str,                   # 8 job code
-                         gobject.TYPE_PYOBJECT, # 9 mediaFile (for data)
-                         gtk.gdk.Pixbuf,        # 10 status icon
-                         int,                   # 11 status (downloaded, cannot download, etc, for sorting)
-                         str,                   # 12 path (on the device)
-                         str,                   # 13 device
-                         int)                   # 14 thread id (worker the file is associated with)
-                         
-        self.selected_rows = set()
-
-        # sort by date (unless there is a problem)
-        self.liststore.set_sort_column_id(2, gtk.SORT_ASCENDING)
+        self.rpd_files = {}
         
-        gtk.TreeView.__init__(self, self.liststore)
-
-        selection = self.get_selection()
-        selection.set_mode(gtk.SELECTION_MULTIPLE)
-        selection.connect('changed', self.on_selection_changed)
-        
-        self.set_rubber_banding(True)
-        
-        # Status Column
-        # Indicates whether file was downloaded, or a warning or error of some kind
-        cell = gtk.CellRendererPixbuf()
-        cell.set_property("yalign", 0.5)
-        status_column = gtk.TreeViewColumn(_("Status"), cell, pixbuf=10)
-        status_column.set_sort_column_id(11)
-        status_column.connect('clicked', self.header_clicked)
-        self.append_column(status_column)
-        
-        # Type of file column i.e. photo or video (displays at user request)
-        cell = gtk.CellRendererPixbuf()
-        cell.set_property("yalign", 0.5)     
-        self.type_column = gtk.TreeViewColumn(_("Type"), cell, pixbuf=7)
-        self.type_column.set_sort_column_id(6)
-        self.type_column.set_clickable(True)
-        self.type_column.connect('clicked', self.header_clicked)
-        self.append_column(self.type_column)
-        self.display_type_column(self.rapidApp.prefs.display_type_column)
-        
-        #File thumbnail column
-        if not DOWNLOAD_VIDEO:
-            title = _("Photo")
-        else:
-            title = _("File")
-        thumbnail_column = gtk.TreeViewColumn(title)
-        cellpb = gtk.CellRendererPixbuf()
-        if not DROP_SHADOW:
-            cellpb.set_fixed_size(60,50)           
-        thumbnail_column.pack_start(cellpb, False)
-        thumbnail_column.set_attributes(cellpb, pixbuf=0)
-        thumbnail_column.set_sort_column_id(1)
-        thumbnail_column.set_clickable(True)        
-        thumbnail_column.connect('clicked', self.header_clicked)
-        self.append_column(thumbnail_column)
-
-        # Job code column
-        cell = gtk.CellRendererText()
-        cell.set_property("yalign", 0)
-        self.job_code_column = gtk.TreeViewColumn(_("Job Code"), cell, text=8)
-        self.job_code_column.set_sort_column_id(8)
-        self.job_code_column.set_resizable(True)
-        self.job_code_column.set_clickable(True)        
-        self.job_code_column.connect('clicked', self.header_clicked)
-        self.append_column(self.job_code_column)
-
-        # Date column
-        cell = gtk.CellRendererText()
-        cell.set_property("yalign", 0)
-        date_column = gtk.TreeViewColumn(_("Date"), cell, text=3)
-        date_column.set_sort_column_id(2)   
-        date_column.set_resizable(True)
-        date_column.set_clickable(True)
-        date_column.connect('clicked', self.header_clicked)
-        self.append_column(date_column)
-        
-        # Size column (displays at user request)
-        cell = gtk.CellRendererText()
-        cell.set_property("yalign", 0)
-        self.size_column = gtk.TreeViewColumn(_("Size"), cell, text=5)
-        self.size_column.set_sort_column_id(4)
-        self.size_column.set_resizable(True)
-        self.size_column.set_clickable(True)            
-        self.size_column.connect('clicked', self.header_clicked)
-        self.append_column(self.size_column)
-        self.display_size_column(self.rapidApp.prefs.display_size_column)
-        
-        # Device column (displays at user request)
-        cell = gtk.CellRendererText()
-        cell.set_property("yalign", 0)
-        self.device_column = gtk.TreeViewColumn(_("Device"), cell, text=13)
-        self.device_column.set_sort_column_id(13)
-        self.device_column.set_resizable(True)
-        self.device_column.set_clickable(True)        
-        self.device_column.connect('clicked', self.header_clicked)
-        self.append_column(self.device_column)
-        self.display_device_column(self.rapidApp.prefs.display_device_column)        
-        
-        # Filename column (displays at user request)
-        cell = gtk.CellRendererText()
-        cell.set_property("yalign", 0)
-        self.filename_column = gtk.TreeViewColumn(_("Filename"), cell, text=1)
-        self.filename_column.set_sort_column_id(1)   
-        self.filename_column.set_resizable(True)
-        self.filename_column.set_clickable(True)
-        self.filename_column.connect('clicked', self.header_clicked)
-        self.append_column(self.filename_column)
-        self.display_filename_column(self.rapidApp.prefs.display_filename_column)
-        
-        # Path column (displays at user request)
-        cell = gtk.CellRendererText()
-        cell.set_property("yalign", 0)
-        self.path_column = gtk.TreeViewColumn(_("Path"), cell, text=12)
-        self.path_column.set_sort_column_id(12)   
-        self.path_column.set_resizable(True)
-        self.path_column.set_clickable(True)
-        self.path_column.connect('clicked', self.header_clicked)
-        self.append_column(self.path_column)
-        self.display_path_column(self.rapidApp.prefs.display_path_column)        
-                
-        self.show_all()
+        self.total_files = 0
+        self.thumbnails_generated = 0
         
-        # flag used to determine if a preview should be generated or not
-        # there is no point generating a preview for each photo when 
-        # select all photos is called, for instance
-        self.suspend_previews = False
+        self.thumbnails = {}
+        self.previews = {}
+        self.previews_being_fetched = set()
         
-        self.user_has_clicked_header = False
+        self.stock_photo_thumbnails = tn.PhotoIcons()
+        self.stock_video_thumbnails = tn.VideoIcons()
         
-        # icons to be displayed in status column
+        self.SELECTED_COL = 1
+        self.UNIQUE_ID_COL = 2
+        self.TIMESTAMP_COL = 4
+        self.FILETYPE_COL = 5
+        self.CHECKBUTTON_VISIBLE_COL = 6
+        self.DOWNLOAD_STATUS_COL = 7
+        self.STATUS_ICON_COL = 8
+        
+        self.liststore = gtk.ListStore(
+             gobject.TYPE_PYOBJECT, # 0 PIL thumbnail
+             gobject.TYPE_BOOLEAN,  # 1 selected or not
+             str,                   # 2 unique id
+             str,                   # 3 file name
+             int,                   # 4 timestamp for sorting, converted float
+             int,                   # 5 file type i.e. photo or video
+             gobject.TYPE_BOOLEAN,  # 6 visibility of checkbutton
+             int,                   # 7 status of download
+             gtk.gdk.Pixbuf,        # 8 status icon
+             )
 
-        self.downloaded_icon = self.render_icon('rapid-photo-downloader-downloaded', gtk.ICON_SIZE_MENU) 
-        self.download_failed_icon = self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU)
-        self.error_icon = self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU)
-        self.warning_icon = self.render_icon(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_MENU)
 
-        self.download_pending_icon = self.render_icon('rapid-photo-downloader-download-pending', gtk.ICON_SIZE_MENU) 
-        self.downloaded_with_warning_icon = self.render_icon('rapid-photo-downloader-downloaded-with-warning', gtk.ICON_SIZE_MENU)
-        self.downloaded_with_error_icon = self.render_icon('rapid-photo-downloader-downloaded-with-error', gtk.ICON_SIZE_MENU)
+        self.clear()
+        self.set_model(self.liststore)
         
-        # make the not yet downloaded icon a transparent square
-        self.not_downloaded_icon = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 16, 16)
-        self.not_downloaded_icon.fill(0xffffffff)
-        self.not_downloaded_icon = self.not_downloaded_icon.add_alpha(True, chr(255), chr(255), chr(255))
-        # but make it be a tick in the preview pane
-        self.not_downloaded_icon_tick = self.render_icon(gtk.STOCK_YES, gtk.ICON_SIZE_MENU)
-        
-        #preload generic icons
-        self.icon_photo =  gtk.gdk.pixbuf_new_from_file(paths.share_dir('glade3/photo24.png'))
-        self.icon_video =  gtk.gdk.pixbuf_new_from_file(paths.share_dir('glade3/video24.png'))
-        #with shadows
-        if DROP_SHADOW:
-            self.generic_photo_thumbnail = gtk.gdk.pixbuf_new_from_file(paths.share_dir('glade3/photo_small_shadow.png'))
-            self.generic_video_thumbnail = gtk.gdk.pixbuf_new_from_file(paths.share_dir('glade3/video_small_shadow.png'))
-            self.iconDropShadow = DropShadow(offset=(3,3), shadow = (0x34, 0x34, 0x34, 0xff), border=6)
-        else:
-            self.generic_photo_thumbnail = gtk.gdk.pixbuf_new_from_file(paths.share_dir('glade3/photo_small.png'))
-            self.generic_video_thumbnail = gtk.gdk.pixbuf_new_from_file(paths.share_dir('glade3/video_small.png'))
+        checkbutton = gtk.CellRendererToggle()
+        checkbutton.set_radio(False)
+        checkbutton.props.activatable = True
+        checkbutton.props.xalign = 0.0
+        checkbutton.connect('toggled', self.on_checkbutton_toggled)
+        self.pack_end(checkbutton, expand=False)
+        self.add_attribute(checkbutton, "active", 1)
+        self.add_attribute(checkbutton, "visible", 6)
         
-        self.previewed_file_treerowref = None
-        self.icontheme = gtk.icon_theme_get_default()
+        checkbutton_size = checkbutton.get_size(self, None)
+        checkbutton_height = checkbutton_size[3]
+        checkbutton_width = checkbutton_size[2]
         
+        #~ status_icon = gtk.CellRendererPixbuf()
+        #~ self.pack_start(status_icon, expand=False)
+        #~ self.add_attribute(status_icon, "pixbuf", self.STATUS_ICON_COL)
         
+        image = ThumbnailCellRenderer(checkbutton_height)
+        self.pack_start(image, expand=True)
+        self.add_attribute(image, "image", 0)
+        self.add_attribute(image, "filename", 3)
+        self.add_attribute(image, "status", 8)
+
         
-    def get_thread(self, iter):
-        """
-        Returns the thread associated with the liststore's iter
-        """
-        return self.liststore.get_value(iter, 14)
+        #set the background color to a darkish grey
+        self.modify_base(gtk.STATE_NORMAL, gtk.gdk.Color('#444444'))
         
-    def get_status(self, iter):
-        """
-        Returns the status associated with the liststore's iter
-        """
-        return self.liststore.get_value(iter, 11)
+        self.set_spacing(0)
+        #~ self.set_column_spacing(0)
+        self.set_row_spacing(5)
+        #~ self.set_row_spacing(0)
+        self.set_margin(25)
         
-    def get_mediaFile(self, iter):
-        """
-        Returns the mediaFile associated with the liststore's iter
-        """
-        return self.liststore.get_value(iter, 9)
+        self._setup_icons()
         
-    def get_is_image(self, iter):
-        """
-        Returns the file type (is image or video) associated with the liststore's iter
-        """
-        return self.liststore.get_value(iter, 6)
-    
-    def get_type_icon(self, iter):
-        """
-        Returns the file type's pixbuf associated with the liststore's iter
-        """
-        return self.liststore.get_value(iter, 7)
+        self.show_all()
         
-    def get_job_code(self, iter):
-        """
-        Returns the job code associated with the liststore's iter
-        """
-        return self.liststore.get_value(iter, 8)
+        self.connect('item-activated', self.on_item_activated)
+        
+    def _setup_icons(self):
+        # icons to be displayed in status column
+
+        size = 16
+        # standard icons
+        failed = self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU)
+        self.download_failed_icon = failed.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
+        error = self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU)
+        self.error_icon = error.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
+        warning = self.render_icon(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_MENU)
+        self.warning_icon = warning.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
+
+        # Rapid Photo Downloader specific icons
+        self.downloaded_icon = gtk.gdk.pixbuf_new_from_file_at_size(
+               paths.share_dir('glade3/rapid-photo-downloader-downloaded.svg'),
+               size, size)
+        self.download_pending_icon = gtk.gdk.pixbuf_new_from_file_at_size(
+               paths.share_dir('glade3/rapid-photo-downloader-download-pending.svg'),
+               size, size) 
+        self.downloaded_with_warning_icon = gtk.gdk.pixbuf_new_from_file_at_size(
+               paths.share_dir('glade3/rapid-photo-downloader-downloaded-with-warning.svg'),
+               size, size)
+        self.downloaded_with_error_icon = gtk.gdk.pixbuf_new_from_file_at_size(
+               paths.share_dir('glade3/rapid-photo-downloader-downloaded-with-error.svg'),
+               size, size)
+        
+        # make the not yet downloaded icon a transparent square
+        self.not_downloaded_icon = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 16, 16)
+        self.not_downloaded_icon.fill(0xffffffff)
+        self.not_downloaded_icon = self.not_downloaded_icon.add_alpha(True, chr(255), chr(255), chr(255))
         
-    def get_status_icon(self, status, preview=False):
+    def get_status_icon(self, status):
         """
         Returns the correct icon, based on the status
         """
@@ -3679,10 +502,7 @@ class SelectionTreeView(gtk.TreeView):
         elif status == STATUS_DOWNLOADED:
             status_icon =  self.downloaded_icon
         elif status == STATUS_NOT_DOWNLOADED:
-            if preview:
-                status_icon = self.not_downloaded_icon_tick
-            else:
-                status_icon = self.not_downloaded_icon
+            status_icon = self.not_downloaded_icon
         elif status in [STATUS_DOWNLOADED_WITH_WARNING, STATUS_BACKUP_PROBLEM]:
             status_icon = self.downloaded_with_warning_icon
         elif status in [STATUS_DOWNLOAD_FAILED, STATUS_DOWNLOAD_AND_BACKUP_FAILED]:
@@ -3690,1464 +510,1183 @@ class SelectionTreeView(gtk.TreeView):
         elif status == STATUS_DOWNLOAD_PENDING:
             status_icon = self.download_pending_icon
         else:
-            sys.stderr.write("FIXME: unknown status: %s\n" % status)
+            logger.critical("FIXME: unknown status: %s", status)
             status_icon = self.not_downloaded_icon
-        return status_icon
-        
-    def get_tree_row_refs(self):
-        """
-        Returns a list of all tree row references
-        """
-        tree_row_refs = []
-        iter = self.liststore.get_iter_first()
-        while iter:
-            tree_row_refs.append(self.get_mediaFile(iter).treerowref)
-            iter = self.liststore.iter_next(iter)
-        return tree_row_refs
-        
-    def get_selected_tree_row_refs(self):
-        """
-        Returns a list of tree row references for the selected rows
-        """
-        tree_row_refs = []
-        selection = self.get_selection()
-        model, pathlist = selection.get_selected_rows()
-        for path in pathlist:
-            iter = self.liststore.get_iter(path)
-            tree_row_refs.append(self.get_mediaFile(iter).treerowref)
-        return tree_row_refs            
-            
-    def get_tree_row_iters(self, selected_only=False):
-        """
-        Yields tree row iters
+        return status_icon        
+    
+    def sort_by_timestamp(self):
+        self.liststore.set_sort_column_id(self.TIMESTAMP_COL, gtk.SORT_ASCENDING)
         
-        If selected_only is True, then only those from the selected
-        rows will be returned.
+    def on_checkbutton_toggled(self, cellrenderertoggle, path):
+        iter = self.liststore.get_iter(path)
+        self.liststore.set_value(iter, self.SELECTED_COL, not cellrenderertoggle.get_active())
+        self.rapid_app.set_download_action_sensitivity()
         
-        This function is essential when modifying any content
-        in the list store (because rows can easily be moved when their
-        content changes)
-        """
-        if selected_only:
-            tree_row_refs = self.get_selected_tree_row_refs()
-        else:
-            tree_row_refs = self.get_tree_row_refs()
-        for reference in tree_row_refs:
-            path = reference.get_path()
-            yield self.liststore.get_iter(path)
+    def set_selected(self, unique_id, value):
+        iter = self.get_iter_from_unique_id(unique_id)
+        self.liststore.set_value(iter, self.SELECTED_COL, value)
     
-    def add_file(self, mediaFile):
-        if debug_info:
-            cmd_line('Adding file %s' % mediaFile.fullFileName)
-            
-        # metadata is loaded when previews are generated before downloading
-        if mediaFile.metadata:
-            date = mediaFile.dateTime()
-            timestamp = mediaFile.metadata.timeStamp(missing=None)
-            if timestamp is None:
-                timestamp = mediaFile.modificationTime
-        # if metadata has not been loaded, substitute other values
-        else:
-            timestamp = mediaFile.modificationTime
-            date = datetime.datetime.fromtimestamp(timestamp)
+    def add_file(self, rpd_file):
 
-        timestamp = int(timestamp)
-            
-        date_human_readable = date_time_human_readable(date)
-        name = mediaFile.name
-        size = mediaFile.size
-        thumbnail = mediaFile.thumbnail
-        
-        if mediaFile.genericThumbnail:
-            if mediaFile.isImage:
-                thumbnail_icon = self.generic_photo_thumbnail
-            else:
-                thumbnail_icon = self.generic_video_thumbnail
-        else:
-            thumbnail_icon = common.scale2pixbuf(60, 36, thumbnail)
-            
-        if DROP_SHADOW and not mediaFile.genericThumbnail:
-            pil_image = pixbuf_to_image(thumbnail_icon)
-            pil_image = self.iconDropShadow.dropShadow(pil_image)
-            thumbnail_icon = image_to_pixbuf(pil_image)
+        thumbnail_icon = self.get_stock_icon(rpd_file.file_type)
+        unique_id = rpd_file.unique_id
+        scan_pid = rpd_file.scan_pid
 
+        timestamp = int(rpd_file.modification_time)
+        
+        iter = self.liststore.append((thumbnail_icon,
+                                      True,
+                                      unique_id,
+                                      rpd_file.display_name,
+                                      timestamp,
+                                      rpd_file.file_type,
+                                      True,
+                                      STATUS_NOT_DOWNLOADED,
+                                      self.not_downloaded_icon
+                                      ))
         
-        if mediaFile.isImage:
-            type_icon = self.icon_photo
-        else:
-            type_icon = self.icon_video
-
-        status_icon = self.get_status_icon(mediaFile.status)
-        
-        if debug_info and False:
-            cmd_line('Thumbnail icon: %s' % thumbnail_icon)
-            cmd_line('Name: %s' % name)
-            cmd_line('Timestamp: %s' % timestamp)
-            cmd_line('Date: %s' % date_human_readable)
-            cmd_line('Size: %s %s' % (size, common.formatSizeForUser(size)))
-            cmd_line('Is an image: %s' % mediaFile.isImage)
-            cmd_line('Status: %s' % self.status_human_readable(mediaFile))
-            cmd_line('Path: %s' % mediaFile.path)
-            cmd_line('Device name: %s' % mediaFile.deviceName)
-            cmd_line('Thread: %s' % mediaFile.thread_id)
-            cmd_line(' ')
-
-        iter = self.liststore.append((thumbnail_icon, name, timestamp, date_human_readable, size, common.formatSizeForUser(size), mediaFile.isImage, type_icon, '', mediaFile, status_icon, mediaFile.status, mediaFile.path, mediaFile.deviceName, mediaFile.thread_id))
-        
-        #create a reference to this row and store it in the mediaFile
         path = self.liststore.get_path(iter)
-        mediaFile.treerowref = gtk.TreeRowReference(self.liststore, path)
+        treerowref = gtk.TreeRowReference(self.liststore, path)
         
-        if mediaFile.status in [STATUS_CANNOT_DOWNLOAD, STATUS_WARNING]:
-            if not self.user_has_clicked_header:
-                self.liststore.set_sort_column_id(11, gtk.SORT_DESCENDING)
+        if scan_pid in self.process_index:
+            self.process_index[scan_pid].append(unique_id)
+        else:
+            self.process_index[scan_pid] = [unique_id,]
+            
+        self.treerow_index[unique_id] = treerowref
+        self.rpd_files[unique_id] = rpd_file
         
-    def no_selected_rows_available_for_download(self):
-        """
-        Gets the number of rows the user has selected that can actually
-        be downloaded, and the threads they are found in
-        """
-        v = 0
-        threads = []
-        model, paths = self.get_selection().get_selected_rows()
-        for path in paths:
-            iter = self.liststore.get_iter(path)
-            status = self.get_status(iter)
-            if status in [STATUS_NOT_DOWNLOADED, STATUS_WARNING]:
-                v += 1
-                thread = self.get_thread(iter)
-                if thread not in threads:
-                    threads.append(thread)
-        return v, threads
-        
-    def rows_available_for_download(self):
-        """
-        Returns true if one or more rows has their status as STATUS_NOT_DOWNLOADED or STATUS_WARNING
-        """
-        iter = self.liststore.get_iter_first()
-        while iter:
-            status = self.get_status(iter)
-            if status in [STATUS_NOT_DOWNLOADED, STATUS_WARNING]:
-                return True
-            iter = self.liststore.iter_next(iter)
-        return False
+        self.total_files += 1
+
+    def get_unique_id_from_iter(self, iter):
+        return self.liststore.get_value(iter, 2)
+        
+    def get_iter_from_unique_id(self, unique_id):
+        treerowref = self.treerow_index[unique_id]
+        path = treerowref.get_path()
+        return self.liststore.get_iter(path)
     
-    def update_download_selected_button(self):
+    def on_item_activated(self, iconview, path):        
         """
-        Updates the text on the Download Selection button, and set its sensitivity
         """
-        no_available_for_download = 0
-        selection = self.get_selection()
-        model, paths = selection.get_selected_rows()
-        if paths:            
-            path = paths[0]
+        iter = self.liststore.get_iter(path)
+        self.show_preview(iter=iter)
+        self.advance_get_preview_image(iter)
+
+    
+    def _get_preview(self, unique_id, rpd_file):
+        if unique_id not in self.previews_being_fetched:
+            #check if preview should be from a downloaded file, or the source
+            if rpd_file.status in DOWNLOADED:
+                file_location = rpd_file.download_full_file_name
+            else:
+                file_location = rpd_file.full_file_name
+            self.preview_manager.get_preview(unique_id, file_location,
+                                            rpd_file.file_type, size_max=None,)
+                                            
+            self.previews_being_fetched.add(unique_id)
+            
+    def show_preview(self, unique_id=None, iter=None):
+        if unique_id is not None:
+            iter = self.get_iter_from_unique_id(unique_id)
+        elif iter is not None:
+            unique_id = self.get_unique_id_from_iter(iter)
+        else:
+            # neither an iter or a unique_id were passed
+            # use iter from first selected file
+            # if none is selected, choose the first file
+            selected = self.get_selected_items()
+            if selected:
+                path = selected[0]
+            else:
+                path = 0
             iter = self.liststore.get_iter(path)
+            unique_id = self.get_unique_id_from_iter(iter)
             
-            #update button text
-            no_available_for_download, threads = self.no_selected_rows_available_for_download()
             
-        if no_available_for_download and workers.scanComplete(threads):
-            self.rapidApp.download_selected_button.set_label(self.rapidApp.DOWNLOAD_SELECTED_LABEL + " (%s)" % no_available_for_download)
-            self.rapidApp.download_selected_button.set_sensitive(True)
-        else:
-            #nothing was selected, or nothing is available from what the user selected, or should not download right now
-            self.rapidApp.download_selected_button.set_label(self.rapidApp.DOWNLOAD_SELECTED_LABEL)
-            self.rapidApp.download_selected_button.set_sensitive(False)
-    
-    def on_selection_changed(self, selection):
-        """
-        Update download selected button and preview the most recently
-        selected row in the treeview
-        """
-        self.update_download_selected_button()
-        size = selection.count_selected_rows()
-        if size == 0:
-            self.selected_rows = set()
-            self.show_preview(None)
+        rpd_file = self.rpd_files[unique_id]    
+        
+        if unique_id in self.previews:
+            preview_image = self.previews[unique_id]
         else:
-            if size <= len(self.selected_rows):
-                # discard everything, start over
-                self.selected_rows = set()
-                self.selection_size = size
-            model, paths = selection.get_selected_rows()
-            for path in paths:
-                iter = self.liststore.get_iter(path)
-                ref = self.get_mediaFile(iter).treerowref
-                
-                if ref not in self.selected_rows:
-                    self.show_preview(iter)
-                    self.selected_rows.add(ref)
+            # request daemon process to get a full size thumbnail
+            self._get_preview(unique_id, rpd_file)
+            if unique_id in self.thumbnails:    
+                preview_image = self.thumbnails[unique_id]
+            else:
+                preview_image = self.get_stock_icon(rpd_file.file_type)
+        
+        checked = self.liststore.get_value(iter, self.SELECTED_COL)
+        include_checkbutton_visible = rpd_file.status == STATUS_NOT_DOWNLOADED
+        self.rapid_app.show_preview_image(unique_id, preview_image, 
+                                            include_checkbutton_visible, checked)
             
-    def clear_all(self, thread_id = None):
-        if thread_id is None:
-            self.liststore.clear()
-            self.show_preview(None)
-        else:
+    def _get_next_iter(self, iter):
+        iter = self.liststore.iter_next(iter)
+        if iter is None:
             iter = self.liststore.get_iter_first()
-            while iter:
-                t = self.get_thread(iter) 
-                if t == thread_id:
-                    if self.previewed_file_treerowref:
-                        mediaFile = self.get_mediaFile(iter)
-                        if mediaFile.treerowref == self.previewed_file_treerowref:
-                            self.show_preview(None)
-                    self.liststore.remove(iter)
-                    # need to start over, or else bad things happen
-                    iter = self.liststore.get_iter_first()
-                else:
-                    iter = self.liststore.iter_next(iter)
-    
-    def refreshSampleDownloadFolders(self, thread_id = None):
-        """
-        Refreshes the download folder of every file that has not yet been downloaded
-        
-        This is useful when the user updates the preferences, and the scan has already occurred (or is occurring)
-        
-        If thread_id is specified, will only update rows with that thread
-        """
-        for iter in self.get_tree_row_iters():
-            status = self.get_status(iter)
-            if status in [STATUS_NOT_DOWNLOADED, STATUS_WARNING, STATUS_CANNOT_DOWNLOAD]:
-                regenerate = True
-                if thread_id is not None:
-                    t = self.get_thread(iter)
-                    regenerate = t == thread_id
-                
-                if regenerate:
-                    mediaFile = self.get_mediaFile(iter)
-                    if mediaFile.isImage:
-                        mediaFile.downloadFolder = self.rapidApp.prefs.download_folder
-                    else:
-                        mediaFile.downloadFolder = self.rapidApp.prefs.video_download_folder
-                    mediaFile.samplePath = os.path.join(mediaFile.downloadFolder, mediaFile.sampleSubfolder)
-                    if mediaFile.treerowref == self.previewed_file_treerowref:
-                        self.show_preview(iter)                
-
-    def _refreshNameFactories(self):
-        sample_download_start_time = datetime.datetime.now()
-        self.imageRenamePrefsFactory = rn.ImageRenamePreferences(self.rapidApp.prefs.image_rename, self, 
-                                                                 self.rapidApp.fileSequenceLock, sequences)
-        self.imageRenamePrefsFactory.setDownloadStartTime(sample_download_start_time)
-        self.videoRenamePrefsFactory = rn.VideoRenamePreferences(self.rapidApp.prefs.video_rename, self, 
-                                                                 self.rapidApp.fileSequenceLock, sequences)
-        self.videoRenamePrefsFactory.setDownloadStartTime(sample_download_start_time)
-        self.subfolderPrefsFactory = rn.SubfolderPreferences(self.rapidApp.prefs.subfolder, self)
-        self.subfolderPrefsFactory.setDownloadStartTime(sample_download_start_time)
-        self.videoSubfolderPrefsFactory = rn.VideoSubfolderPreferences(self.rapidApp.prefs.video_subfolder, self)
-        self.videoSubfolderPrefsFactory.setDownloadStartTime(sample_download_start_time)
-        self.strip_characters = self.rapidApp.prefs.strip_characters
-        
-    
-    def refreshGeneratedSampleSubfolderAndName(self, thread_id = None):
-        """
-        Refreshes the name, subfolder and status of every file that has not yet been downloaded
-        
-        This is useful when the user updates the preferences, and the scan has already occurred (or is occurring)
+        return iter
         
-        If thread_id is specified, will only update rows with that thread
-        """
-        self._setUsesJobCode()
-        self._refreshNameFactories()
-        for iter in self.get_tree_row_iters():
-            status = self.get_status(iter)
-            if status in [STATUS_NOT_DOWNLOADED, STATUS_WARNING, STATUS_CANNOT_DOWNLOAD]:
-                regenerate = True
-                if thread_id is not None:
-                    t = self.get_thread(iter)
-                    regenerate = t == thread_id
-                
-                if regenerate:
-                    mediaFile = self.get_mediaFile(iter)
-                    self.generateSampleSubfolderAndName(mediaFile, iter)
-                    if mediaFile.treerowref == self.previewed_file_treerowref:
-                        self.show_preview(iter)
-    
-    def generateSampleSubfolderAndName(self, mediaFile, iter):
-        problem = pn.Problem()
-        if mediaFile.isImage:
-            fallback_date = None
-            subfolderPrefsFactory = self.subfolderPrefsFactory
-            renamePrefsFactory = self.imageRenamePrefsFactory
-            nameUsesJobCode = self.imageRenameUsesJobCode
-            subfolderUsesJobCode = self.imageSubfolderUsesJobCode
+    def _get_prev_iter(self, iter):
+        row = self.liststore.get_path(iter)[0]
+        if row == 0:
+            row = len(self.liststore)-1
         else:
-            fallback_date = mediaFile.modificationTime
-            subfolderPrefsFactory = self.videoSubfolderPrefsFactory
-            renamePrefsFactory = self.videoRenamePrefsFactory
-            nameUsesJobCode = self.videoRenameUsesJobCode
-            subfolderUsesJobCode = self.videoSubfolderUsesJobCode
-            
-        renamePrefsFactory.setJobCode(self.get_job_code(iter))
-        subfolderPrefsFactory.setJobCode(self.get_job_code(iter))
-        
-        generateSubfolderAndName(mediaFile, problem, subfolderPrefsFactory, renamePrefsFactory, 
-                                nameUsesJobCode, subfolderUsesJobCode,
-                                self.strip_characters, fallback_date)
-        if self.get_status(iter) != mediaFile.status:
-            self.liststore.set(iter, 11, mediaFile.status)
-            self.liststore.set(iter, 10, self.get_status_icon(mediaFile.status))
-        mediaFile.sampleStale = False
-        
-    def _setUsesJobCode(self):
-        self.imageRenameUsesJobCode = rn.usesJobCode(self.rapidApp.prefs.image_rename)
-        self.imageSubfolderUsesJobCode = rn.usesJobCode(self.rapidApp.prefs.subfolder)
-        self.videoRenameUsesJobCode = rn.usesJobCode(self.rapidApp.prefs.video_rename)
-        self.videoSubfolderUsesJobCode = rn.usesJobCode(self.rapidApp.prefs.video_subfolder)        
+            row -= 1
+        iter = self.liststore.get_iter(row)
+        return iter        
     
-    
-    def status_human_readable(self, mediaFile):
-        if mediaFile.status == STATUS_DOWNLOADED:
-            v = _('%(filetype)s was downloaded successfully') % {'filetype': mediaFile.displayNameCap}
-        elif mediaFile.status == STATUS_DOWNLOAD_FAILED:
-            v = _('%(filetype)s was not downloaded') % {'filetype': mediaFile.displayNameCap}
-        elif mediaFile.status == STATUS_DOWNLOADED_WITH_WARNING:
-            v = _('%(filetype)s was downloaded with warnings') % {'filetype': mediaFile.displayNameCap}
-        elif mediaFile.status == STATUS_BACKUP_PROBLEM:
-            v = _('%(filetype)s was downloaded but there were problems backing up') % {'filetype': mediaFile.displayNameCap}
-        elif mediaFile.status == STATUS_DOWNLOAD_AND_BACKUP_FAILED:
-            v = _('%(filetype)s was neither downloaded nor backed up') % {'filetype': mediaFile.displayNameCap}                
-        elif mediaFile.status == STATUS_NOT_DOWNLOADED:
-            v = _('%(filetype)s is ready to be downloaded') % {'filetype': mediaFile.displayNameCap}
-        elif mediaFile.status == STATUS_DOWNLOAD_PENDING:
-            v = _('%(filetype)s is about to be downloaded') % {'filetype': mediaFile.displayNameCap}
-        elif mediaFile.status == STATUS_WARNING:
-            v = _('%(filetype)s will be downloaded with warnings')% {'filetype': mediaFile.displayNameCap}
-        elif mediaFile.status == STATUS_CANNOT_DOWNLOAD:
-            v = _('%(filetype)s cannot be downloaded') % {'filetype': mediaFile.displayNameCap}
-        return v    
-        
-    def show_preview(self, iter):
-            
-        if not iter:
-            # clear everything except the label Preview at the top
-            for widget in  [self.parentApp.preview_original_name_label,
-                            self.parentApp.preview_name_label,
-                            self.parentApp.preview_status_label, 
-                            self.parentApp.preview_problem_title_label, 
-                            self.parentApp.preview_problem_label]:
-                widget.set_text('')
-                
-            for widget in  [self.parentApp.preview_image,
-                            self.parentApp.preview_name_label,
-                            self.parentApp.preview_original_name_label,
-                            self.parentApp.preview_status_label,                             
-                            self.parentApp.preview_problem_title_label,
-                            self.parentApp.preview_problem_label                            
-                            ]:
-                widget.set_tooltip_text('')
-                
-            self.parentApp.preview_image.clear()
-            self.parentApp.preview_status_icon.clear()
-            self.parentApp.preview_destination_expander.hide()
-            self.parentApp.preview_device_expander.hide()
-            self.previewed_file_treerowref = None
-            
-        
-        elif not self.suspend_previews:
-            mediaFile = self.get_mediaFile(iter)
-            
-            self.previewed_file_treerowref = mediaFile.treerowref
+    def show_next_image(self, unique_id):
+        iter = self.get_iter_from_unique_id(unique_id)
+        iter = self._get_next_iter(iter)
+
+        if iter is not None:
+            self.show_preview(iter=iter)
             
-            self.parentApp.set_base_preview_image(mediaFile.thumbnail)
-            thumbnail = self.parentApp.scaledPreviewImage()
-                
-            self.parentApp.preview_image.set_from_pixbuf(thumbnail)
+            # cache next image
+            self.advance_get_preview_image(iter, prev=False, next=True)
             
-            image_tool_tip = "%s\n%s" % (date_time_human_readable(mediaFile.dateTime(), False), common.formatSizeForUser(mediaFile.size))
-            self.parentApp.preview_image.set_tooltip_text(image_tool_tip)
-
-            if mediaFile.sampleStale and mediaFile.status in [STATUS_NOT_DOWNLOADED, STATUS_WARNING]:
-                self._refreshNameFactories()
-                self._setUsesJobCode()
-                self.generateSampleSubfolderAndName(mediaFile, iter)
-
-            self.parentApp.preview_original_name_label.set_text(mediaFile.name)
-            self.parentApp.preview_original_name_label.set_tooltip_text(mediaFile.name)
-            if mediaFile.volume:
-                pixbuf = mediaFile.volume.get_icon_pixbuf(16)
-            else:
-                pixbuf = self.icontheme.load_icon('gtk-harddisk', 16, gtk.ICON_LOOKUP_USE_BUILTIN)
-            self.parentApp.preview_device_image.set_from_pixbuf(pixbuf)
-            self.parentApp.preview_device_label.set_text(mediaFile.deviceName)
-            self.parentApp.preview_device_path_label.set_text(mediaFile.path)
-            self.parentApp.preview_device_path_label.set_tooltip_text(mediaFile.path)
+    def show_prev_image(self, unique_id):
+        iter = self.get_iter_from_unique_id(unique_id)
+        iter = self._get_prev_iter(iter)
+
+        if iter is not None:
+            self.show_preview(iter=iter)
             
-            if using_gio:
-                folder = gio.File(mediaFile.downloadFolder)
-                fileInfo = folder.query_info(gio.FILE_ATTRIBUTE_STANDARD_ICON)
-                icon = fileInfo.get_icon()
-                pixbuf = common.get_icon_pixbuf(using_gio, icon, 16, fallback='folder')
-            else:
-                pixbuf = self.icontheme.load_icon('folder', 16, gtk.ICON_LOOKUP_USE_BUILTIN)
-                
-            self.parentApp.preview_destination_image.set_from_pixbuf(pixbuf)
-            downloadFolderName = os.path.split(mediaFile.downloadFolder)[1]            
-            self.parentApp.preview_destination_label.set_text(downloadFolderName)
+            # cache next image
+            self.advance_get_preview_image(iter, prev=True, next=False)
 
-            if mediaFile.status in [STATUS_WARNING, STATUS_CANNOT_DOWNLOAD, STATUS_NOT_DOWNLOADED, STATUS_DOWNLOAD_PENDING]:
-                
-                self.parentApp.preview_name_label.set_text(mediaFile.sampleName)
-                self.parentApp.preview_name_label.set_tooltip_text(mediaFile.sampleName)
-                self.parentApp.preview_destination_path_label.set_text(mediaFile.samplePath)
-                self.parentApp.preview_destination_path_label.set_tooltip_text(mediaFile.samplePath)
-            else:
-                self.parentApp.preview_name_label.set_text(mediaFile.downloadName)
-                self.parentApp.preview_name_label.set_tooltip_text(mediaFile.downloadName)
-                self.parentApp.preview_destination_path_label.set_text(mediaFile.downloadPath)
-                self.parentApp.preview_destination_path_label.set_tooltip_text(mediaFile.downloadPath)
             
-            status_text = self.status_human_readable(mediaFile)
-            self.parentApp.preview_status_icon.set_from_pixbuf(self.get_status_icon(mediaFile.status, preview=True))
-            self.parentApp.preview_status_label.set_markup('<b>' + status_text + '</b>')
-            self.parentApp.preview_status_label.set_tooltip_text(status_text)
-
-
-            if mediaFile.status in [STATUS_WARNING, STATUS_DOWNLOAD_FAILED,
-                                    STATUS_DOWNLOADED_WITH_WARNING, 
-                                    STATUS_CANNOT_DOWNLOAD, 
-                                    STATUS_BACKUP_PROBLEM, 
-                                    STATUS_DOWNLOAD_AND_BACKUP_FAILED]:
-                problem_title = mediaFile.problem.get_title()
-                self.parentApp.preview_problem_title_label.set_markup('<i>' + problem_title + '</i>')
-                self.parentApp.preview_problem_title_label.set_tooltip_text(problem_title)
-                
-                problem_text = mediaFile.problem.get_problems()
-                self.parentApp.preview_problem_label.set_text(problem_text)
-                self.parentApp.preview_problem_label.set_tooltip_text(problem_text)
-            else:
-                self.parentApp.preview_problem_label.set_markup('')
-                self.parentApp.preview_problem_title_label.set_markup('')
-                for widget in  [self.parentApp.preview_problem_title_label,
-                                self.parentApp.preview_problem_label
-                                ]:
-                    widget.set_tooltip_text('')                
-                
-            if self.rapidApp.prefs.display_preview_folders:
-                self.parentApp.preview_destination_expander.show()
-                self.parentApp.preview_device_expander.show()
+    def advance_get_preview_image(self, iter, prev=True, next=True):
+        unique_ids = []
+        if next:
+            next_iter = self._get_next_iter(iter)
+            unique_ids.append(self.get_unique_id_from_iter(next_iter))
             
-    
-    def select_rows(self, range):
-        selection = self.get_selection()
-        if range == 'all':
-            selection.select_all()
-        elif range == 'none':
-            selection.unselect_all()
-        else:
-            # User chose to select all photos or all videos,
-            # or select all files with or without job codes.
-
-            # Temporarily suspend previews while a large number of rows
-            # are being selected / unselected
-            self.suspend_previews = True
+        if prev:
+            prev_iter = self._get_prev_iter(iter)
+            unique_ids.append(self.get_unique_id_from_iter(prev_iter))
             
-            iter = self.liststore.get_iter_first()
-            while iter is not None:
-                if range in ['photos', 'videos']:
-                    type = self.get_is_image(iter)
-                    select_row = (type and range == 'photos') or (not type and range == 'videos')
-                else:
-                    job_code = self.get_job_code(iter)
-                    select_row = (job_code and range == 'withjobcode') or (not job_code and range == 'withoutjobcode')
-
-                if select_row:
-                    selection.select_iter(iter)
+        for unique_id in unique_ids:
+            if not unique_id in self.previews:
+                rpd_file = self.rpd_files[unique_id]
+                self._get_preview(unique_id, rpd_file)
+            
+    def check_all(self, check_all, file_type=None):
+        for row in self.liststore:
+            if row[self.CHECKBUTTON_VISIBLE_COL]:
+                if file_type is not None:
+                    if row[self.FILETYPE_COL] == file_type:
+                        row[self.SELECTED_COL] = check_all
                 else:
-                    selection.unselect_iter(iter)
-                iter = self.liststore.iter_next(iter)
+                    row[self.SELECTED_COL] = check_all
+        self.rapid_app.set_download_action_sensitivity()
             
-            self.suspend_previews = False
-            # select the first photo / video
-            iter = self.liststore.get_iter_first()
-            while iter is not None:
-                type = self.get_is_image(iter)
-                if (type and range == 'photos') or (not type and range == 'videos'):
-                    self.show_preview(iter)
-                    break
-                iter = self.liststore.iter_next(iter)
-
-
-    def header_clicked(self, column):
-        self.user_has_clicked_header = True
-        
-    def display_filename_column(self, display):
+    def files_are_checked_to_download(self):
         """
-        if display is true, the column will be shown
-        otherwise, it will not be shown
+        Returns True if there is any file that the user has indicated they
+        intend to download, else returns False.
         """
-        self.filename_column.set_visible(display)
-        
-    def display_size_column(self, display):
-        self.size_column.set_visible(display)
-
-    def display_type_column(self, display):
-        if not DOWNLOAD_VIDEO:
-            self.type_column.set_visible(False)
-        else:
-            self.type_column.set_visible(display)
-        
-    def display_path_column(self, display):
-        self.path_column.set_visible(display)
-        
-    def display_device_column(self, display):
-        self.device_column.set_visible(display)
+        for row in self.liststore:
+            if row[self.SELECTED_COL]:
+                rpd_file = self.rpd_files[row[self.UNIQUE_ID_COL]]
+                if rpd_file.status not in DOWNLOADED:
+                    return True
+        return False
         
-    def apply_job_code(self, job_code, overwrite=True, to_all_rows=False, thread_id=None):
+    def get_files_checked_for_download(self):
         """
-        Applies the Job code to the selected rows, or all rows if to_all_rows is True.
-        
-        If overwrite is True, then it will overwrite any existing job code.
+        Returns a dict of scan ids and associated files the user has indicated
+        they want to download
         """
-
-        def _apply_job_code():
-            status = self.get_status(iter)
-            if status in [STATUS_DOWNLOAD_PENDING, STATUS_WARNING, STATUS_NOT_DOWNLOADED]:
-                
-                if mediaFile.isImage:
-                    apply = rn.usesJobCode(self.rapidApp.prefs.image_rename) or rn.usesJobCode(self.rapidApp.prefs.subfolder)
-                else:
-                    apply = rn.usesJobCode(self.rapidApp.prefs.video_rename) or rn.usesJobCode(self.rapidApp.prefs.video_subfolder)
-                if apply:
-                    if overwrite:
-                        self.liststore.set(iter, 8, job_code)
-                        mediaFile.jobcode = job_code
-                        mediaFile.sampleStale = True
+        files = dict()
+        for row in self.liststore:
+            if row[self.SELECTED_COL]:
+                rpd_file = self.rpd_files[row[self.UNIQUE_ID_COL]]
+                if rpd_file.status not in DOWNLOADED:
+                    scan_pid = rpd_file.scan_pid
+                    if scan_pid in files:
+                        files[scan_pid].append(rpd_file)
                     else:
-                        if not self.get_job_code(iter):
-                            self.liststore.set(iter, 8, job_code)
-                            mediaFile.jobcode = job_code
-                            mediaFile.sampleStale = True
-                else:
-                    pass
-                    #if they got an existing job code, may as well keep it there in case the user 
-                    #reactivates job codes again in their prefs
-                    
-        if to_all_rows or thread_id is not None:
-            for iter in self.get_tree_row_iters():
-                apply = True
-                if thread_id is not None:
-                    t = self.get_thread(iter)
-                    apply = t == thread_id
+                        files[scan_pid] = [rpd_file,]
                     
-                if apply:
-                    mediaFile = self.get_mediaFile(iter)
-                    _apply_job_code()
-                    if mediaFile.treerowref == self.previewed_file_treerowref:
-                        self.show_preview(iter)
-        else:
-            for iter in self.get_tree_row_iters(selected_only = True):
-                mediaFile = self.get_mediaFile(iter)
-                _apply_job_code()
-                if mediaFile.treerowref == self.previewed_file_treerowref:
-                    self.show_preview(iter)
-            
-    def job_code_missing(self, selected_only):
+        return files
+                
+
+    def mark_download_pending(self, files_by_scan_pid):
         """
-        Returns True if any of the pending downloads do not have a 
-        job code assigned.
-        
-        If selected_only is True, will only check in rows that the 
-        user has selected.
+        Sets status to download pending and updates thumbnails display
         """
+        for scan_pid in files_by_scan_pid:
+            for rpd_file in files_by_scan_pid[scan_pid]:
+                unique_id = rpd_file.unique_id
+                self.rpd_files[unique_id].status = STATUS_DOWNLOAD_PENDING
+                iter = self.get_iter_from_unique_id(unique_id)
+                self.liststore.set_value(iter, self.CHECKBUTTON_VISIBLE_COL, False)
+                self.liststore.set_value(iter, self.SELECTED_COL, False)
+                self.liststore.set_value(iter, self.DOWNLOAD_STATUS_COL, STATUS_DOWNLOAD_PENDING)
+                icon = self.get_status_icon(STATUS_DOWNLOAD_PENDING)
+                self.liststore.set_value(iter, self.STATUS_ICON_COL, icon)
+                
+    def select_image(self, unique_id):
+        iter = self.get_iter_from_unique_id(unique_id)
+        path = self.liststore.get_path(iter)
+        self.select_path(path)
+        self.scroll_to_path(path, use_align=False, row_align=0.5, col_align=0.5)
         
-        def _job_code_missing(iter):
-            status = self.get_status(iter)
-            if status in [STATUS_WARNING, STATUS_NOT_DOWNLOADED]:
-                is_image = self.get_is_image(iter)
-                job_code = self.get_job_code(iter)
-                return needAJobCode.needAJobCode(job_code, is_image)
-            return False
-        
-        self._setUsesJobCode()
-        needAJobCode = NeedAJobCode(self.rapidApp.prefs)
-        
-        v = False
-        if selected_only:
-            selection = self.get_selection()
-            model, pathlist = selection.get_selected_rows()
-            for path in pathlist:
-                iter = self.liststore.get_iter(path)
-                v = _job_code_missing(iter)
-                if v:
-                    break
+    def get_stock_icon(self, file_type):
+        if file_type == rpdfile.FILE_TYPE_PHOTO:
+            return self.stock_photo_thumbnails.stock_thumbnail_image_icon
         else:
-            iter = self.liststore.get_iter_first()
-            while iter:
-                v = _job_code_missing(iter)
-                if v:
-                    break
-                iter = self.liststore.iter_next(iter)
-        return v
-
+            return self.stock_video_thumbnails.stock_thumbnail_image_icon
+            
+    def update_status_post_download(self, rpd_file):
+        iter = self.get_iter_from_unique_id(rpd_file.unique_id)
+        self.liststore.set_value(iter, self.DOWNLOAD_STATUS_COL, rpd_file.status)
+        icon = self.get_status_icon(rpd_file.status)
+        self.liststore.set_value(iter, self.STATUS_ICON_COL, icon)
+        self.rpd_files[rpd_file.unique_id] = rpd_file
+            
+    def generate_thumbnails(self, scan_pid):
+        """Initiate thumbnail generation for files scanned in one process
+        """
+        rpd_files = [self.rpd_files[unique_id] for unique_id in self.process_index[scan_pid]]
+        self.thumbnail_manager.add_task(rpd_files)
     
-    def _set_download_pending(self, iter, threads):
-        existing_status = self.get_status(iter)
-        if existing_status in [STATUS_WARNING, STATUS_NOT_DOWNLOADED]:
-            self.liststore.set(iter, 11, STATUS_DOWNLOAD_PENDING)
-            self.liststore.set(iter, 10, self.download_pending_icon)
-            # this value is in a thread's list of files to download
-            mediaFile = self.get_mediaFile(iter)
-            # each thread will see this change in status
-            mediaFile.status = STATUS_DOWNLOAD_PENDING
-            thread = self.get_thread(iter)
-            if thread not in threads:
-                threads.append(thread)
-        
-    def set_status_to_download_pending(self, selected_only, thread_id=None):
+    def update_thumbnail(self, thumbnail_data):
         """
-        Sets status of files to be download pending, if they are waiting to be downloaded
-        if selected_only is true, only applies to selected rows
-        
-        If thread_id is not None, then after the statuses have been set, 
-        the thread will be restarted (this is intended for the cases
-        where this method is called from a thread and auto start is True)
+        Takes the generated thumbnail and updates the display
         
-        Returns a list of threads which can be downloaded
+        If the thumbnail_data includes a second image, that is used to
+        update the thumbnail list using the unique_id
         """
-        threads = []
+        unique_id = thumbnail_data[0]
+        thumbnail_icon = thumbnail_data[1]
         
-        if selected_only:
-            for iter in self.get_tree_row_iters(selected_only = True):
-                self._set_download_pending(iter, threads)
-        else:
-            for iter in self.get_tree_row_iters():
-                apply = True                
-                if thread_id is not None:
-                    t = self.get_thread(iter)
-                    apply = t == thread_id
-                if apply:                
-                    self._set_download_pending(iter, threads)
-                
-            if thread_id is not None:
-                # restart the thread
-                workers[thread_id].startStop()
-        return threads
-                
-    def update_status_post_download(self, treerowref):
-        path = treerowref.get_path()
-        if not path:
-            sys.stderr.write("FIXME: SelectionTreeView treerowref no longer refers to valid row\n")
-        else:
+        if thumbnail_icon is not None:
+            # get the thumbnail icon in PIL format
+            thumbnail_icon = thumbnail_icon.get_image()
+            
+            treerowref = self.treerow_index[unique_id]
+            path = treerowref.get_path()
             iter = self.liststore.get_iter(path)
-            mediaFile = self.get_mediaFile(iter)
-            status = mediaFile.status
-            self.liststore.set(iter, 11, status)
-            self.liststore.set(iter, 10, self.get_status_icon(status))
             
-            # If this row is currently previewed, then should update the preview
-            if mediaFile.treerowref == self.previewed_file_treerowref:
-                self.show_preview(iter)
-
-
-class SelectionVBox(gtk.VBox):
-    """
-    Dialog from which the user can select photos and videos to download
-    """
+            if thumbnail_icon:
+                self.liststore.set(iter, 0, thumbnail_icon)
+                
+            if len(thumbnail_data) > 2:
+                # get the 2nd image in PIL format
+                self.thumbnails[unique_id] = thumbnail_data[2].get_image()
 
-    
-    def __init__(self, parentApp):
-        """
-        Initialize values for log dialog, but do not display.
-        """
+            
+    def thumbnail_results(self, source, condition):
+        connection = self.thumbnail_manager.get_pipe(source)
         
-        gtk.VBox.__init__(self)
-        self.parentApp = parentApp
+        conn_type, data = connection.recv()
         
-        tiny_screen = TINY_SCREEN
-        if tiny_screen:
-            config.max_thumbnail_size = 160
+        if conn_type == rpdmp.CONN_COMPLETE:
+            connection.close()
+            return False
+        else:
+            
+            for thumbnail_data in data:
+                self.update_thumbnail(thumbnail_data)
+            
+            self.thumbnails_generated += len(data)
+            
+            # clear progress bar information if all thumbnails have been
+            # extracted
+            if self.thumbnails_generated == self.total_files:
+                self.rapid_app.download_progressbar.set_fraction(0.0)
+                self.rapid_app.download_progressbar.set_text('')
+            else:
+                self.rapid_app.download_progressbar.set_fraction(
+                    float(self.thumbnails_generated) / self.total_files)
+            
         
-        selection_scrolledwindow = gtk.ScrolledWindow()
-        selection_scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
-        selection_viewport = gtk.Viewport()
+        return True
         
+    def preview_results(self, unique_id, preview_full_size, preview_small):
+        """
+        Receive a full size preview image and update
+        """
+        self.previews_being_fetched.remove(unique_id)
+        if preview_full_size:
+            preview_image = preview_full_size.get_image()
+            self.previews[unique_id] = preview_image
+            self.rapid_app.update_preview_image(unique_id, preview_image)
+                    
+    
+    def clear_all(self, scan_pid=None, keep_downloaded_files=False):
+        """
+        Removes files from display and internal tracking.
         
-        self.selection_treeview = SelectionTreeView(self)
+        If scan_pid is not None, then only files matching that scan_pid will
+        be removed. Otherwise, everything will be removed.
         
-        selection_scrolledwindow.add(self.selection_treeview)
-
+        If keep_downloaded_files is True, files will not be removed if they
+        have been downloaded.
+        """
+        if scan_pid is None and not keep_downloaded_files:
+            self.liststore.clear()
+            self.treerow_index = {}
+            self.process_index = {}
+            
+            self.rpd_files = {}
+        else:
+            if scan_pid in self.process_index:
+                for unique_id in self.process_index[scan_pid]:
+                    rpd_file = self.rpd_files[unique_id]
+                    if not keep_downloaded_files or not rpd_file.status in DOWNLOADED:
+                        treerowref = self.treerow_index[rpd_file.unique_id]
+                        path = treerowref.get_path()
+                        iter = self.liststore.get_iter(path)
+                        self.liststore.remove(iter)
+                        del self.treerow_index[rpd_file.unique_id]
+                        del self.rpd_files[rpd_file.unique_id]
+                if not keep_downloaded_files or not len(self.process_index[scan_pid]):
+                    del self.process_index[scan_pid]
+    
+class TaskManager:
+    def __init__(self, results_callback, batch_size):
+        self.results_callback = results_callback
+        
+        # List of actual process, it's terminate_queue, and it's run_event
+        self._processes = []
+        
+        self._pipes = {}
+        self.batch_size = batch_size
+        
+        self.paused = False
+       
+    
+    def add_task(self, task):
+        pid = self._setup_task(task)
+        return pid
 
-        # Job code controls
-        self.add_job_code_combo()
-        left_pane_vbox = gtk.VBox(spacing = 12)
-        left_pane_vbox.pack_start(selection_scrolledwindow, True, True)
-        left_pane_vbox.pack_start(self.job_code_hbox, False, True)
-                
-        # Window sizes
-        #selection_scrolledwindow.set_size_request(350, -1)
         
+    def _setup_task(self, task):
+        task_results_conn, task_process_conn = Pipe(duplex=False)
         
-        # Preview pane
+        source = task_results_conn.fileno()
+        self._pipes[source] = task_results_conn
+        gobject.io_add_watch(source, gobject.IO_IN, self.results_callback)
         
-        # Zoom in and out slider (make the image bigger / smaller)
+        terminate_queue = Queue()
+        run_event = Event()
+        run_event.set()
         
-        # Zoom out (on the left of the slider)
-        self.zoom_out_eventbox = gtk.EventBox()
-        self.zoom_out_eventbox.set_events(gtk.gdk.BUTTON_PRESS_MASK)        
-        self.zoom_out_image = gtk.Image()
-        self.zoom_out_image.set_from_file(paths.share_dir('glade3/zoom-out.png'))
-        self.zoom_out_eventbox.add(self.zoom_out_image)
-        self.zoom_out_eventbox.connect("button_press_event", self.zoom_out_0_callback)
+        return self._initiate_task(task, task_process_conn, terminate_queue, run_event)
         
-        # Zoom in (on the right of the slider)
-        self.zoom_in_eventbox = gtk.EventBox()
-        self.zoom_in_eventbox.set_events(gtk.gdk.BUTTON_PRESS_MASK)
-        self.zoom_in_image = gtk.Image()
-        self.zoom_in_image.set_from_file(paths.share_dir('glade3/zoom-in.png'))
-        self.zoom_in_eventbox.add(self.zoom_in_image)
-        self.zoom_in_eventbox.connect("button_press_event", self.zoom_in_100_callback)
+    def _initiate_task(self, task, task_process_conn, terminate_queue, run_event):
+        logger.error("Implement child class method!")
         
-        self.slider_adjustment = gtk.Adjustment(value=self.parentApp.prefs.preview_zoom, 
-                lower=config.MIN_THUMBNAIL_SIZE, upper=config.max_thumbnail_size, 
-                step_incr=1.0, page_incr=config.THUMBNAIL_INCREMENT, page_size=0)
-        self.slider_adjustment.connect("value_changed", self.resize_image_callback)
-        self.slider_hscale = gtk.HScale(self.slider_adjustment)
-        self.slider_hscale.set_draw_value(False) # don't display numeric value
-        self.slider_hscale.set_size_request(config.MIN_THUMBNAIL_SIZE * 2, -1)
+    
+    def processes(self):
+        for i in range(len(self._processes)):
+            yield self._processes[i]        
+    
+    def start(self):
+        self.paused = False
+        for scan in self.processes():
+            run_event = scan[2]
+            if not run_event.is_set():
+                run_event.set()
+                
+    def pause(self):
+        self.paused = True
+        for scan in self.processes():
+            run_event = scan[2]
+            if run_event.is_set():
+                run_event.clear()
+    
+    def request_termination(self):
+        """
+        Send a signal to processes that they should immediately terminate
+        """
+        requested = False
+        for p in self.processes():
+            if p[0].is_alive():
+                requested = True
+                p[1].put(None)
+                # The process might be paused: let it run
+                run_event = p[2]
+                if not run_event.is_set():
+                    run_event.set()
+                    
+        return requested
+    
+    def terminate_forcefully(self):
+        """
+        Forcefully terminates any running processes. Use with great caution.
+        No cleanup action is performed. 
         
+        As python essential reference (4th edition) says, if the process
+        'holds a lock or is involved with interprocess communication,
+        terminating it might cause a deadlock or corrupted I/O.'
+        """
         
-        #Preview image
-        self.base_preview_image = None # large size image used to scale down from
-        self.preview_image = gtk.Image()
+        for p in self.processes():
+            if p[0].is_alive():
+                p[0].terminate()
 
-        self.preview_image.set_alignment(0, 0.5)
-        #leave room for thumbnail shadow
-        if DROP_SHADOW:
-            self.cacheDropShadow()
-        else:
-            self.shadow_size = 0
+            
+    def get_pipe(self, source):
+        return self._pipes[source]
         
-        image_size, shadow_size, offset = self._imageAndShadowSize()
+    def get_no_active_processes(self):
+        """
+        Returns how many processes are currently active, i.e. running
+        """
+        i = 0
+        for p in self.processes():
+            if p[0].is_alive():
+                i += 1
+        return i
+
+
+class ScanManager(TaskManager):
+    
+    def __init__(self, results_callback, batch_size, generate_folder,
+                 add_device_function):
+        TaskManager.__init__(self, results_callback, batch_size)
+        self.add_device_function = add_device_function
+        self.generate_folder = generate_folder
         
-        self.preview_image.set_size_request(image_size, image_size)
+    def _initiate_task(self, device, task_process_conn, terminate_queue, run_event):
+        scan = scan_process.Scan(device.get_path(), self.batch_size, self.generate_folder, 
+                                task_process_conn, terminate_queue, run_event)
+        scan.start()
+        self._processes.append((scan, terminate_queue, run_event))
+        self.add_device_function(scan.pid, device, 
+            # This refers to when a device like a hard drive is having its contents scanned,
+            # looking for photos or videos. It is visible initially in the progress bar for each device 
+            # (which normally holds "x photos and videos").
+            # It maybe displayed only briefly if the contents of the device being scanned is small.
+            progress_bar_text=_('scanning...'))
+            
+        return scan.pid
+            
+class CopyFilesManager(TaskManager):
+    
+    def _initiate_task(self, task, task_process_conn, terminate_queue, run_event):
+        photo_download_folder = task[0]
+        video_download_folder = task[1]
+        scan_pid = task[2]
+        files = task[3]
         
-        #labels to display file information
+        copy_files = copyfiles.CopyFiles(photo_download_folder,
+                                video_download_folder,
+                                files, scan_pid, self.batch_size, 
+                                task_process_conn, terminate_queue, run_event)
+        copy_files.start()
+        self._processes.append((copy_files, terminate_queue, run_event))
+        return copy_files.pid
         
-        #Original filename
-        self.preview_original_name_label = gtk.Label()
-        self.preview_original_name_label.set_alignment(0, 0.5)
-        self.preview_original_name_label.set_ellipsize(pango.ELLIPSIZE_END)
+class ThumbnailManager(TaskManager):
         
+    def _initiate_task(self, files, task_process_conn, terminate_queue, run_event):
+        generator = tn.GenerateThumbnails(files, self.batch_size, task_process_conn, terminate_queue, run_event)
+        generator.start()
+        self._processes.append((generator, terminate_queue, run_event))
+        return generator.pid
+
+
+class SingleInstanceTaskManager:
+    """
+    Base class to manage single instance processes. Examples are daemon
+    processes, but also a non-daemon process that has one simple task.
+    
+    Core (infrastructure) functionality is implemented in this class.
+    Derived classes should implemented functionality to actually implement
+    specific tasks.
+    """
+    def __init__(self, results_callback):    
+        self.results_callback = results_callback
         
-        #Device (where it will be downloaded from)
-        self.preview_device_expander = gtk.Expander()
-        self.preview_device_label = gtk.Label()
-        self.preview_device_label.set_alignment(0, 0.5)
-        self.preview_device_image = gtk.Image()
+        self.task_results_conn, self.task_process_conn = Pipe(duplex=True)
         
-        self.preview_device_path_label = gtk.Label()
-        self.preview_device_path_label.set_alignment(0, 0.5)
-        self.preview_device_path_label.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
-        self.preview_device_path_label.set_padding(30, 0)
-        self.preview_device_expander.add(self.preview_device_path_label)
+        source = self.task_results_conn.fileno()
+        gobject.io_add_watch(source, gobject.IO_IN, self.task_results)
+
         
-        device_hbox = gtk.HBox(False, spacing = 6)
-        device_hbox.pack_start(self.preview_device_image)
-        device_hbox.pack_start(self.preview_device_label, True, True)
+class PreviewManager(SingleInstanceTaskManager):
+    def __init__(self, results_callback):
+        SingleInstanceTaskManager.__init__(self, results_callback)
+        self._get_preview = tn.GetPreviewImage(self.task_process_conn)
+        self._get_preview.start()
         
-        self.preview_device_expander.set_label_widget(device_hbox)
+    def get_preview(self, unique_id, full_file_name, file_type, size_max):
+        self.task_results_conn.send((unique_id, full_file_name, file_type, size_max))
         
-        #Filename that has been generated
-        self.preview_name_label = gtk.Label()
-        self.preview_name_label.set_alignment(0, 0.5)
-        self.preview_name_label.set_ellipsize(pango.ELLIPSIZE_END)
+    def task_results(self, source, condition):
+        unique_id, preview_full_size, preview_small = self.task_results_conn.recv()
+        self.results_callback(unique_id, preview_full_size, preview_small)
+        return True 
         
-        #Download destination
-        self.preview_destination_expander = gtk.Expander()
-        self.preview_destination_label = gtk.Label()
-        self.preview_destination_label.set_alignment(0, 0.5)
-        self.preview_destination_image = gtk.Image()
+class SubfolderFileManager(SingleInstanceTaskManager):
+    """
+    Manages the daemon process that renames files and creates subfolders
+    """
+    def __init__(self, results_callback, sequence_values):
+        SingleInstanceTaskManager.__init__(self, results_callback)
+        self._subfolder_file = subfolderfile.SubfolderFile(self.task_process_conn, sequence_values)
+        self._subfolder_file.start()
+        
+    def rename_file_and_move_to_subfolder(self, download_succeeded, 
+            download_count, rpd_file):
+                                              
+        self.task_results_conn.send((download_succeeded, download_count, 
+            rpd_file))
+        logger.debug("Download count: %s.", download_count)
+        
+
+    def task_results(self, source, condition):
+        move_succeeded, rpd_file = self.task_results_conn.recv()
+        self.results_callback(move_succeeded, rpd_file)
+        return True
         
-        self.preview_destination_path_label = gtk.Label()
-        self.preview_destination_path_label.set_alignment(0, 0.5)
-        self.preview_destination_path_label.set_ellipsize(pango.ELLIPSIZE_MIDDLE)        
-        self.preview_destination_path_label.set_padding(30, 0)
-        self.preview_destination_expander.add(self.preview_destination_path_label)
 
-        destination_hbox = gtk.HBox(False, spacing = 6)
-        destination_hbox.pack_start(self.preview_destination_image)
-        destination_hbox.pack_start(self.preview_destination_label, True, True)
-        
-        self.preview_destination_expander.set_label_widget(destination_hbox)
 
+class ResizblePilImage(gtk.DrawingArea):
+    def __init__(self, bg_color=None):
+        gtk.DrawingArea.__init__(self)
+        self.base_image = None
+        self.bg_color = bg_color
+        self.connect('expose_event', self.expose)
         
-        #Status of the file
+    def set_image(self, image):
+        self.base_image = image
         
-        self.preview_status_icon = gtk.Image()
-        self.preview_status_icon.set_size_request(16,16)
-
-        self.preview_status_label = gtk.Label()
-        self.preview_status_label.set_alignment(0, 0.5)
-        self.preview_status_label.set_ellipsize(pango.ELLIPSIZE_END)
-        self.preview_status_label.set_padding(12, 0)
-
-        #Title of problems encountered in generating the name / subfolder
-        self.preview_problem_title_label = gtk.Label()
-        self.preview_problem_title_label.set_alignment(0, 0.5)
-        self.preview_problem_title_label.set_ellipsize(pango.ELLIPSIZE_END)
-        self.preview_problem_title_label.set_padding(12, 0)
+        #set up sizes and ratio used for drawing the derived image
+        self.base_image_w = self.base_image.size[0]
+        self.base_image_h = self.base_image.size[1]
+        self.base_image_aspect = float(self.base_image_w) / self.base_image_h
         
-        #Details of what the problem(s) are
-        self.preview_problem_label = gtk.Label()
-        self.preview_problem_label.set_alignment(0, 0)
-        self.preview_problem_label.set_line_wrap(True)
-        self.preview_problem_label.set_padding(12, 0)
-        #Can't combine wrapping and ellipsize, sadly
-        #self.preview_problem_label.set_ellipsize(pango.ELLIPSIZE_END)
-                
-        #Put content into table
-        # Use a table so we can do the Gnome HIG layout more easily
-        self.preview_table = gtk.Table(10, 4)
-        self.preview_table.set_row_spacings(12)
-        left_spacer = gtk.Label('')
-        left_spacer.set_padding(12, 0)
-        right_spacer = gtk.Label('')
-        right_spacer.set_padding(6, 0)
-        
-
-        spacer2 = gtk.Label('')
-        
-        #left and right spacers
-        self.preview_table.attach(left_spacer, 0, 1, 1, 2, xoptions=gtk.SHRINK, yoptions=gtk.SHRINK)
-        self.preview_table.attach(right_spacer, 3, 4, 1, 2, xoptions=gtk.SHRINK, yoptions=gtk.SHRINK)
-        
-        row = 0
-        zoom_hbox = gtk.HBox()
-        zoom_hbox.pack_start(self.zoom_out_eventbox, False, False)
-        zoom_hbox.pack_start(self.slider_hscale, False, False)
-        zoom_hbox.pack_start(self.zoom_in_eventbox, False, False)
-        
-        self.preview_table.attach(zoom_hbox, 1, 3, row, row+1, yoptions=gtk.SHRINK)
-        
-        row += 1
-        self.preview_table.attach(self.preview_image, 1, 3, row, row+1, yoptions=gtk.SHRINK)
-        row += 1
-        
-        self.preview_table.attach(self.preview_original_name_label, 1, 3, row, row+1, xoptions=gtk.EXPAND|gtk.FILL, yoptions=gtk.SHRINK)
-        row += 1
-        if not tiny_screen:
-            self.preview_table.attach(self.preview_device_expander, 1, 3, row, row+1, xoptions=gtk.EXPAND|gtk.FILL, yoptions=gtk.SHRINK)
-            row += 1
-        
-        self.preview_table.attach(self.preview_name_label, 1, 3, row, row+1, xoptions=gtk.EXPAND|gtk.FILL, yoptions=gtk.SHRINK)
-        row += 1
-        if not tiny_screen:
-            self.preview_table.attach(self.preview_destination_expander, 1, 3, row, row+1, xoptions=gtk.EXPAND|gtk.FILL, yoptions=gtk.SHRINK)
-            row += 1
-
-        if not tiny_screen:
-            self.preview_table.attach(spacer2, 0, 7, row, row+1, yoptions=gtk.SHRINK)
-            row += 1
-        
-        self.preview_table.attach(self.preview_status_icon, 1, 2, row, row+1, xoptions=gtk.SHRINK, yoptions=gtk.SHRINK)
-        self.preview_table.attach(self.preview_status_label, 2, 3, row, row+1, yoptions=gtk.SHRINK)
-        row += 1
-        
-        self.preview_table.attach(self.preview_problem_title_label, 2, 3, row, row+1, yoptions=gtk.SHRINK)
-        row += 1
-        self.preview_table.attach(self.preview_problem_label, 2, 4, row, row+1, xoptions=gtk.EXPAND|gtk.FILL, yoptions=gtk.EXPAND|gtk.FILL)
-        row += 1
-        
-        self.file_hpaned = gtk.HPaned()
-        self.file_hpaned.pack1(left_pane_vbox, shrink=False)
-        self.file_hpaned.pack2(self.preview_table, resize=True, shrink=False)
-        self.pack_start(self.file_hpaned, True, True)
-        if self.parentApp.prefs.hpaned_pos > 0:
-            self.file_hpaned.set_position(self.parentApp.prefs.hpaned_pos)
-        else:
-            # this is what the user will see the first time they run the app
-            self.file_hpaned.set_position(300)
+        self.queue_draw()
+        
+    def expose(self, widget, event):
 
-        self.show_all()
-    
-    
-    def set_base_preview_image(self, pixbuf):
-        """
-        sets the unscaled pixbuf image to be displayed to the user
-        the actual image the user will see will depend on the scale
-        they've set to view it at
-        """
-        self.base_preview_image = pixbuf
+        cairo_context = self.window.cairo_create()
         
-    def zoom_in(self):
-        self.slider_adjustment.set_value(min([config.max_thumbnail_size, int(self.slider_adjustment.get_value()) + config.THUMBNAIL_INCREMENT]))
+        x = event.area.x 
+        y = event.area.y 
+        w = event.area.width
+        h = event.area.height
         
-    def zoom_out(self):
-        self.slider_adjustment.set_value(max([config.MIN_THUMBNAIL_SIZE, int(self.slider_adjustment.get_value()) - config.THUMBNAIL_INCREMENT]))
-    
-    def zoom_in_100_callback(self, widget, value):
-        self.slider_adjustment.set_value(config.max_thumbnail_size)
+        #constrain operations to event area 
+        cairo_context.rectangle(x, y, w, h)
+        cairo_context.clip_preserve()
         
-    def zoom_out_0_callback(self, widget, value):
-        self.slider_adjustment.set_value(config.MIN_THUMBNAIL_SIZE)
-    
-    def set_display_preview_folders(self, value):
-        if value and self.selection_treeview.previewed_file_treerowref:
-            self.preview_destination_expander.show()
-            self.preview_device_expander.show()
+        #set background color, if needed
+        if self.bg_color:
+            cairo_context.set_source_rgb(*self.bg_color)
+            cairo_context.fill_preserve()        
 
-        else:
-            self.preview_destination_expander.hide()
-            self.preview_device_expander.hide()
+        if not self.base_image:
+            return False
             
-    def cacheDropShadow(self):
-        i, self.shadow_size, offset_v = self._imageAndShadowSize()
-        self.drop_shadow = DropShadow(offset=(offset_v,offset_v), shadow = (0x44, 0x44, 0x44, 0xff), border=self.shadow_size, trim_border = True)
-        
-    def _imageAndShadowSize(self):
-        image_size = int(self.slider_adjustment.get_value())
-        offset_v = max([image_size / 25, 5]) # realistically size the shadow based on the size of the image
-        shadow_size = offset_v + 3
-        image_size = image_size + offset_v * 2 + 3
-        return (image_size, shadow_size, offset_v)
-    
-    def resize_image_callback(self, adjustment):
-        """
-        Resize the preview image after the adjustment value has been
-        changed
-        """
-        size = int(adjustment.value)
-        self.parentApp.prefs.preview_zoom = size
-        self.cacheDropShadow()
-        
-        pixbuf = self.scaledPreviewImage()
-        if pixbuf:
-            self.preview_image.set_from_pixbuf(pixbuf)
-            size = max([pixbuf.get_width(), pixbuf.get_height()])
-            self.preview_image.set_size_request(size, size)
-        else:    
-            self.preview_image.set_size_request(size + self.shadow_size, size + self.shadow_size)
-        
-    def scaledPreviewImage(self):
-        """
-        Generate a scaled version of the preview image
-        """
-        size = int(self.slider_adjustment.get_value())
-        if not self.base_preview_image:
-            return None
+        frame_aspect = float(w) / h
+        
+        if frame_aspect > self.base_image_aspect:
+            # Frame is wider than image
+            height = h
+            width = int(height * self.base_image_aspect)
         else:
-            pixbuf = common.scale2pixbuf(size, size, self.base_preview_image)
+            # Frame is taller than image
+            width = w
+            height = int(width / self.base_image_aspect)
             
-            if DROP_SHADOW: 
-                pil_image = pixbuf_to_image(pixbuf)
-                pil_image = self.drop_shadow.dropShadow(pil_image) 
-                pixbuf = image_to_pixbuf(pil_image)
-            
-            return pixbuf
-    
-    def set_job_code_display(self):
-        """
-        Shows or hides the job code entry
+        #resize image
+        pil_image = self.base_image.copy()
+        if self.base_image_w < width or self.base_image_h < height:
+            logger.debug("Upsizing image")
+            pil_image = tn.upsize_pil(pil_image, (width, height))
+        else:
+            logger.debug("Downsizing image")
+            tn.downsize_pil(pil_image, (width, height))
+
+        #image width and height
+        image_w = pil_image.size[0]
+        image_h = pil_image.size[1]
         
-        If user is not using job codes in their file or subfolder names
-        then do not prompt for it
-        """
+        #center the image horizontally and vertically
+        #top left and right corners for the image:
+        image_x = x + ((w - image_w) / 2)
+        image_y = y + ((h - image_h) / 2)
+        
+        image = create_cairo_image_surface(pil_image, image_w, image_h)
+        cairo_context.set_source_surface(image, image_x, image_y)
+        cairo_context.paint()        
 
-        if self.parentApp.needJobCodeForRenaming():
-            self.job_code_hbox.show()
-            self.job_code_label.show()
-            self.job_code_combo.show()
-            self.selection_treeview.job_code_column.set_visible(True)
-        else:
-            self.job_code_hbox.hide()
-            self.job_code_label.hide()
-            self.job_code_combo.hide()
-            self.selection_treeview.job_code_column.set_visible(False)
-    
-    def update_job_code_combo(self):
-        # delete existing rows
-        while len(self.job_code_combo.get_model()) > 0:
-            self.job_code_combo.remove_text(0)
-        # add new ones
-        for text in self.parentApp.prefs.job_codes:
-            self.job_code_combo.append_text(text)
-        # clear existing entry displayed in entry box
-        self.job_code_entry.set_text('')
+        return False    
+        
         
+
+class PreviewImage:
     
-    def add_job_code_combo(self):
-        self.job_code_hbox = gtk.HBox(spacing = 12)
-        self.job_code_hbox.set_no_show_all(True)
-        self.job_code_label = gtk.Label(_("Job Code:"))
-        
-        self.job_code_combo = gtk.combo_box_entry_new_text()
-        for text in self.parentApp.prefs.job_codes:
-            self.job_code_combo.append_text(text)
-        
-        # make entry box have entry completion
-        self.job_code_entry = self.job_code_combo.child
-        
-        self.completion = gtk.EntryCompletion()
-        self.completion.set_match_func(self.job_code_match_func)
-        self.completion.connect("match-selected",
-                             self.on_job_code_combo_completion_match)
-        self.completion.set_model(self.job_code_combo.get_model())
-        self.completion.set_text_column(0)
-        self.job_code_entry.set_completion(self.completion)
-        
-        
-        self.job_code_combo.connect('changed', self.on_job_code_resp)
-        
-        self.job_code_entry.connect('activate', self.on_job_code_entry_resp)
-        
-        self.job_code_combo.set_tooltip_text(_("Enter a new Job Code and press Enter, or select an existing Job Code"))
-
-        #add widgets
-        self.job_code_hbox.pack_start(self.job_code_label, False, False)
-        self.job_code_hbox.pack_start(self.job_code_combo, True, True)
-        self.set_job_code_display()
-
-    def job_code_match_func(self, completion, key, iter):
-         model = completion.get_model()
-         return model[iter][0].lower().startswith(self.job_code_entry.get_text().lower())
-         
-    def on_job_code_combo_completion_match(self, completion, model, iter):
-         self.job_code_entry.set_text(model[iter][0])
-         self.job_code_entry.set_position(-1)
-         
-    def on_job_code_resp(self, widget):
-        """
-        When the user has clicked on an existing job code
-        """
+    def __init__(self, parent_app, builder):
+        #set background color to equivalent of '#444444
+        self.preview_image = ResizblePilImage(bg_color=(0.267, 0.267, 0.267)) 
+        self.preview_image_eventbox = builder.get_object("preview_eventbox")
+        self.preview_image_eventbox.add(self.preview_image)
+        self.preview_image.show()
+        self.download_this_checkbutton = builder.get_object("download_this_checkbutton")
+        self.rapid_app = parent_app
         
-        # ignore changes because the user is typing in a new value
-        if widget.get_active() >= 0:
-            self.job_code_chosen(widget.get_active_text())
-            
-    def on_job_code_entry_resp(self, widget):
-        """
-        When the user has hit enter after entering a new job code
-        """
-        self.job_code_chosen(widget.get_text())
+        self.base_preview_image = None # large size image used to scale down from
+        self.current_preview_size = (0,0)
+        self.preview_image_size_limit = (0,0)
         
-    def job_code_chosen(self, job_code):
+        self.unique_id = None
+        
+    def set_preview_image(self, unique_id, pil_image, include_checkbutton_visible=None, 
+                          checked=None):
         """
-        The user has selected a Job code, apply it to selected images. 
         """
-        self.selection_treeview.apply_job_code(job_code, overwrite = True)
-        self.completion.set_model(None)
-        self.parentApp.assignJobCode(job_code)
-        self.completion.set_model(self.job_code_combo.get_model())
-            
-    def add_file(self, mediaFile):
-        self.selection_treeview.add_file(mediaFile)
-            
+        self.preview_image.set_image(pil_image)
+        self.unique_id = unique_id
+        if checked is not None:
+            self.download_this_checkbutton.set_active(checked)
+            self.download_this_checkbutton.grab_focus()
+
+        if include_checkbutton_visible is not None:
+            self.download_this_checkbutton.props.visible = include_checkbutton_visible
         
-class LogDialog(gnomeglade.Component):
-    """
-    Displays a log of errors, warnings or other information to the user
+    def update_preview_image(self, unique_id, pil_image):
+        if unique_id == self.unique_id:
+            self.set_preview_image(unique_id, pil_image)
+      
+
+        
+class RapidApp(dbus.service.Object):
     """
+    The main Rapid Photo Downloader application class.
     
-    def __init__(self, parentApp):
-        """
-        Initialize values for log dialog, but do not display.
-        """
+    Contains functionality for main program window, and directs all other
+    processes.
+    """
+     
+    def __init__(self,  bus, path, name, taskserver=None): 
+        
+        dbus.service.Object.__init__ (self, bus, path, name)
+        self.running = False
         
-        gnomeglade.Component.__init__(self, 
-                                    paths.share_dir(config.GLADE_FILE), 
-                                    "logdialog")
-                                    
+        self.taskserver = taskserver
         
-        self.widget.connect("delete-event", self.hide_window)
+        # Setup program preferences, and set callback for when they change
+        self._init_prefs()
         
-        self.parentApp = parentApp
-        self.log_textview.set_cursor_visible(False)
-        self.textbuffer = self.log_textview.get_buffer()
+        # Initialize widgets in the main window, and variables that point to them
+        self._init_widgets()
         
-        self.errorTag = self.textbuffer.create_tag(weight=pango.WEIGHT_BOLD, foreground="red")
-        self.warningTag = self.textbuffer.create_tag(weight=pango.WEIGHT_BOLD)
-        self.resolutionTag = self.textbuffer.create_tag(style=pango.STYLE_ITALIC)
+        # Initialize job code handling
+        self._init_job_code()
         
-    def addMessage(self, thread_id, severity, problem, details, resolution):
-        if severity in [config.CRITICAL_ERROR, config.SERIOUS_ERROR]:
-            self.parentApp.error_image.show()
-        elif severity == config.WARNING:
-            self.parentApp.warning_image.show()
-        self.parentApp.warning_vseparator.show()
+        # Remember the window size from the last time the program was run, or
+        # set a default size
+        self._set_window_size()
         
-        iter = self.textbuffer.get_end_iter()
-        if severity in [config.CRITICAL_ERROR, config.SERIOUS_ERROR]:
-            self.textbuffer.insert_with_tags(iter, problem +"\n", self.errorTag)
-        else:
-            self.textbuffer.insert_with_tags(iter, problem +"\n", self.warningTag)
-        if details:
-            iter = self.textbuffer.get_end_iter()
-            self.textbuffer.insert(iter, details + "\n")
-        if resolution:
-            iter = self.textbuffer.get_end_iter()
-            self.textbuffer.insert_with_tags(iter, resolution +"\n", self.resolutionTag)
+        # Setup various widgets
+        self._setup_buttons()
+        self._setup_error_icons()
+        self._setup_icons()
             
-        iter = self.textbuffer.get_end_iter()
-        self.textbuffer.insert(iter, "\n")
+        # Show the main window
+        self.rapidapp.show()
         
-        # move viewport to display the latest message
-        adjustment = self.log_scrolledwindow.get_vadjustment()
-        adjustment.set_value(adjustment.upper)
+        # Check program preferences - don't allow auto start if there is a problem
+        prefs_valid = prefsrapid.check_prefs_for_validity(self.prefs)
+        do_not_allow_auto_start = prefs_valid
         
+        # Initialize variables with which to track important downloads results
+        self._init_download_tracking()
         
-    def on_logdialog_response(self, dialog, arg):
-        if arg == gtk.RESPONSE_CLOSE:
-            pass
-        self.parentApp.error_image.hide()
-        self.parentApp.warning_image.hide()
-        self.parentApp.warning_vseparator.hide()
-        self.parentApp.prefs.show_log_dialog = False
-        self.widget.hide()
-        return True
-
-    def hide_window(self,  window, event):
-        window.hide()
-        return True
+        # Set up process managers.
+        # A task such as scanning a device or copying files is handled in its
+        # own process.
+        self._start_process_managers()
+        
+        # Setup devices from which to download from and backup to
+        self.setup_devices(on_startup=True, on_preference_change=False, 
+                           do_not_allow_auto_start=do_not_allow_auto_start)
+        
+        # Ensure the device collection scrolled window is not too small
+        self._set_device_collection_size()
+        
+        #~ preferencesdialog.PreferencesDialog(self)    
+    
+    def on_rapidapp_destroy(self, widget, data=None):
 
+        self._terminate_processes(terminate_file_copies = True)
 
+        # save window and component sizes
+        self.prefs.vpaned_pos = self.main_vpaned.get_position()
 
-class RapidApp(gnomeglade.GnomeApp,  dbus.service.Object): 
-    def __init__(self,  bus, path, name): 
+        x, y, width, height = self.rapidapp.get_allocation()
+        self.prefs.main_window_size_x = width
+        self.prefs.main_window_size_y = height
         
-        dbus.service.Object.__init__ (self, bus, path, name)
-        self.running = False
+        self.prefs.set_downloads_today_from_tracker(self.downloads_today_tracker)
         
-        gladefile = paths.share_dir(config.GLADE_FILE)
-
-        gnomeglade.GnomeApp.__init__(self, "rapid", __version__, gladefile, "rapidapp")
-    
-        # notifications
-        self.displayDownloadSummaryNotification = False
-        self.initPyNotify()
+        gtk.main_quit()
         
-        self.prefs = RapidPreferences()
-        self.prefs.notify_add(self.on_preference_changed)
+    def _terminate_processes(self, terminate_file_copies=False):
         
-        self.testing = False
-        if self.testing:
-            self.setTestingEnv()
-            
-#        sys.exit(0)
+        # FIXME: need more fine grained tuning here - must cancel large file
+        # copies midstream
+        logger.info("Terminating...")
 
-        # remember the window size from the last time the program was run
-        if self.prefs.main_window_maximized:
-            self.rapidapp.maximize()
-        elif self.prefs.main_window_size_x > 0:
-            self.rapidapp.set_default_size(self.prefs.main_window_size_x, self.prefs.main_window_size_y)
+        scan_termination_requested = self.scan_manager.request_termination()        
+        thumbnails_termination_requested = self.thumbnails.thumbnail_manager.request_termination()
+        if terminate_file_copies:
+            copy_files_termination_requested = self.copy_files_manager.request_termination()
         else:
-            # set a default size
-            self.rapidapp.set_default_size(650, 650)
-            
-        if gtk.gdk.screen_height() <= config.TINY_SCREEN_HEIGHT:
-            self.prefs.display_preview_folders = False
-            self.menu_preview_folders.set_sensitive(False)
-            
-        self.widget.show()
+            copy_files_termination_requested = False
         
-        self._setupIcons()
+        if scan_termination_requested or thumbnails_termination_requested:
+            time.sleep(1)
+            if (self.scan_manager.get_no_active_processes() > 0 or 
+                self.thumbnails.thumbnail_manager.get_no_active_processes() > 0):
+                time.sleep(1)
+                # must try again, just in case a new scan has meanwhile started!
+                self.scan_manager.request_termination()
+                self.thumbnails.thumbnail_manager.terminate_forcefully()
+                self.scan_manager.terminate_forcefully()
+                
+        if terminate_file_copies and copy_files_termination_requested:
+            time.sleep(1)
+            self.copy_files_manager.terminate_forcefully()
         
-        # this must come after the window is shown
-        if self.prefs.vpaned_pos > 0:
-            self.main_vpaned.set_position(self.prefs.vpaned_pos)
-        else:
-            self.main_vpaned.set_position(66)
+        if terminate_file_copies:
+            self._clean_all_temp_dirs()
         
-        self.checkIfFirstTimeProgramEverRun()
+    # # #
+    # Events and tasks related to displaying preview images and thumbnails
+    # # #
 
-        displayPreferences = self.checkForUpgrade(__version__)
-        self.prefs.program_version = __version__
+    def on_download_this_checkbutton_toggled(self, checkbutton):
+        value = checkbutton.get_active()
+        self.thumbnails.set_selected(self.preview_image.unique_id, value)
+        self.set_download_action_sensitivity()
+    
+    def on_preview_eventbox_button_press_event(self, widget, event):
         
-        self.timeRemaining = TimeRemaining()
-        self._resetDownloadInfo()
-        self.statusbar_context_id = self.rapid_statusbar.get_context_id("progress")
+        if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
+            self.show_thumbnails()    
+    
+    def on_show_thumbnails_action_activate(self, action):
+        logger.debug("on_show_thumbnails_action_activate")
+        self.show_thumbnails()
         
-        # hide display of warning and error symbols in the taskbar until they are needed
-        self.error_image.hide()
-        self.warning_image.hide()
-        self.warning_vseparator.hide()
+    def on_show_image_action_activate(self, action):
+        logger.debug("on_show_image_action_activate")
+        self.thumbnails.show_preview()
         
-        if not displayPreferences:
-            displayPreferences = not self.checkPreferencesOnStartup()
+    def on_check_all_action_activate(self, action):
+        self.thumbnails.check_all(check_all=True)
         
-        # display download information using threads
-        global media_collection_treeview, log_dialog
-        global workers
+    def on_uncheck_all_action_activate(self, action):
+        self.thumbnails.check_all(check_all=False)
 
-        #track files that should have a suffix added to them
-        global duplicate_files
+    def on_check_all_photos_action_activate(self, action):
+        self.thumbnails.check_all(check_all=True, 
+                                  file_type=rpdfile.FILE_TYPE_PHOTO)
         
-        #track files that have been downloaded in this session
-        global downloaded_files
+    def on_check_all_videos_action_activate(self, action):
+        self.thumbnails.check_all(check_all=True, 
+                                  file_type=rpdfile.FILE_TYPE_VIDEO)
+                                  
+    def on_quit_action_activate(self, action):
+        self.on_rapidapp_destroy(widget=self.rapidapp, data=None)
         
-        # control sequence numbers and letters
-        global sequences
+    def on_refresh_action_activate(self, action):
+        self.setup_devices(on_startup=False, on_preference_change=False,
+                           do_not_allow_auto_start=True)
+                           
+    def on_get_help_action_activate(self, action):
+        webbrowser.open("http://www.damonlynch.net/rapid/help.html")
         
-        # whether we need to prompt for a job code
-        global need_job_code_for_renaming
-
-        duplicate_files = {}
-        downloaded_files = DownloadedFiles()
+    def on_about_action_activate(self, action):
+        self.about.set_property("name", PROGRAM_NAME)
+        self.about.set_property("version", utilities.human_readable_version(
+                                                                __version__))
+        self.about.run()
+        self.about.destroy() 
+        
+    def on_report_problem_action_activate(self, action):
+        webbrowser.open("https://bugs.launchpad.net/rapid")
+        
+    def on_translate_action_activate(self, action):
+        webbrowser.open("http://www.damonlynch.net/rapid/translate.html")
+     
+    def on_donate_action_activate(self, action):
+        webbrowser.open("http://www.damonlynch.net/rapid/donate.html")
+             
+    def show_preview_image(self, unique_id, image, include_checkbutton_visible, checked):
+        if self.main_notebook.get_current_page() == 0: # thumbnails
+            logger.debug("Switching to preview image display")
+            self.main_notebook.set_current_page(1)
+        self.preview_image.set_preview_image(unique_id, image, include_checkbutton_visible, checked)
+        self.next_image_action.set_sensitive(True)
+        self.prev_image_action.set_sensitive(True)
         
-        self.download_start_time = None
+    def update_preview_image(self, unique_id, image):
+        self.preview_image.update_preview_image(unique_id, image)
         
-        downloadsToday = self.prefs.getAndMaybeResetDownloadsToday()
-        sequences = rn.Sequences(downloadsToday, self.prefs.stored_sequence_no)
+    def show_thumbnails(self):
+        logger.debug("Switching to thumbnails display")
+        self.main_notebook.set_current_page(0)
+        self.thumbnails.select_image(self.preview_image.unique_id)
+        self.next_image_action.set_sensitive(False)
+        self.prev_image_action.set_sensitive(False)
         
-        self.downloadStats = DownloadStats()
         
-        # set the number of seconds gap with which to measure download time remaing 
-        self.downloadTimeGap = 3
-
-        #locks for threadsafe file downloading and stats gathering
-        self.fileRenameLock = Lock()
-        self.fileSequenceLock = Lock()
-        self.statsLock = Lock()
-        self.downloadedFilesLock = Lock()
-
-        # log window, in dialog format
-        # used for displaying download information to the user
+    def on_next_image_action_activate(self, action):
+        if self.preview_image.unique_id is not None:
+            self.thumbnails.show_next_image(self.preview_image.unique_id)
+    
+    def on_prev_image_action_activate(self, action):
+        if self.preview_image.unique_id is not None:        
+            self.thumbnails.show_prev_image(self.preview_image.unique_id)
         
-        log_dialog = LogDialog(self)
+    def set_thumbnail_sort(self):
+        """
+        If all the scans are complete, sets the sort order
+        """
+        if self.scan_manager.get_no_active_processes() == 0:
+            self.thumbnails.sort_by_timestamp()
 
 
-        self.volumeMonitor = None
-        if self.usingVolumeMonitor():
-            self.startVolumeMonitor()
+    # # #
+    # Volume management
+    # # #
+    
+    def start_volume_monitor(self):
+        if not self.vmonitor:
+            self.vmonitor = gio.volume_monitor_get()
+            self.vmonitor.connect("mount-added", self.on_mount_added)
+            self.vmonitor.connect("mount-removed", self.on_mount_removed) 
+    
+            
+    def setup_devices(self, on_startup, on_preference_change, do_not_allow_auto_start):
+        """
         
-        # flag to indicate whether the user changed some preferences that 
-        # indicate the image and backup devices should be setup again
-        self.rerunSetupAvailableImageAndVideoMedia = False
-        self.rerunSetupAvailableBackupMedia = False
+        Setup devices from which to download from and backup to
         
-        # flag to indicate the user changes some preferences and the display
-        # of sample names and subfolders needs to be refreshed
-        self.refreshGeneratedSampleSubfolderAndName = False
+        Sets up volumes for downloading from and backing up to
         
-        # counter to indicate how many threads need their sample names and subfolders regenerated because the user
-        # changes their prefs at the same time as devices were being scanned
-        self.noAfterScanRefreshGeneratedSampleSubfolderAndName = 0
+        on_startup should be True if the program is still starting, 
+        i.e. this is being called from the program's initialization.
         
-        # flag to indicate the user changes some preferences and the display
-        # of sample download folders needs to be refreshed
-        self.refreshSampleDownloadFolder = False
-        self.noAfterScanRefreshSampleDownloadFolders = 0
+        on_preference_change should be True if this is being called as the
+        result of a preference being changed
         
-        # flag to indicate that the preferences dialog window is being 
-        # displayed to the user
-        self.preferencesDialogDisplayed = False
+        Removes any image media that are currently not downloaded, 
+        or finished downloading        
+        """
+        
+        if self.using_volume_monitor():
+            self.start_volume_monitor()
         
-        # set up tree view display to display image devices and download status
-        media_collection_treeview = MediaTreeView(self)        
 
-        self.media_collection_vbox.pack_start(media_collection_treeview)
+        self.clear_non_running_downloads()
         
-        #Selection display
-        self.selection_vbox = SelectionVBox(self)
-        self.selection_hbox.pack_start(self.selection_vbox, padding=12)
-        self.set_display_selection(self.prefs.display_selection)
-        self.set_display_preview_folders(self.prefs.display_preview_folders)
+        mounts = []
+        self.backup_devices = {}
         
-        self.backupVolumes = {}
-
-        #Help button and download buttons
-        self._setupDownloadbuttons()
+        # Clear download statistics and tracking
+        # FIXME
         
-        #status bar progress bar
-        self.download_progressbar = gtk.ProgressBar()
-        self.download_progressbar.set_size_request(150, -1)
-        self.download_progressbar.show()
-        self.download_progressbar_hbox.pack_start(self.download_progressbar, expand=False, 
-                                        fill=0)
+        if self.using_volume_monitor():
+            # either using automatically detected backup devices
+            # or download devices
+            for mount in self.vmonitor.get_mounts():
+                if not mount.is_shadowed():
+                    path = mount.get_root().get_path()
+                    if path:
+                        if (path in self.prefs.device_blacklist and 
+                                    self.search_for_PSD()):
+                            logger.info("%s ignored", mount.get_name())
+                        else:
+                            logger.info("Detected %s", mount.get_name())
+                            is_backup_mount = self.check_if_backup_mount(path)
+                            if is_backup_mount:
+                                self.backup_devices[path] = mount
+                            elif (self.prefs.device_autodetection and 
+                                 (dv.is_DCIM_device(path) or 
+                                  self.search_for_PSD())):
+                                mounts.append((path, mount))
+                    
         
+        if not self.prefs.device_autodetection:
+            # user manually specified the path from which to download 
+            path = self.prefs.device_location
+            if path:
+                logger.info("Using manually specified path %s", path)
+                if utilities.is_directory(path):
+                    mounts.append((path, None))
+                else:
+                    logger.error("Download path does not exist: %s", path)
 
-        # menus
-
-        #preview panes
-        self.menu_display_selection.set_active(self.prefs.display_selection)
-        self.menu_preview_folders.set_active(self.prefs.display_preview_folders)
+        if self.prefs.backup_images:
+            if not self.prefs.backup_device_autodetection:
+                # user manually specified backup location
+                # will backup to this path, but don't need any volume info 
+                # associated with it
+                self.backup_devices[self.prefs.backup_location] = None
+        
+        # Display amount of free space in a status bar message
+        self.display_free_space()
         
-        #preview columns in pane
-        if not DOWNLOAD_VIDEO:
-            self.menu_type_column.set_active(False)
-            self.menu_type_column.set_sensitive(False)
+        if do_not_allow_auto_start:
+            self.auto_start_is_on = False
         else:
-            self.menu_type_column.set_active(self.prefs.display_type_column)
-        self.menu_size_column.set_active(self.prefs.display_size_column)
-        self.menu_filename_column.set_active(self.prefs.display_filename_column)
-        self.menu_device_column.set_active(self.prefs.display_device_column)
-        self.menu_path_column.set_active(self.prefs.display_path_column)
+            self.auto_start_is_on = ((not on_preference_change) and
+                                    ((self.prefs.auto_download_at_startup and 
+                                      on_startup) or 
+                                      (self.prefs.auto_download_upon_device_insertion and
+                                       not on_startup)))
         
-        self.menu_clear.set_sensitive(False)
 
-        need_job_code_for_renaming = self.needJobCodeForRenaming()
-        self.menu_select_all_without_job_code.set_sensitive(need_job_code_for_renaming)
-        self.menu_select_all_with_job_code.set_sensitive(need_job_code_for_renaming)
+        self.testing_auto_exit = False
+        self.testing_auto_exit_trip = len(mounts)
+        self.testing_auto_exit_trip_counter = 0
         
-        #job code initialization
-        self.last_chosen_job_code = None
-        self.prompting_for_job_code = False
+
+        for m in mounts:
+            path, mount = m
+            device = dv.Device(path=path, mount=mount)
+            if (self.search_for_PSD() and 
+                    path not in self.prefs.device_whitelist):
+                # prompt user to see if device should be used or not
+                self.get_use_device(device)
+            else:
+                scan_pid = self.scan_manager.add_task(device)
+                if mount is not None:
+                    self.mounts_by_path[path] = scan_pid
         
-        #check to see if the download folder exists and is writable
-        displayPreferences_2 = not self.checkDownloadPathOnStartup()
-        displayPreferences = displayPreferences or displayPreferences_2
-            
-        if self.prefs.device_autodetection == False:
-            displayPreferences_2 = not self.checkImageDevicePathOnStartup()
-            displayPreferences = displayPreferences or displayPreferences_2
+    def get_use_device(self, device):  
+        """ Prompt user whether or not to download from this device """
         
-        #setup download and backup mediums, initiating scans
-        self.setupAvailableImageAndBackupMedia(onStartup=True, onPreferenceChange=False, doNotAllowAutoStart = displayPreferences)
-
-        #adjust viewport size for displaying media
-        #this is important because the code in MediaTreeView.addCard() is inaccurate at program startup
+        logger.info("Prompting whether to use %s", device.get_name())
+        d = dv.UseDeviceDialog(self.rapidapp, device, self.got_use_device)
         
-        if media_collection_treeview.mapThreadToRow:
-            height = self.media_collection_viewport.size_request()[1]
-            self.media_collection_scrolledwindow.set_size_request(-1,  height)
-        else:
-            # don't allow the media collection to be absolutely empty
-            self.media_collection_scrolledwindow.set_size_request(-1, 47)
+    def got_use_device(self, dialog, user_selected, permanent_choice, device):
+        """ User has chosen whether or not to use a device to download from """
+        dialog.destroy()
         
-        self.download_button.grab_default()
-        # for some reason, the grab focus command is not working... unsure why
-        self.download_button.grab_focus()
+        path = device.get_path()
         
-        if displayPreferences:
-            PreferencesDialog(self)
+        if user_selected:
+            if permanent_choice and path not in self.prefs.device_whitelist:
+                # do NOT do a list append operation here without the assignment,
+                # or the actual preferences will not be updated!!
+                if len(self.prefs.device_whitelist):
+                    self.prefs.device_whitelist = self.prefs.device_whitelist + [path]
+                else:
+                    self.prefs.device_whitelist = [path]
+            scan_pid = self.scan_manager.add_task(device)
+            self.mounts_by_path[path] = scan_pid
             
+        elif permanent_choice and path not in self.prefs.device_blacklist:
+            # do not do a list append operation here without the assignment, or the preferences will not be updated!
+            if len(self.prefs.device_blacklist):
+                self.prefs.device_blacklist = self.prefs.device_blacklist + [path]
+            else:
+                self.prefs.device_blacklist = [path]    
+     
+    def search_for_PSD(self):
+        """
+        Check to see if user preferences are to automatically search for 
+        Portable Storage Devices or not
+        """
+        return self.prefs.device_autodetection_psd and self.prefs.device_autodetection
 
+    def check_if_backup_mount(self,  path):
+        """
+        Checks to see if backups are enabled and path represents a valid backup location
+        
+        Checks against user preferences.
+        """
+        identifiers = [self.prefs.backup_identifier]
+        if DOWNLOAD_VIDEO:
+            identifiers.append(self.prefs.video_backup_identifier)
+        if self.prefs.backup_images:
+            if self.prefs.backup_device_autodetection:
+                if dv.is_backup_media(path, identifiers):
+                    return True
+            elif path == self.prefs.backup_location:
+                # user manually specified the path
+                return True
+        return False        
+            
+    def using_volume_monitor(self):
+        """
+        Returns True if programs needs to use gio volume monitor
+        """
+        
+        return (self.prefs.device_autodetection or 
+                (self.prefs.backup_images and 
+                self.prefs.backup_device_autodetection
+                ))
+                    
+    def on_mount_added(self, vmonitor, mount):
+        """
+        callback run when gio indicates a new volume
+        has been mounted
+        """
 
-    @dbus.service.method (config.DBUS_NAME,
-                           in_signature='', out_signature='b')
-    def is_running (self):
-        return self.running
-    
-    @dbus.service.method (config.DBUS_NAME,
-                            in_signature='', out_signature='')
-    def start (self):
-        if self.is_running():
-            self.rapidapp.present()
+
+        if mount.is_shadowed():
+            # ignore this type of mount
+            return
+            
+        path = mount.get_root().get_path()
+
+        if path in self.prefs.device_blacklist and self.search_for_PSD():
+            logger.info("Device %(device)s (%(path)s) ignored" % {
+                        'device': mount.get_name(), 'path': path})
         else:
-            self.running = True
-#            if not using_gio:
-            self.main()
-#            else:
-#                mainloop = gobject.MainLoop()
-#                mainloop.run()
-            self.running = False
+            is_backup_mount = self.check_if_backup_mount(path)
+                        
+            if is_backup_mount:
+                if path not in self.backup_devices:
+                    self.backup_devices[path] = mount
+                    self.display_free_space()
+
+            elif self.prefs.device_autodetection and (dv.is_DCIM_device(path) or 
+                                                        self.search_for_PSD()):
+                
+                device = dv.Device(path=path, mount=mount)
+                if self.search_for_PSD() and path not in self.prefs.device_whitelist:
+                    # prompt user if device should be used or not
+                    self.get_use_device(device)
+                else:   
+                    scan_pid = self.scan_manager.add_task(device)
+                    self.mounts_by_path[path] = scan_pid
             
-    def setTestingEnv(self):
-        #self.prefs.program_version = '0.0.8~b7'
-        p = ['Date time', 'Image date', 'YYYYMMDD', 'Text', '-', '', 'Date time', 'Image date', 'HHMM', 'Text', '-', '', rn.SEQUENCES, rn.DOWNLOAD_SEQ_NUMBER, rn.SEQUENCE_NUMBER_3, 'Text', '-iso', '', 'Metadata', 'ISO', '', 'Text', '-f', '', 'Metadata', 'Aperture', '', 'Text', '-', '', 'Metadata', 'Focal length', '', 'Text', 'mm-', '', 'Metadata', 'Exposure time', '', 'Filename', 'Extension', 'lowercase']
-        v = ['Date time', 'Video date', 'YYYYMMDD', 'Text', '-', '', 'Date time', 'Video date', 'HHMM', 'Text', '-', '', 'Sequences', 'Downloads today', 'One digit', 'Text', '-', '', 'Metadata', 'Width', '', 'Text', 'x', '', 'Metadata', 'Height', '', 'Filename', 'Extension', 'lowercase']
-        f = '/home/damon/store/rapid-dump'
-        self.prefs.image_rename = p
-        self.prefs.video_rename = v
-        self.prefs.download_folder = f
-        self.prefs.video_download_folder = f
-        
-        
-    def _setupIcons(self):
-        icons = ['rapid-photo-downloader-downloaded', 
-             'rapid-photo-downloader-downloaded-with-error',
-             'rapid-photo-downloader-downloaded-with-warning',
-             'rapid-photo-downloader-download-pending',
-             'rapid-photo-downloader-jobcode']
-        
-        icon_list = [(icon, paths.share_dir('glade3/%s.svg' % icon)) for icon in icons]
-        common.register_iconsets(icon_list)
-    
-    def displayFreeSpace(self):
+    def on_mount_removed(self, vmonitor, mount):
         """
-        Displays the amount of space free on the filesystem the files will be downloaded to.
-        Also displays backup volumes / path being used.
+        callback run when gio indicates a new volume
+        has been mounted
         """
-        msg = ''
-        if using_gio and os.path.isdir(self.prefs.download_folder):
-            folder = gio.File(self.prefs.download_folder)
-            fileInfo = folder.query_filesystem_info(gio.FILE_ATTRIBUTE_FILESYSTEM_FREE)
-            free = common.formatSizeForUser(fileInfo.get_attribute_uint64(gio.FILE_ATTRIBUTE_FILESYSTEM_FREE))
-            msg = " " + _("%(free)s available") % {'free': free}
         
+        path = mount.get_root().get_path()
+
+        # three scenarios -
+        # the mount has been scanned but downloading has not yet started
+        # files are being downloaded from mount (it must be a messy unmount)
+        # files have finished downloading from mount
+        
+        if path in self.mounts_by_path:
+            scan_pid = self.mounts_by_path[path]
+            del self.mounts_by_path[path]
+            # temp directory should be cleaned by finishing of process
+            
+            #~ if scan_pid in self.download_active_by_scan_pid:
+                #~ self._clean_temp_dirs_for_scan_pid(scan_pid)
+            self.thumbnails.clear_all(scan_pid = scan_pid, 
+                                      keep_downloaded_files = True)
+            self.device_collection.remove_device(scan_pid)
             
-        if self.prefs.backup_images:
-            if not self.prefs.backup_device_autodetection:
-                # user manually specified backup location
-                msg2 = _('Backing up to %(path)s') % {'path':self.prefs.backup_location}
-            else:
-                msg2 = self.displayBackupVolumes()
                 
-            if msg:
-                msg = _("%(freespace)s. %(backuppaths)s.") % {'freespace': msg, 'backuppaths': msg2}
-            else:
-                msg = msg2
+                    
+        # remove backup volumes
+        elif path in self.backup_devices:
+            del self.backup_devices[path]
+            self.display_free_space()
+                
+        # may need to disable download button and menu
+        self.set_download_action_sensitivity()
             
-        self.rapid_statusbar.push(self.statusbar_context_id, msg)
-    
-    def checkImageDevicePathOnStartup(self):
-        msg = None
-        if not os.path.isdir(self.prefs.device_location):
-            msg = _("Sorry, this device location does not exist:\n%(path)s\n\nPlease resolve the problem, or modify your preferences." % {"path": self.prefs.device_location})
+    def clear_non_running_downloads(self):
+        """
+        Clears the display of downloads that are currently not running
+        """
+        
+        # Stop any processes currently scanning or creating thumbnails
+        self._terminate_processes(terminate_file_copies=False)
+        
+        # Remove them from the user interface
+        for scan_pid in self.device_collection.get_all_displayed_processes():
+            if scan_pid not in self.download_active_by_scan_pid:
+                self.device_collection.remove_device(scan_pid)
+                self.thumbnails.clear_all(scan_pid=scan_pid)
             
-        if msg:
-            sys.stderr.write(msg +'\n')
-            misc.run_dialog(_("Problem with Device Location Folder"), msg, 
-                self,
-                gtk.MESSAGE_ERROR)
-            return False
-        else:
-            return True
         
-    def checkDownloadPathOnStartup(self):
-        if DOWNLOAD_VIDEO:
-            paths = ((self.prefs.download_folder, _('Photo')), (self.prefs.video_download_folder, _('Video')))
+
+    
+    # # #
+    # Download and help buttons, and menu items
+    # # #
+    
+    def on_download_action_activate(self, action):
+        """
+        Called when a download is activated
+        """
+        
+        if self.copy_files_manager.paused:
+            logger.debug("Download resumed")
+            self.resume_download()
         else:
-            paths = ((self.prefs.download_folder, _('Photo')),)
-        msg = ''
-        noProblems = 0
-        for path, file_type in paths:
-            if not os.path.isdir(path):
-                msg += _("The %(file_type)s Download Folder does not exist.\n") % {'file_type': file_type}
-                noProblems += 1
-            else:
-                #unfortunately 'os.access(self.prefs.download_folder, os.W_OK)' is not reliable
-                try:
-                    tempWorkingDir = tempfile.mkdtemp(prefix='rapid-tmp-', 
-                                                dir=path)
-                except:
-                    noProblems += 1
-                    msg += _("The %(file_type)s Download Folder exists but cannot be written to.\n") % {'file_type': file_type}
-                else:
-                    os.rmdir(tempWorkingDir)
+            logger.debug("Download activated")
             
-        if msg:
-            msg = _("Sorry, problems were encountered with your download folders. Please fix the problems or modify the preferences.\n\n") + msg
-            sys.stderr.write(msg)
-            if noProblems == 1:
-                title = _("Problem with Download Folder")
+            if self.download_action_is_download:
+                self.start_download()
             else:
-                title = _("Problem with Download Folders")
+                self.pause_download()
+
+    
+    def on_help_action_activate(self, action):
+        webbrowser.open("http://www.damonlynch.net/rapid/documentation")
+        
+    def on_preferences_action_activate(self, action):
+
+        preferencesdialog.PreferencesDialog(self)
+        
+    def set_download_action_sensitivity(self):
+        """
+        Sets sensitivity of Download action to enable or disable it
+        
+        Affects download button and menu item
+        """
+        if not self.download_is_occurring():
+            sensitivity = False
+            if self.scan_manager.get_no_active_processes() == 0:
+                if self.thumbnails.files_are_checked_to_download():
+                    sensitivity = True
             
-            misc.run_dialog(title, msg, 
-                self,
-                gtk.MESSAGE_ERROR)
-            return False
+            self.download_action.set_sensitive(sensitivity)
+            
+    def set_download_action_label(self, is_download):
+        """
+        Toggles label betwen pause and download 
+        """
+        
+        if is_download:
+            self.download_action.set_label(_("Download"))
+            self.download_action_is_download = True
         else:
-            return True
+            self.download_action.set_label(_("Pause"))
+            self.download_action_is_download = False
+    
+    # # #
+    # Job codes
+    # # #
     
-    def checkPreferencesOnStartup(self):
-        prefsOk = rn.checkPreferencesForValidity(self.prefs.image_rename,  self.prefs.subfolder, self.prefs.video_rename, self.prefs.video_subfolder)
-        if not prefsOk:
-            msg = _("There is an error in the program preferences.")
-            msg += " " + _("Some preferences will be reset.") 
-            # do not use cmd_line here, as this is a genuine error
-            sys.stderr.write(msg +'\n')
-        return prefsOk
-        
-    def needJobCodeForRenaming(self):
-        return rn.usesJobCode(self.prefs.image_rename) or rn.usesJobCode(self.prefs.subfolder) or rn.usesJobCode(self.prefs.video_rename) or rn.usesJobCode(self.prefs.video_subfolder)
-        
-    def assignJobCode(self,  code):
+    
+    def _init_job_code(self):
+        self.job_code = None
+        self.need_job_code_for_naming = self.prefs.any_pref_uses_job_code()
+    
+    def assign_job_code(self,  code):
         """ assign job code (which may be empty) to global variable and update user preferences
         
         Update preferences only if code is not empty. Do not duplicate job code.
         """
-        global job_code
+        # FIXME
+        #~ global job_code
         if code == None:
             code = ''
         job_code = code
@@ -5163,1301 +1702,841 @@ class RapidApp(gnomeglade.GnomeApp,  dbus.service.Object):
                 jcs.remove(code)
                 
             self.prefs.job_codes = [code] + jcs
-            
-    
-    def getShowWarningDownloadingFromCamera(self):
-        if self.prefs.show_warning_downloading_from_camera:
-            cmd_line(_("Displaying warning about downloading directly from camera"))
-            d = ShowWarningDialog(self.widget, self.gotShowWarningDownloadingFromCamera)
-            
-    def gotShowWarningDownloadingFromCamera(self, dialog, showWarningAgain):
-        dialog.destroy()
-        self.prefs.show_warning_downloading_from_camera = showWarningAgain
-    
-    def getUseDevice(self,  path,  volume, autostart):  
-        """ Prompt user whether or not to download from this device """
-        
-        cmd_line(_("Prompting whether to use %s" % volume.get_name(limit=0)))
-        d = UseDeviceDialog(self.widget, path, volume, autostart, self.gotUseDevice)
-        
-    def gotUseDevice(self,  dialog,  userSelected,  permanent_choice,  path, volume, autostart):
-        """ User has chosen whether or not to use a device to download from """
-        dialog.destroy()
-        
-        if userSelected:
-            if permanent_choice and path not in self.prefs.device_whitelist:
-                # do not do a list append operation here without the assignment, or the preferences will not be updated!
-                if len(self.prefs.device_whitelist):
-                    self.prefs.device_whitelist = self.prefs.device_whitelist + [path]
-                else:
-                    self.prefs.device_whitelist = [path]
-            self.initiateScan(path, volume, autostart)
-            
-        elif permanent_choice and path not in self.prefs.device_blacklist:
-            # do not do a list append operation here without the assignment, or the preferences will not be updated!
-            if len(self.prefs.device_blacklist):
-                self.prefs.device_blacklist = self.prefs.device_blacklist + [path]
-            else:
-                self.prefs.device_blacklist = [path]
-                
-    def _getJobCode(self,  postJobCodeEntryCB,  autoStart, downloadSelected):
+
+    def _get_job_code(self,  post_job_code_entry_callback,  autoStart, downloadSelected):
         """ prompt for a job code """
         
         if not self.prompting_for_job_code:
-            cmd_line(_("Prompting for Job Code"))
+            logger.debug("Prompting for Job Code")
             self.prompting_for_job_code = True
-            j = JobCodeDialog(self.widget, self.prefs.job_codes,  self.last_chosen_job_code, postJobCodeEntryCB,  autoStart, downloadSelected, False)
+            j = preferencesdialog.JobCodeDialog(parent_window = self.rapidapp,
+                    job_codes = self.prefs.job_codes,
+                    default_job_code = self.last_chosen_job_code, 
+                    post_job_code_entry_callback=post_job_code_entry_callback,
+                    entry_only = False)
         else:
-            cmd_line(_("Already prompting for Job Code, do not prompt again"))
+            logger.debug("Already prompting for Job Code, do not prompt again")
         
-    def getJobCode(self, autoStart=True, downloadSelected=False):
-        """ called from the copyphotos thread, or when the user clicks one of the two download buttons"""
-        
-        self._getJobCode(self.gotJobCode, autoStart, downloadSelected)
+    def get_job_code(self):
+        self._get_job_code(self.got_job_code)
         
-    def gotJobCode(self, dialog, userChoseCode, code, autoStart, downloadSelected):
+    def got_job_code(self, dialog, user_chose_code, code):
         dialog.destroy()
         self.prompting_for_job_code = False
         
-        if userChoseCode:
-            self.assignJobCode(code)
+        if user_chose_code:
+            self.assign_job_code(code)
             self.last_chosen_job_code = code
-            self.selection_vbox.selection_treeview.apply_job_code(code, overwrite=False, to_all_rows = not downloadSelected)
-            threads = self.selection_vbox.selection_treeview.set_status_to_download_pending(selected_only = downloadSelected)
-            if downloadSelected or not autoStart:
-                cmd_line(_("Starting downloads"))
-                self.startDownload(threads)
-            else:
-                # autostart is true
-                cmd_line(_("Starting downloads that have been waiting for a Job Code"))
-                for w in workers.getWaitingForJobCodeWorkers():
-                    w.startStop()    
+            #~ self.selection_vbox.selection_treeview.apply_job_code(code, overwrite=False, to_all_rows = not downloadSelected)
+            #~ threads = self.selection_vbox.selection_treeview.set_status_to_download_pending(selected_only = downloadSelected)
+            #~ if downloadSelected or not autoStart:
+                #~ logger.debug("Starting downloads")
+                #~ self.startDownload(threads)
+            #~ else:
+                #~ # autostart is true
+                #~ logger.debug("Starting downloads that have been waiting for a Job Code")
+                #~ for w in workers.getWaitingForJobCodeWorkers():
+                    #~ w.startStop()    
                 
         else:
             # user cancelled
-            for w in workers.getWaitingForJobCodeWorkers():
-                w.waitingForJobCode = False
-                
-            if autoStart:
-                for w in workers.getAutoStartWorkers():
-                    w.autoStart = False
-            
-    def addFile(self, mediaFile):
-        self.selection_vbox.add_file(mediaFile)
-        
-    def update_status_post_download(self, treerowref):
-        self.selection_vbox.selection_treeview.update_status_post_download(treerowref)
-            
-    def on_menu_size_column_toggled(self, widget):
-        self.prefs.display_size_column = widget.get_active()
-        self.selection_vbox.selection_treeview.display_size_column(self.prefs.display_size_column)
-        
-    def on_menu_type_column_toggled(self, widget):
-        self.prefs.display_type_column = widget.get_active()
-        self.selection_vbox.selection_treeview.display_type_column(self.prefs.display_type_column)
+            pass
+            #~ logger.debug("No Job Code entered")
+            #~ for w in workers.getWaitingForJobCodeWorkers():
+                #~ w.waitingForJobCode = False
+                #~ 
+            #~ if autoStart:
+                #~ for w in workers.getAutoStartWorkers():
+                    #~ w.autoStart = False        
+    
+    # # #
+    # Download
+    # # #
+    
+    def _init_download_tracking(self):
+        """
+        Initialize variables to track downloads
+        """
+        # Track download sizes and other values for each device.
+        # (Scan id acts as an index to each device. A device could be scanned
+        #  more than once).
+        self.size_of_download_in_bytes_by_scan_pid = dict()
+        self.no_files_in_download_by_scan_pid = dict()
+        self.file_types_present_by_scan_pid = dict()
+        self.download_count_for_file_by_unique_id = dict()
+        self.download_count_by_scan_pid = dict()
         
-    def on_menu_filename_column_toggled(self, widget):
-        self.prefs.display_filename_column = widget.get_active()
-        self.selection_vbox.selection_treeview.display_filename_column(self.prefs.display_filename_column)
+        # Track which temporary directories are created when downloading files
+        self.temp_dirs_by_scan_pid = dict()
         
-    def on_menu_path_column_toggled(self, widget):
-        self.prefs.display_path_column = widget.get_active()
-        self.selection_vbox.selection_treeview.display_path_column(self.prefs.display_path_column)        
+        # Track which downloads are running
+        self.download_active_by_scan_pid = []
         
-    def on_menu_device_column_toggled(self, widget):        
-        self.prefs.display_device_column = widget.get_active()
-        self.selection_vbox.selection_treeview.display_device_column(self.prefs.display_device_column)
-                
-    def checkIfFirstTimeProgramEverRun(self):
+
+    
+    def start_download(self):
         """
-        if this is the first time the program has been run, then
-        might need to create default directories
+        Start download, renaming and backup of files.
         """
-        if len(self.prefs.program_version) == 0:
-            path = getDefaultPhotoLocation(ignore_missing_dir=True)
-            if not os.path.isdir(path):
-                cmd_line(_("Creating photo download folder %(folder)s") % {'folder':path})
-                try:
-                    os.makedirs(path)
-                    self.prefs.download_folder = path
-                except:
-                    cmd_line(_("Failed to create default photo download folder %(folder)s") % {'folder':path})
-            if DOWNLOAD_VIDEO:
-                path = getDefaultVideoLocation(ignore_missing_dir=True)
-                if not os.path.isdir(path):
-                    cmd_line(_("Creating video download folder %(folder)s") % {'folder':path})
-                    try:
-                        os.makedirs(path)
-                        self.prefs.video_download_folder = path
-                    except:
-                        cmd_line(_("Failed to create default video download folder %(folder)s") % {'folder':path})
-    
-    def checkForUpgrade(self, runningVersion):
-        """ Checks if the running version of the program is different from the version recorded in the preferences.
         
-        If the version is different, then the preferences are checked to see whether they should be upgraded or not.
+        self.download_start_time = datetime.datetime.now()
+        files_by_scan_pid = self.thumbnails.get_files_checked_for_download()
+        folders_valid = self.check_download_folder_validity(files_by_scan_pid)
+        
+        #FIXME: if invalid, display some kind of error message to the user
         
-        returns True if program preferences window should be opened """
+        if folders_valid:
+            self.thumbnails.mark_download_pending(files_by_scan_pid)
+            for scan_pid in files_by_scan_pid:
+                files = files_by_scan_pid[scan_pid]
+                self.download_files(files, scan_pid)
+                
+        self.set_download_action_label(is_download = False)
         
-        displayPrefs = upgraded = False
+    def pause_download(self):
         
-        previousVersion = self.prefs.program_version
-        if len(previousVersion) > 0:
-            # the program has been run previously for this user
+        self.copy_files_manager.pause()
         
-            pv = common.pythonifyVersion(previousVersion)
-            rv = common.pythonifyVersion(runningVersion)
+        # set action to display Download
+        if not self.download_action_is_download:
+            self.set_download_action_label(is_download = True)
             
-            title = PROGRAM_NAME
-            imageRename = subfolder = None
+    def resume_download(self):
+        self.copy_files_manager.start()
+
+    def download_files(self, files, scan_pid):
+        """
+        Initiate downloading and renaming of files
+        """
+        
+        # Check which file types will be downloaded for this particular process
+        if self.files_of_type_present(files, rpdfile.FILE_TYPE_PHOTO):
+            photo_download_folder = self.prefs.download_folder
+        else:
+            photo_download_folder = None
             
-            if pv != rv:
-                if pv > rv:
-                    prefsOk = rn.checkPreferencesForValidity(self.prefs.image_rename, self.prefs.subfolder, self.prefs.video_rename, self.prefs.video_subfolder)
-                        
-                    msg = _("A newer version of this program was previously run on this computer.\n\n")
-                    if prefsOk:
-                        msg += _("Program preferences appear to be valid, but please check them to ensure correct operation.")
-                    else:
-                        msg += _("Sorry, some preferences are invalid and will be reset.")
-                    sys.stderr.write(_("Warning:") + " %s\n" % msg)
-                    misc.run_dialog(title, msg)
-                    displayPrefs = True
-                
-                else:
-                    cmd_line(_("This version of the program is newer than the previously run version. Checking preferences."))
-
-                    if rn.checkPreferencesForValidity(self.prefs.image_rename, self.prefs.subfolder, self.prefs.video_rename, self.prefs.video_subfolder, previousVersion):
-                        upgraded,  imageRename,  subfolder = rn.upgradePreferencesToCurrent(self.prefs.image_rename, self.prefs.subfolder, previousVersion)
-                        if upgraded:
-                            self.prefs.image_rename = imageRename
-                            self.prefs.subfolder = subfolder
-                            cmd_line(_("Preferences were modified."))
-                            msg = _('This version of the program uses different preferences than the old version. Your preferences have been updated.\n\nPlease check them to ensure correct operation.')
-                            misc.run_dialog(title,  msg)
-                            displayPrefs = True
-                        else:
-                            cmd_line(_("No preferences needed to be changed."))
-                    else:
-                        msg = _('This version of the program uses different preferences than the old version. Some of your previous preferences were invalid, and could not be updated. They will be reset.')
-                        sys.stderr.write(msg + "\n")
-                        misc.run_dialog(title,  msg)
-                        displayPrefs = True
-
-
-        return displayPrefs
-
-    def initPyNotify(self):
-        if not pynotify.init("TestCaps"):
-            sys.stderr.write(_("Problem using pynotify.") + "\n")
-            sys.exit(1)
-
-        capabilities = {'actions':  False,
-            'body':  False,
-            'body-hyperlinks': False,
-            'body-images': False,
-            'body-markup': False,
-            'icon-multi': False,
-            'icon-static': False,
-            'sound': False,
-            'image/svg+xml': False,
-            'append':  False}
-
-        caps = pynotify.get_server_caps ()
-        if caps is None:
-            sys.stderr.write(_("Failed to receive pynotify server capabilities.") + "\n")
-            sys.exit (1)
-
-        for cap in caps:
-            capabilities[cap] = True
-
-        do_not_size_icon = False
-        self.notification_icon_size = 48        
-        try:
-            info = pynotify.get_server_info()
-        except:
-            cmd_line(_("Warning: desktop environment notification server is incorrectly configured."))
+        if self.files_of_type_present(files, rpdfile.FILE_TYPE_VIDEO):
+            video_download_folder = self.prefs.video_download_folder
         else:
-            try:
-                if info["name"] == 'notify-osd':
-                    do_not_size_icon = True
-            except:
-                pass
-        
-        if do_not_size_icon:
-            self.application_icon = gtk.gdk.pixbuf_new_from_file(
-                        paths.share_dir('glade3/rapid-photo-downloader.svg'))
+            video_download_folder = None
+            
+        self.size_of_download_in_bytes_by_scan_pid[scan_pid] = self.size_files_to_be_downloaded(files)
+        self.no_files_in_download_by_scan_pid[scan_pid] = len(files)
+        self.download_active_by_scan_pid.append(scan_pid)
+        # Initiate copy files process
+        self.copy_files_manager.add_task((photo_download_folder, 
+                              video_download_folder, scan_pid,
+                              files))
+                              
+    def copy_files_results(self, source, condition):
+        """
+        Handle results from copy files process
+        """
+        #FIXME: must handle early termination / pause of copy files process
+        connection = self.copy_files_manager.get_pipe(source)
+        conn_type, msg_data = connection.recv()
+        if conn_type == rpdmp.CONN_PARTIAL:
+            msg_type, data = msg_data
+
+            if msg_type == rpdmp.MSG_TEMP_DIRS:
+                scan_pid, photo_temp_dir, video_temp_dir = data
+                self.temp_dirs_by_scan_pid[scan_pid] = (photo_temp_dir, video_temp_dir)                
+            elif msg_type == rpdmp.MSG_BYTES:
+                scan_pid, total_downloaded = data
+                percent_complete = (float(total_downloaded) / 
+                                self.size_of_download_in_bytes_by_scan_pid[scan_pid]) * 100
+                self.device_collection.update_progress(scan_pid, percent_complete,
+                                            None, None)
+            elif msg_type == rpdmp.MSG_FILE:
+                download_succeeded, rpd_file, download_count, temp_full_file_name = data
+                
+                
+                self.download_count_for_file_by_unique_id[rpd_file.unique_id] = download_count
+                self.download_count_by_scan_pid[rpd_file.scan_pid] = download_count
+                rpd_file.download_start_time = self.download_start_time
+                
+                if download_succeeded:
+                    # Insert preference values needed for name generation
+                    rpd_file = prefsrapid.insert_pref_lists(self.prefs, rpd_file)
+                    rpd_file.strip_characters = self.prefs.strip_characters
+                    rpd_file.download_folder = self.prefs.get_download_folder_for_file_type(rpd_file.file_type)
+                
+                #~ if not download_succeeded:
+                    #~ logger.error("File was not downloaded: %s", rpd_file.full_file_name)
+                
+                self.subfolder_file_manager.rename_file_and_move_to_subfolder(
+                        download_succeeded, 
+                        download_count, 
+                        rpd_file
+                        )
+                
+                
+            return True
         else:
-            self.application_icon = gtk.gdk.pixbuf_new_from_file_at_size(
-                    paths.share_dir('glade3/rapid-photo-downloader.svg'),
-                    self.notification_icon_size,  self.notification_icon_size)
+            # Process is complete, i.e. conn_type == rpdmp.CONN_COMPLETE
+            connection.close()
+            return False
+            
 
-        
     
-    def usingVolumeMonitor(self):
-        """
-        Returns True if programs needs to use gio or gnomevfs volume monitor
+    def download_is_occurring(self):
+        """Returns True if a file is currently being downloaded or renamed
         """
-        
-        return (self.prefs.device_autodetection or 
-                (self.prefs.backup_images and 
-                self.prefs.backup_device_autodetection
-                ))
-        
+        return not len(self.download_active_by_scan_pid) == 0
     
-    def startVolumeMonitor(self):
-        if not self.volumeMonitor:
-            self.volumeMonitor = VMonitor(self)
+    # # #
+    # Create folder and file names for downloaded files
+    # # #
     
-    def displayBackupVolumes(self):
+    def subfolder_file_results(self, move_succeeded, rpd_file):
         """
-        Create a message to be displayed to the user showing which backup volumes will be used
+        Handle results of subfolder creation and file renaming
         """
-        message =  ''
-        
-        paths = self.backupVolumes.keys()
-        i = 0
-        v = len(paths)
-        prefix = ''
-        for b in paths:
-            if v > 1:
-                if i < (v -1)  and i > 0:
-                    prefix = ', '
-                elif i == (v - 1) :
-                    prefix = " " + _("and")  + " "
-            i += 1
-            message = "%s%s'%s'" % (message,  prefix, self.backupVolumes[b].get_name())
-        
-        if v > 1:
-            message = _("Using backup devices") + " %s" % message
-        elif v == 1:
-            message = _("Using backup device") + " %s"  % message
-        else:
-            message = _("No backup devices detected")
             
-        return message
+        scan_pid = rpd_file.scan_pid
+        unique_id = rpd_file.unique_id
         
-    def searchForPsd(self):
-        """
-        Check to see if user preferences are to automatically search for Portable Storage Devices or not
-        """
-        return self.prefs.device_autodetection_psd and self.prefs.device_autodetection
+        self._update_file_download_device_progress(scan_pid, unique_id)
         
-
-    def isGProxyShadowMount(self, gMount):
-
-        """ gvfs GProxyShadowMount is used for the camera itself, not the data in the memory card """
-        if using_gio:
-            if hasattr(gMount, 'is_shadowed'):
-                return gMount.is_shadowed()
-            else:
-                return str(type(gMount)).find('GProxyShadowMount') >= 0
-        else:
-            return False
+        self.thumbnails.update_status_post_download(rpd_file)
+        
+        download_count = self.download_count_for_file_by_unique_id[unique_id]
+        if download_count == self.no_files_in_download_by_scan_pid[scan_pid]:
+            # Last file has been downloaded, so clean temp directory
+            logger.debug("Purging temp directories")
+            self._clean_temp_dirs_for_scan_pid(scan_pid)
+            del self.no_files_in_download_by_scan_pid[scan_pid]
+            del self.size_of_download_in_bytes_by_scan_pid[scan_pid]
+            self.download_active_by_scan_pid.remove(scan_pid)
             
-    def isCamera(self, volume):
-        if using_gio:
-            try:
-                return volume.get_root().query_filesystem_info(gio.FILE_ATTRIBUTE_GVFS_BACKEND).get_attribute_as_string(gio.FILE_ATTRIBUTE_GVFS_BACKEND) == 'gphoto2'
-            except:
-                return False
+            if not self.download_is_occurring():
+                logger.debug("Download completed")
+                
+                self.prefs.stored_sequence_no = self.stored_sequence_value.value
+                self.downloads_today_tracker.set_raw_downloads_today_from_int(self.downloads_today_value.value)
+                self.downloads_today_tracker.set_raw_downloads_today_date(self.downloads_today_date_value.value)
+                self.prefs.set_downloads_today_from_tracker(self.downloads_today_tracker)
+                
+                self.display_free_space()
+                
+                self.set_download_action_label(is_download=True)
+                self.set_download_action_sensitivity()
         else:
-            return False
+            pass
+            #~ logger.info("Download count: %s", download_count)
+
 
-    def workerHasThisPath(self,  path):
-        havePath= False
-        for w in workers.getNonFinishedWorkers():
-            if w.cardMedia.path == path:
-                havePath = True
-                break
-        return havePath
         
-    def on_volume_mounted(self, monitor, mount):
+    def _update_file_download_device_progress(self, scan_pid, unique_id):
         """
-        callback run when gnomevfs indicates a new volume
-        has been mounted
+        Increments the progress bar for an individual device
         """
-        
-        if self.usingVolumeMonitor():
-            volume = Volume(mount)
-            path = volume.get_path()
-             
-            if path in self.prefs.device_blacklist and self.searchForPsd():
-                cmd_line(_("Device %(device)s (%(path)s) ignored") % {
-                            'device': volume.get_name(limit=0), 'path': path})
-            else:
-                if not self.isGProxyShadowMount(mount):
-                    self._printDetectedDevice(volume.get_name(limit=0),  path)
-                    
-                    isBackupVolume = self.checkIfBackupVolume(path)
-                                
-                    if isBackupVolume:
-                        if path not in self.backupVolumes:
-                            self.backupVolumes[path] = volume
-                            self.displayFreeSpace()
-
-                    elif self.prefs.device_autodetection and (media.is_DCIM_Media(path) or self.searchForPsd()):
-                        if self.isCamera(volume.volume):
-                            self.getShowWarningDownloadingFromCamera()
-                        if self.searchForPsd() and path not in self.prefs.device_whitelist:
-                            # prompt user if device should be used or not
-                            self.getUseDevice(path, volume, self.prefs.auto_download_upon_device_insertion)
-                        else:   
-                            self._printAutoStart(self.prefs.auto_download_upon_device_insertion)                   
-                            self.initiateScan(path, volume, self.prefs.auto_download_upon_device_insertion)
-                             
-    def initiateScan(self, path, volume, autostart):
-        """ initiates scan of image device"""
-        cardMedia = CardMedia(path, volume)
-        i = workers.getNextThread_id()
-        
-        workers.append(CopyPhotos(i, self, self.fileRenameLock, 
-                                    self.fileSequenceLock, self.statsLock,
-                                    self.downloadedFilesLock, self.downloadStats,
-                                    autostart, cardMedia))
-
-
-        self.setDownloadButtonSensitivity()
-        self.startScan()
-
-        
-    def on_volume_unmounted(self, monitor, volume):
+        #~ scan_pid = rpd_file.scan_pid
+        #~ unique_id = rpd_file.unique_id
+        progress_bar_text = _("%(number)s of %(total)s %(filetypes)s") % \
+                             {'number':  self.download_count_for_file_by_unique_id[unique_id], 
+                              'total': self.no_files_in_download_by_scan_pid[scan_pid],
+                              'filetypes': self.file_types_present_by_scan_pid[scan_pid]}
+        self.device_collection.update_progress(scan_pid, None, progress_bar_text, None)        
+
+    def _clean_all_temp_dirs(self):
         """
-        callback run when gnomevfs indicates a volume
-        has been unmounted
+        Cleans all temp dirs if they exist
         """
-        
-        v = Volume(volume)
-        path = v.get_path()
-
-        # four scenarios -
-        # volume is waiting to be scanned
-        # the volume has been scanned but downloading has not yet started
-        # images are being downloaded from volume (it must be a messy unmount)
-        # images finished downloading from volume
-        
-        if path:
-            # first scenario
-
-            for w in workers.getReadyToStartWorkers():
-                if w.cardMedia.volume:
-                    if w.cardMedia.volume.volume == volume:
-                        media_collection_treeview.removeCard(w.thread_id)
-                        self.selection_vbox.selection_treeview.clear_all(w.thread_id)
-                        workers.disableWorker(w.thread_id)
-            # second scenario
-            for w in workers.getReadyToDownloadWorkers():
-                if w.cardMedia.volume:                
-                    if w.cardMedia.volume.volume == volume:
-                        media_collection_treeview.removeCard(w.thread_id)
-                        self.selection_vbox.selection_treeview.clear_all(w.thread_id)
-                        workers.disableWorker(w.thread_id)
-                    
-            # fourth scenario - nothing to do
-                    
-            # remove backup volumes
-            if path in self.backupVolumes:
-                del self.backupVolumes[path]
-                self.displayFreeSpace()
+        for scan_pid in self.temp_dirs_by_scan_pid:
+            for temp_dir in self.temp_dirs_by_scan_pid[scan_pid]:
+                self._purge_dir(temp_dir)
                 
-            # may need to disable download button
-            self.setDownloadButtonSensitivity()
-        
+        self.temp_dirs_by_scan_pid = {}
+            
     
-    def clearCompletedDownloads(self):
+    def _clean_temp_dirs_for_scan_pid(self, scan_pid):
         """
-        clears the display of completed downloads
+        Deletes temp files and folders used in download
         """
+        for temp_dir in self.temp_dirs_by_scan_pid[scan_pid]:
+            self._purge_dir(temp_dir)
+        del self.temp_dirs_by_scan_pid[scan_pid]
 
-        for w in workers.getFinishedWorkers():
-            media_collection_treeview.removeCard(w.thread_id)
-            self.selection_vbox.selection_treeview.clear_all(w.thread_id)
-
-            
-
-        
-    def clearNotStartedDownloads(self):
-        """
-        Clears the display of the download and instructs the thread not to run
-        """
-        
-        for w in workers.getNotDownloadingWorkers():
-            media_collection_treeview.removeCard(w.thread_id)
-            workers.disableWorker(w.thread_id)
-    
-    def checkIfBackupVolume(self,  path):
+    def _purge_dir(self, directory):
         """
-        Checks to see if backups are enabled and path represents a valid backup location
+        Deletes all files in the directory, and the directory itself.
         
-        Checks against user preferences.
+        Does not recursively traverse any subfolders in the directory.
         """
-        identifiers = [self.prefs.backup_identifier]
-        if DOWNLOAD_VIDEO:
-            identifiers.append(self.prefs.video_backup_identifier)
-        if self.prefs.backup_images:
-            if self.prefs.backup_device_autodetection:
-                if media.isBackupMedia(path, identifiers):
-                    return True
-            elif path == self.prefs.backup_location:
-                # user manually specified the path
-                return True
-        return False
-        
-    def _printDetectedDevice(self,  volume_name, path):
-        cmd_line (_("Detected %(device)s with path %(path)s") % {'device': volume_name,   'path': path})
         
-    def _printAutoStart(self,  autoStart):
-        if autoStart:
-            cmd_line(_("Automatically start download is true") )
-        else:
-            cmd_line(_("Automatically start download is false") )
-        
-    def setupAvailableImageAndBackupMedia(self, onStartup, onPreferenceChange, doNotAllowAutoStart):
+        if directory:
+            try:
+                path = gio.File(directory)
+                # first delete any files in the temp directory
+                # assume there are no directories in the temp directory
+                file_attributes = "standard::name,standard::type"
+                children = path.enumerate_children(file_attributes)
+                for child in children:
+                    f = path.get_child(child.get_name())
+                    #~ logger.info("Deleting %s", child.get_name())
+                    f.delete(cancellable=None)
+                path.delete(cancellable=None)
+                logger.debug("Deleted directory %s", directory)
+            except gio.Error, inst:
+                logger.error("Failure deleting temporary folder %s", directory)
+                logger.error(inst)
+    
+    
+    # # # 
+    # Preferences
+    # # #
+
+    def check_prefs_on_startup(self):
         """
-        Sets up volumes for downloading from and backing up to
-        
-        onStartup should be True if the program is still starting, i.e. this is being called from the 
-        program's initialization.
+        Checks the image & video rename, and subfolder prefs for validity.
         
-        onPreferenceChange should be True if this is being called as the result of a preference
-        being changed
-        
-        Removes any image media that are currently not downloaded, 
-        or finished downloading
+        Returns True if no problem, false otherwise.
         """
+        prefs_ok = prefsrapid.check_prefs_for_validity(self.prefs.image_rename,
+                                                       self.prefs.subfolder,
+                                                       self.prefs.video_rename,
+                                                       self.prefs.video_subfolder)
+        if not prefs_ok:
+            logger.error("There is an error in the program preferences. Some preferences will be reset.")
+        return prefs_ok
         
-        self.clearNotStartedDownloads()
-        
-        volumeList = []
-        self.backupVolumes = {}
         
-        if not workers.noDownloadingWorkers():
-            self.downloadStats.clear() 
-            self._resetDownloadInfo()
-        
-        if self.usingVolumeMonitor():
-            # either using automatically detected backup devices
-            # or download devices
-            
-            for v in self.volumeMonitor.get_mounts():
-                volume = Volume(v) #'volumes' are actually mounts (legacy variable name at work here)
-                path = volume.get_path(avoid_gnomeVFS_bug = True)
-
-                if path:
-                    if path in self.prefs.device_blacklist and self.searchForPsd():
-                        cmd_line(_("Device %(device)s (%(path)s) ignored") % {
-                                    'device': volume.get_name(limit=0), 
-                                    'path': path})
-                    else:
-                        if not self.isGProxyShadowMount(v):
-                            self._printDetectedDevice(volume.get_name(limit=0), path)
-                            isBackupVolume = self.checkIfBackupVolume(path)
-                            if isBackupVolume:
-                                #backupPath = os.path.join(path,  self.prefs.backup_identifier)
-                                self.backupVolumes[path] = volume
-                            elif self.prefs.device_autodetection and (media.is_DCIM_Media(path) or self.searchForPsd()):
-                                volumeList.append((path, volume))
-                        
-        
-        if not self.prefs.device_autodetection:
-            # user manually specified the path from which to download 
-            path = self.prefs.device_location
-            if path:
-                cmd_line(_("Using manually specified path") + " %s" %  path)
-                volumeList.append((path,  None))
-                    
-        if self.prefs.backup_images:
-            if not self.prefs.backup_device_autodetection:
-                # user manually specified backup location
-                # will backup to this path, but don't need any volume info associated with it
-                self.backupVolumes[self.prefs.backup_location] = None
-        
-        self.displayFreeSpace()
-        # add each memory card / other device to the list of threads
-        
-        if doNotAllowAutoStart:
-            autoStart = False
-        else:
-            autoStart = (not onPreferenceChange) and ((self.prefs.auto_download_at_startup and onStartup) or (self.prefs.auto_download_upon_device_insertion and not onStartup))
+    def _init_prefs(self): 
+        self.prefs = prefsrapid.RapidPreferences()
+        self.prefs.notify_add(self.on_preference_changed)
         
-        self._printAutoStart(autoStart)
+        # flag to indicate whether the user changed some preferences that 
+        # indicate the image and backup devices should be setup again
+        self.rerun_setup_available_image_and_video_media = False
+        self.rerun_setup_available_backup_media = False
         
-        shownWarning = False
+        # flag to indicate that the preferences dialog window is being 
+        # displayed to the user
+        self.preferences_dialog_displayed = False
 
-        for i in range(len(volumeList)):
-            path, volume = volumeList[i]
-            if volume:
-                if self.isCamera(volume.volume) and not shownWarning:
-                    self.getShowWarningDownloadingFromCamera()
-                    shownWarning = True
-            if self.searchForPsd() and path not in self.prefs.device_whitelist:
-                # prompt user to see if device should be used or not
-                self.getUseDevice(path, volume, autoStart)
-            else:
-                self.initiateScan(path, volume, autoStart)
-                
-    def refreshBackupMedia(self):
-        """
-        Setup the backup media
+        # flag to indicate that the user has modified the download today
+        # related values in the preferences dialog window
+        self.refresh_downloads_today = False
         
-        Assumptions: this is being called after the user has changed their preferences AND download media has already been setup
-        """
-        self.backupVolumes = {}
-        if self.prefs.backup_images:
-            if not self.prefs.backup_device_autodetection:
-                # user manually specified backup location
-                # will backup to this path, but don't need any volume info associated with it
-                self.backupVolumes[self.prefs.backup_location] = None
-            else:
-                for v in self.volumeMonitor.get_mounts():
-                    volume = Volume(v)
-                    path = volume.get_path(avoid_gnomeVFS_bug = True)
-                    if path:
-                        if self.checkIfBackupVolume(path):
-                            # is a backup volume
-                            if path not in self.backupVolumes:
-                                # ensure it is not in a list of workers which have not started downloading
-                                # if it is, remove it
-                                for w in workers.getNotDownloadingAndNotFinishedWorkers():
-                                    if w.cardMedia.path == path:
-                                        media_collection_treeview.removeCard(w.thread_id)
-                                        self.selection_vbox.selection_treeview.clear_all(w.thread_id)
-                                        workers.disableWorker(w.thread_id)
-                                
-                                downloading_workers = []
-                                for w in workers.getDownloadingWorkers():
-                                    downloading_workers.append(w)
-                                
-                                for w in downloading_workers:
-                                    if w.cardMedia.path == path:
-                                        # the user is trying to backup to a device that is currently being downloaded from..... we don't normally allow that, but what to do?
-                                        cmd_line(_("Warning: backup device %(device)s is currently being downloaded from") % {'device': volume.get_name(limit=0)})
-                                        
-                                self.backupVolumes[path] = volume
-                        
-        self.displayFreeSpace()
+        self.downloads_today_tracker = self.prefs.get_downloads_today_tracker()
         
-    def _setupDownloadbuttons(self):
-        self.download_hbutton_box = gtk.HButtonBox()
-        self.download_hbutton_box.set_spacing(12)
-        self.download_hbutton_box.set_homogeneous(False)
-
-        help_button = gtk.Button(stock=gtk.STOCK_HELP)
-        help_button.connect("clicked", self.on_help_button_clicked)
-        self.download_hbutton_box.pack_start(help_button)
-        self.download_hbutton_box.set_child_secondary(help_button, True)
-    
-        self.DOWNLOAD_SELECTED_LABEL = _("D_ownload Selected")
-        self.download_button_is_download = True
-        self.download_button = gtk.Button() 
-        self.download_button.set_use_underline(True)
-        self.download_button.set_flags(gtk.CAN_DEFAULT)
-        self.download_selected_button = gtk.Button() 
-        self.download_selected_button.set_use_underline(True)        
-        self._set_download_button()
-        self.download_button.connect('clicked', self.on_download_button_clicked)
-        self.download_selected_button.connect('clicked', self.on_download_selected_button_clicked)
-        self.download_hbutton_box.set_layout(gtk.BUTTONBOX_END)
-        self.download_hbutton_box.pack_start(self.download_selected_button)        
-        self.download_hbutton_box.pack_start(self.download_button)
-        self.download_hbutton_box.show_all()
-        self.buttons_hbox.pack_start(self.download_hbutton_box, 
-                                    padding=hd.WINDOW_BORDER_SPACE)
-                                    
-        self.setDownloadButtonSensitivity()
-
-    def set_display_selection(self, value):
-        if value:
-            self.selection_vbox.preview_table.show_all()
+        downloads_today = self.downloads_today_tracker.get_and_maybe_reset_downloads_today()
+        if downloads_today > 0:
+            logger.info("Downloads that have occurred so far today: %s", downloads_today)
         else:
-            self.selection_vbox.preview_table.hide()
-        self.selection_vbox.set_display_preview_folders(self.prefs.display_preview_folders)
-            
-    def set_display_preview_folders(self, value):
-        self.selection_vbox.set_display_preview_folders(value)
-       
-    def _resetDownloadInfo(self):
-        self.markSet = False
-        self.startTime = None
-        self.totalDownloadSize = self.totalDownloadedSoFar = 0
-        self.totalDownloadSizeThisRun = self.totalDownloadedSoFarThisRun = 0 
-        # there is no need to clear self.timeRemaining, as when each thread is completed, it removes itself
-        
-        # this next value is used by the date time option "Download Time"
-        self.download_start_time = None 
-        
-        global job_code
-        job_code = None
-    
-    def addToTotalDownloadSize(self,  size):
-        self.totalDownloadSize += size
-        
-    def setOverallDownloadMark(self):
-        if not self.markSet:
-            self.markSet = True
-            self.totalDownloadSizeThisRun = self.totalDownloadSize - self.totalDownloadedSoFar
-            self.totalDownloadedSoFarThisRun = 0
-                
-            self.startTime = time.time()
-            self.timeStatusBarUpdated = self.startTime
+            logger.info("No downloads have occurred so far today")        
 
-            self.timeMark = self.startTime
-            self.sizeMark = 0            
+        self.downloads_today_value = Value(c_int, 
+                        self.downloads_today_tracker.get_raw_downloads_today())
+        self.downloads_today_date_value = Array(c_char,
+                        self.downloads_today_tracker.get_raw_downloads_today_date())
+        self.day_start_value = Array(c_char, 
+                        self.downloads_today_tracker.get_raw_day_start())
+        self.refresh_downloads_today_value = Value(c_bool, False)
+        self.stored_sequence_value = Value(c_int, self.prefs.stored_sequence_no)
+        self.uses_stored_sequence_no_value = Value(c_bool, self.prefs.any_pref_uses_stored_sequence_no())
+        self.uses_session_sequece_no_value = Value(c_bool, self.prefs.any_pref_uses_session_sequece_no())
+        self.uses_sequence_letter_value = Value(c_bool, self.prefs.any_pref_uses_sequence_letter_value())
         
-    def startOrResumeWorkers(self, threads):
-                    
-        # resume any paused workers
-        for w in workers.getPausedDownloadingWorkers():
-            w.startStop()
-            self.timeRemaining.setTimeMark(w)
-        
-        # set the time that the download started - this is used
-        # in the "Download Time" date time renaming option.
-        self.setDownloadStartTime()
-
-            
-        #start any new workers that have downloads pending
-        for i in threads:
-            workers[i].startStop()
+        self.prefs.program_version = __version__
         
-        if is_beta and verbose and False:
-            workers.printWorkerStatus()
+    def _check_for_sequence_value_use(self):
+        self.uses_stored_sequence_no_value.value = self.prefs.any_pref_uses_stored_sequence_no()
+        self.uses_session_sequece_no_value.value = self.prefs.any_pref_uses_session_sequece_no()
+        self.uses_sequence_letter_value.value = self.prefs.any_pref_uses_sequence_letter_value()    
     
-    def setDownloadStartTime(self):
-        if not self.download_start_time:
-            self.download_start_time = datetime.datetime.now()
-        
-    def updateOverallProgress(self, thread_id, bytesDownloaded, percentComplete):
+    def on_preference_changed(self, key, value):
         """
-        Updates progress bar and status bar text with time remaining
-        to download images
+        Called when user changes the program's preferences
         """
+        logger.debug("Preference change detected: %s", key)
+        
+
+        if key == 'show_log_dialog':
+            self.menu_log_window.set_active(value)
+        elif key in ['device_autodetection', 'device_autodetection_psd', 'device_location']:
+            self.rerun_setup_available_image_and_video_media = True
+            if not self.preferences_dialog_displayed:
+                self.post_preference_change()
                 
-        self.totalDownloadedSoFar += bytesDownloaded
-        self.totalDownloadedSoFarThisRun += bytesDownloaded
-        
-        fraction = self.totalDownloadedSoFar / float(self.totalDownloadSize)
-        
-        self.download_progressbar.set_fraction(fraction)        
-        
-        if percentComplete == 100.0:
-            self.menu_clear.set_sensitive(True)
-            self.timeRemaining.remove(thread_id)
-
-        if self.downloadComplete():
-            # finished all downloads
-            self.rapid_statusbar.push(self.statusbar_context_id, "")
-            self.download_button_is_download = True
-            self._set_download_button()
-            self.setDownloadButtonSensitivity()
-            cmd_line(_("All downloads complete"))
-            job_code = None
-            if is_beta and verbose and False:
-                workers.printWorkerStatus()
-    
-        else:
-            now = time.time()
-            self.timeRemaining.update(thread_id, bytesDownloaded)
-            
-            if now > (self.downloadTimeGap + self.timeMark):
-                amtTime = now - self.timeMark
-                self.timeMark = now
-                amtDownloaded = self.totalDownloadedSoFarThisRun - self.sizeMark
-                self.sizeMark = self.totalDownloadedSoFarThisRun
-                amtToDownload = float(self.totalDownloadSizeThisRun) - self.totalDownloadedSoFarThisRun
-                downloadSpeed = "%1.1f" % (amtDownloaded / 1048576 / amtTime) +_("MB/s")
-                self.speed_label.set_text(downloadSpeed)
+        elif key in ['backup_images', 'backup_device_autodetection', 'backup_location', 'backup_identifier', 'video_backup_identifier']:
+            self.rerun_setup_available_backup_media = True
+            if not self.preferences_dialog_displayed:
+                self.post_preference_change()
                 
-                timeRemaining = self.timeRemaining.timeRemaining()
-                if timeRemaining:
-                    secs =  int(timeRemaining)
+        # Downloads today and stored sequence numbers are kept in shared memory,
+        # so that the subfolderfile daemon process can access and modify them
+        
+        # Note, totally ignore any changes in downloads today, as it
+        # is modified in a special manner via a tracking class
                 
-                    if secs == 0:
-                        message = ""
-                    elif secs == 1:
-                        message = _("About 1 second remaining")
-                    elif secs < 60:
-                        message = _("About %i seconds remaining") % secs 
-                    elif secs == 60:
-                        message = _("About 1 minute remaining")
-                    else:
-                        # Translators: in the text '%(minutes)i:%(seconds)02i', only the : should be translated, if needed. 
-                        # '%(minutes)i' and '%(seconds)02i' should not be modified or left out. They are used to format and display the amount
-                        # of time the download has remainging, e.g. 'About 5:36 minutes remaining'
-                        message = _("About %(minutes)i:%(seconds)02i minutes remaining") % {'minutes': secs / 60, 'seconds': secs % 60}
-                    
-                    self.rapid_statusbar.pop(self.statusbar_context_id)
-                    self.rapid_statusbar.push(self.statusbar_context_id, message)
-                    
-    
-    def resetSequences(self):
-        if self.downloadComplete():
-            sequences.reset(self.prefs.getDownloadsToday(),  self.prefs.stored_sequence_no)
+        elif key == 'stored_sequence_no':
+            if type(value) <> types.IntType:
+                logger.critical("Stored sequence number value is malformed")
+            else:
+                self.stored_sequence_value.value = value
+                
+        elif key in ['image_rename', 'subfolder', 'video_rename', 'video_subfolder']:
+            # Check if stored sequence no is being used
+            self._check_for_sequence_value_use()
+            
+        #~ elif key == 'job_codes':
+            #~ # update job code list in left pane
+            #~ self.selection_vbox.update_job_code_combo()
+            
+        elif key in ['download_folder', 'video_download_folder']:
+            self.display_free_space()
     
-    def notifyUserAllDownloadsComplete(self):
-        """ If all downloads are complete, if needed notify the user using libnotify 
-        
-        Reset progress bar info"""
-        
-        if self.downloadComplete():
-            if self.displayDownloadSummaryNotification:
-                message = _("All downloads complete")
-                if self.downloadStats.noImagesDownloaded:
-                    filetype = file_types_by_number(self.downloadStats.noImagesDownloaded, 0)
-                    message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                                {'number': self.downloadStats.noImagesDownloaded, 
-                                'numberdownloaded': _("%(filetype)s downloaded") % \
-                                {'filetype': filetype}}
-                if self.downloadStats.noImagesSkipped:
-                    filetype = file_types_by_number(self.downloadStats.noImagesSkipped, 0)
-                    message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                                {'number': self.downloadStats.noImagesSkipped,
-                                'numberdownloaded': _("%(filetype)s failed to download") % \
-                                {'filetype': filetype}}
-                if self.downloadStats.noVideosDownloaded:
-                    filetype = file_types_by_number(0, self.downloadStats.noVideosDownloaded)
-                    message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                                {'number': self.downloadStats.noVideosDownloaded, 
-                                'numberdownloaded': _("%(filetype)s downloaded") % \
-                                {'filetype': filetype}}                    
-                if self.downloadStats.noVideosSkipped:
-                    filetype = file_types_by_number(0, self.downloadStats.noVideosSkipped)
-                    message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                                {'number': self.downloadStats.noVideosSkipped,
-                                'numberdownloaded': _("%(filetype)s failed to download") % \
-                                {'filetype': filetype}}                    
-                if self.downloadStats.noWarnings:
-                    message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                                {'number': self.downloadStats.noWarnings, 
-                                'numberdownloaded': _("warnings")}
-                if self.downloadStats.noErrors:
-                    message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                                {'number': self.downloadStats.noErrors, 
-                                'numberdownloaded': _("errors")}
-                    
-                n = pynotify.Notification(PROGRAM_NAME,  message)
-                n.set_icon_from_pixbuf(self.application_icon)
-                n.show()
-                self.displayDownloadSummaryNotification = False # don't show it again unless needed
-                # download statistics are cleared in exitOnDownloadComplete()
-            self._resetDownloadInfo()
-            self.speed_label.set_text('         ')
-            self.displayFreeSpace()
+    def post_preference_change(self):
+        if self.rerun_setup_available_image_and_video_media:
+            if self.using_volume_monitor():
+                self.start_volume_monitor()
+            logger.info("Download device settings preferences were changed.")
             
+            self.thumbnails.clear_all()
+            self.setup_devices(on_startup = False, on_preference_change = True, do_not_allow_auto_start = True)
                 
-    def exitOnDownloadComplete(self):
-        if self.downloadComplete():
-            if self.prefs.auto_exit:
-                if not (self.downloadStats.noErrors or self.downloadStats.noWarnings):                
-                    self.quit()
-            # since for whatever reason am not exiting, clear the download statistics
-            self.downloadStats.clear()
-        
+            self.rerun_setup_available_image_and_video_media = False
+            
+        if self.rerun_setup_available_backup_media:
+            if self.using_volume_monitor():
+                self.start_volume_monitor()          
+            logger.info("Backup preferences were changed.")
+            
+            logger.info("self.refreshBackupMedia()")
+            
+            self.rerun_setup_available_backup_media = False
+            
+        if self.refresh_downloads_today:
+            self.downloads_today_value.value = self.downloads_today_tracker.get_raw_downloads_today()
+            self.downloads_today_date_value.value = self.downloads_today_tracker.get_raw_downloads_today_date()
+            self.day_start_value.value = self.downloads_today_tracker.get_raw_day_start()
+            self.refresh_downloads_today_value.value = True
+            self.prefs.set_downloads_today_from_tracker(self.downloads_today_tracker)
+            
+
     
-    def downloadFailed(self, thread_id):
-        if workers.noDownloadingWorkers() == 0:
-            self.download_button_is_download = True
-            self._set_download_button()
-            self.setDownloadButtonSensitivity()
+    # # #
+    # Main app window management and setup
+    # # #
     
-    def downloadComplete(self):
-        return self.totalDownloadedSoFar == self.totalDownloadSize
-
-    def setDownloadButtonSensitivity(self):
-
-        isSensitive = (workers.noReadyToDownloadWorkers() > 0 and 
-                        workers.noScanningWorkers() == 0 and
-                        self.selection_vbox.selection_treeview.rows_available_for_download()) or \
-                        workers.noDownloadingWorkers() > 0
+    def _init_widgets(self):
+        """
+        Initialize widgets in the main window, and variables that point to them
+        """
+        builder = gtk.Builder()
+        self.builder = builder
+        builder.add_from_file(paths.share_dir("glade3/rapid.ui"))
+        self.rapidapp = builder.get_object("rapidapp")
+        self.main_vpaned = builder.get_object("main_vpaned")
+        self.main_notebook = builder.get_object("main_notebook")
+        self.download_action = builder.get_object("download_action")
         
-        if isSensitive:
-            self.download_button.props.sensitive = True
-            # download selected button sensitity is enabled only when the user selects something
-            self.selection_vbox.selection_treeview.update_download_selected_button()
-            self.menu_download_pause.props.sensitive = True
-        else:
-            self.download_button.props.sensitive = False
-            self.download_selected_button.props.sensitive = False
-            self.menu_download_pause.props.sensitive = False
-            
-        return isSensitive
+        self.download_progressbar = builder.get_object("download_progressbar")
+        self.rapid_statusbar = builder.get_object("rapid_statusbar")
+        self.statusbar_context_id = self.rapid_statusbar.get_context_id("progress")
+        self.device_collection_scrolledwindow = builder.get_object("device_collection_scrolledwindow")
+        self.next_image_action = builder.get_object("next_image_action")
+        self.prev_image_action = builder.get_object("prev_image_action")
         
+        # Only enable this action when actually displaying a preview
+        self.next_image_action.set_sensitive(False)
+        self.prev_image_action.set_sensitive(False)        
         
-    def on_rapidapp_destroy(self, widget):
-        """Called when the application is going to quit"""
+        # About dialog
+        builder.add_from_file(paths.share_dir("glade3/about.ui"))
+        self.about = builder.get_object("about")
         
-        # save window and component sizes
-        self.prefs.hpaned_pos = self.selection_vbox.file_hpaned.get_position()
-        self.prefs.vpaned_pos = self.main_vpaned.get_position()
-
-        x, y = self.rapidapp.get_size()
-        self.prefs.main_window_size_x = x
-        self.prefs.main_window_size_y = y
-
-        workers.quitAllWorkers()
-
-        self.flushevents() 
+        builder.connect_signals(self)
         
-        display_queue.close("w")
-
-
-    def on_rapidapp_window_state_event(self, widget, event):
-        """ Checkto see if the user maximized the main application window or not. """
-        if event.changed_mask & gdk.WINDOW_STATE_MAXIMIZED:
-            self.prefs.main_window_maximized = event.new_window_state & gdk.WINDOW_STATE_MAXIMIZED
-                
+        self.preview_image = PreviewImage(self, builder)
 
-    def on_menu_clear_activate(self, widget):
-        self.clearCompletedDownloads()
-        widget.set_sensitive(False)
+        thumbnails_scrolledwindow = builder.get_object('thumbnails_scrolledwindow')
+        self.thumbnails = ThumbnailDisplay(self)
+        thumbnails_scrolledwindow.add(self.thumbnails)        
         
-    def on_menu_refresh_activate(self, widget):
-        self.selection_vbox.selection_treeview.clear_all()
-        self.setupAvailableImageAndBackupMedia(onStartup = False,  onPreferenceChange = True,  doNotAllowAutoStart = True)
+        #collection of devices from which to download
+        self.device_collection_viewport = builder.get_object("device_collection_viewport")
+        self.device_collection = DeviceCollection(self)
+        self.device_collection_viewport.add(self.device_collection)
         
-    def on_menu_report_problem_activate(self,  widget):
-        webbrowser.open("https://bugs.launchpad.net/rapid") 
+        # monitor to handle mounts and dismounts
+        self.vmonitor = None
+        # track scan ids for mount paths - very useful when a device is unmounted
+        self.mounts_by_path = {}
         
-    def on_menu_get_help_online_activate(self,  widget):
-        webbrowser.open("http://www.damonlynch.net/rapid/help.html") 
-
-    def on_menu_donate_activate(self,  widget):
-        webbrowser.open("http://www.damonlynch.net/rapid/donate.html") 
-
-    def on_menu_translate_activate(self,  widget):
-        webbrowser.open("http://www.damonlynch.net/rapid/translate.html") 
-
-    def on_menu_preferences_activate(self, widget):
-        """ Sets preferences for the application using dialog window """
+        # Download action state
+        self.download_action_is_download = True
+        
+        #job code initialization
+        self.last_chosen_job_code = None
+        self.prompting_for_job_code = False
 
-        PreferencesDialog(self)
+    def _set_window_size(self):
+        """
+        Remember the window size from the last time the program was run, or
+        set a default size        
+        """
         
-    def on_menu_log_window_toggled(self, widget):
-        active = widget.get_active()
-        self.prefs.show_log_dialog = active
-        if active:
-            log_dialog.widget.show()
+        if self.prefs.main_window_maximized:
+            self.rapidapp.maximize()
+            self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH, 
+                                           config.DEFAULT_WINDOW_HEIGHT)
+        elif self.prefs.main_window_size_x > 0:
+            self.rapidapp.set_default_size(self.prefs.main_window_size_x, self.prefs.main_window_size_y)
         else:
-            log_dialog.widget.hide()
+            # set a default size
+            self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH, 
+                                           config.DEFAULT_WINDOW_HEIGHT)
+        
 
-    def on_menu_display_selection_toggled(self, check_button):
-        self.prefs.display_selection = check_button.get_active()
+    def _set_device_collection_size(self):
+        """
+        Set the size of the device collection scrolled window widget
+        """
         
-    def on_menu_preview_folders_toggled(self, check_button):
-        self.prefs.display_preview_folders = check_button.get_active()
         
-    def on_menu_zoom_out_activate(self, widget):
-        self.selection_vbox.zoom_out()
+        if self.device_collection.map_process_to_row:
+            height = self.device_collection_viewport.size_request()[1]
+            self.device_collection_scrolledwindow.set_size_request(-1,  height)
+        else:
+            # don't allow the media collection to be absolutely empty
+            self.device_collection_scrolledwindow.set_size_request(-1, 47)
         
-    def on_menu_zoom_in_activate(self, widget):
-        self.selection_vbox.zoom_in()
+            
+    def on_rapidapp_window_state_event(self, widget, event):
+        """ Records the window maximization state in the preferences."""
         
-    def on_menu_select_all_activate(self, widget):
-        self.selection_vbox.selection_treeview.select_rows('all')
-
-    def on_menu_select_all_photos_activate(self, widget):
-        self.selection_vbox.selection_treeview.select_rows('photos')
-    
-    def on_menu_select_all_videos_activate(self, widget):
-        self.selection_vbox.selection_treeview.select_rows('videos')
+        if event.changed_mask & gdk.WINDOW_STATE_MAXIMIZED:
+            self.prefs.main_window_maximized = event.new_window_state & gdk.WINDOW_STATE_MAXIMIZED
         
-    def on_menu_select_none_activate(self, widget):
-        self.selection_vbox.selection_treeview.select_rows('none')
+    def _setup_buttons(self):
+        thumbnails_button = self.builder.get_object("thumbnails_button")
+        image = gtk.image_new_from_file(paths.share_dir('glade3/thumbnails_icon.png'))
+        thumbnails_button.set_image(image)
         
-    def on_menu_select_all_with_job_code_activate(self, widget):
-        self.selection_vbox.selection_treeview.select_rows('withjobcode')
-
-    def on_menu_select_all_without_job_code_activate(self, widget):
-        self.selection_vbox.selection_treeview.select_rows('withoutjobcode')
-
-
-    def on_menu_about_activate(self, widget):
-        """ Display about dialog box """
-
-        about = gtk.glade.XML(paths.share_dir(config.GLADE_FILE), "about").get_widget("about")
-        about.set_property("name", PROGRAM_NAME)
-        about.set_property("version", __version__)
-        about.run()
-        about.destroy()       
-
-    def _set_download_button(self):
+        preview_button = self.builder.get_object("preview_button")
+        image = gtk.image_new_from_file(paths.share_dir('glade3/photo_icon.png'))
+        preview_button.set_image(image)
+        
+        next_image_button = self.builder.get_object("next_image_button")
+        image = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_BUTTON)
+        next_image_button.set_image(image)
+        
+        prev_image_button = self.builder.get_object("prev_image_button")
+        image = gtk.image_new_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_BUTTON)
+        prev_image_button.set_image(image)
+    
+    def _setup_icons(self):
+        icons = ['rapid-photo-downloader-jobcode',]
+        icon_list = [(icon, paths.share_dir('glade3/%s.svg' % icon)) for icon in icons]        
+        register_iconsets(icon_list)
+    
+    def _setup_error_icons(self):
         """
-        Sets download button to appropriate state
+        hide display of warning and error symbols in the taskbar until they
+        are needed
         """
+        self.error_image = self.builder.get_object("error_image")
+        self.warning_image = self.builder.get_object("warning_image")
+        self.warning_vseparator = self.builder.get_object("warning_vseparator")
+        self.error_image.hide()
+        self.warning_image.hide()
+        self.warning_vseparator.hide()
         
-        if self.download_button_is_download:
-            # This text will be displayed to the user on the Download / Pause button.
-            self.download_selected_button.set_label(self.DOWNLOAD_SELECTED_LABEL)
-            self.download_selected_button.set_image(gtk.image_new_from_stock(
-                                                gtk.STOCK_CONVERT,
-                                                gtk.ICON_SIZE_BUTTON))
-            self.selection_vbox.selection_treeview.update_download_selected_button()
-            
-            self.download_button.set_image(gtk.image_new_from_stock(
-                                                gtk.STOCK_CONVERT,
-                                                gtk.ICON_SIZE_BUTTON))
-            
-            if workers.noPausedWorkers():
-                self.download_button.set_label(_("_Resume"))
-                self.download_selected_button.hide()
+    def statusbar_message(self, msg):
+        self.rapid_statusbar.push(self.statusbar_context_id, msg)
+        
+    def statusbar_message_remove(self):
+        self.rapid_statusbar.pop(self.statusbar_context_id)
+        
+    def display_free_space(self):
+        """
+        Displays the amount of space free on the filesystem the files will be 
+        downloaded to.
+        
+        Also displays backup volumes / path being used. (NOT IMPLEMENTED YET)
+        """
+        photo_dir = self.is_valid_download_dir(self.prefs.download_folder)
+        video_dir = self.is_valid_download_dir(self.prefs.video_download_folder)
+        if photo_dir and video_dir:
+            same_file_system = self.same_file_system(self.prefs.download_folder,
+                                            self.prefs.video_download_folder)
+        else:
+            same_file_system = False
+                
+        dirs = []
+        if photo_dir:
+            dirs.append((self.prefs.download_folder, _("photos")))
+        if video_dir and not same_file_system:
+            dirs.append((self.prefs.video_download_folder, _("videos")))
+        
+        if len(dirs) > 1:
+            msg = ' ' + _('Free space:') + ' '
+            
+        for i in range(len(dirs)):
+            dir_info = dirs[i]
+            folder = gio.File(dir_info[0])
+            file_info = folder.query_filesystem_info(gio.FILE_ATTRIBUTE_FILESYSTEM_FREE)
+            size = file_info.get_attribute_uint64(gio.FILE_ATTRIBUTE_FILESYSTEM_FREE)
+            free = format_size_for_user(bytes=size)
+            if len(dirs) > 1:
+                #(videos) or (photos) will be appended to the free space message displayed to the 
+                #user in the status bar.
+                #you should only translate this if your language does not use parantheses 
+                file_type = _("(%(file_type)s)") % {'file_type': dir_info[1]}
+
+                #Freespace available on the filesystem for downloading to
+                #Displayed in status bar message on main window                
+                msg += _("%(free)s %(file_type)s") % {'free': free, 'file_type': file_type}
+                if i == 0:
+                    #Inserted in the middle of the statusbar message concerning the amount of freespace
+                    #Used to differentiate between two different file systems
+                    #e.g. Free space: 21.3GB (photos); 14.7GB (videos).
+                    msg += _("; ")
+                else:
+                    #Inserted at the end of the statusbar message concerning the amount of freespace
+                    #Used to differentiate between two different file systems
+                    #e.g. Free space: 21.3GB (photos); 14.7GB (videos).                    
+                    msg += _(".")
+                
             else:
-                self.download_button.set_label(_("_Download All"))
-                self.download_selected_button.show_all()
-                                                
-        else:
-            # button should indicate paused state
-            self.download_button.set_image(gtk.image_new_from_stock(
-                                                gtk.STOCK_MEDIA_PAUSE,
-                                                gtk.ICON_SIZE_BUTTON))
-            # This text will be displayed to the user on the Download / Pause button.
-            self.download_button.set_label(_("_Pause"))
-            self.download_selected_button.set_sensitive(False)
-            self.download_selected_button.hide()
-            
-    def on_menu_download_pause_activate(self, widget):
-        self.on_download_button_clicked(widget)
+                #Freespace available on the filesystem for downloading to
+                #Displayed in status bar message on main window
+                #e.g. 14.7GB available
+                msg = " " + _("%(free)s free") % {'free': free}
         
-    def startScan(self):
-        if workers.noReadyToStartWorkers() > 0:
-            workers.startWorkers()
-
-    def postStartDownloadTasks(self):
-        if workers.noDownloadingWorkers() > 1:
-            self.displayDownloadSummaryNotification = True
             
-        # set button to display Pause
-        self.download_button_is_download = False
-        self._set_download_button()
-        
-    def startDownload(self, threads):
-        self.startOrResumeWorkers(threads)
-        self.postStartDownloadTasks()
-        
-    def pauseDownload(self):
-        for w in workers.getDownloadingWorkers():
-            w.startStop()
-        # set button to display Download
-        if not self.download_button_is_download:
-            self.download_button_is_download = True
-            self._set_download_button()
-        
-    def on_download_button_clicked(self, widget):
-        """
-        Handle download button click.
-        
-        Button is in one of three states: download all, resume, or pause.
-        
-        If download, a click indicates to start or resume a download run.
-        If pause, a click indicates to pause all running downloads.
-        """
-        if self.download_button_is_download:
-            if need_job_code_for_renaming and self.selection_vbox.selection_treeview.job_code_missing(False) and not self.prompting_for_job_code:
-                self.getJobCode(autoStart=False, downloadSelected=False)
+        if self.prefs.backup_images and False: #FIXME: skip this for now!
+            if not self.prefs.backup_device_autodetection:
+                # user manually specified backup location
+                msg2 = _('Backing up to %(path)s') % {'path':self.prefs.backup_location}
             else:
-                threads = self.selection_vbox.selection_treeview.set_status_to_download_pending(selected_only = False)
-                self.startDownload(threads)
-            self._set_download_button()
-        else:
-            self.pauseDownload()
-
-    def on_download_selected_button_clicked(self, widget):
-        # set the status of the selected workers to be downloading pending
-        if need_job_code_for_renaming and self.selection_vbox.selection_treeview.job_code_missing(True) and not self.prompting_for_job_code:
-            self.getJobCode(autoStart=False, downloadSelected=True)
-        else:
-            threads = self.selection_vbox.selection_treeview.set_status_to_download_pending(selected_only = True)
-            self.startDownload(threads)
+                msg2 = self.displayBackupVolumes()
                 
-
+            if msg:
+                msg = _("%(freespace)s. %(backuppaths)s.") % {'freespace': msg, 'backuppaths': msg2}
+            else:
+                msg = msg2
         
-    def on_help_button_clicked(self, widget):
-        webbrowser.open("http://www.damonlynch.net/rapid/help.html")
+        msg = msg.rstrip()
             
-    def on_preference_changed(self, key, value):
+        self.statusbar_message(msg)
+    
+    # # #
+    # Utility functions
+    # # #
+
+    def files_of_type_present(self, files, file_type):
         """
-        Called when user changes the program's preferences
+        Returns true if there is at least one instance of the file_type
+        in the list of files to be copied
         """
+        for rpd_file in files:
+            if rpd_file.file_type == file_type:
+                return True
+        return False
         
-        if key == 'display_selection':
-            self.set_display_selection(value)
-        elif key == 'display_preview_folders':
-            self.set_display_preview_folders(value)
-        elif key == 'show_log_dialog':
-            self.menu_log_window.set_active(value)
-        elif key in ['device_autodetection', 'device_autodetection_psd', 'device_location']:
-            self.rerunSetupAvailableImageAndVideoMedia = True
-            if not self.preferencesDialogDisplayed:
-                self.postPreferenceChange()
-                
-        elif key in ['backup_images', 'backup_device_autodetection', 'backup_location', 'backup_identifier', 'video_backup_identifier']:
-            self.rerunSetupAvailableBackupMedia = True
-            if not self.preferencesDialogDisplayed:
-                self.postPreferenceChange()
-
-        elif key in ['subfolder', 'image_rename', 'video_subfolder', 'video_rename']:
-            global need_job_code_for_renaming
-            need_job_code_for_renaming = self.needJobCodeForRenaming()
-            self.selection_vbox.set_job_code_display()
-            self.menu_select_all_without_job_code.set_sensitive(need_job_code_for_renaming)
-            self.menu_select_all_with_job_code.set_sensitive(need_job_code_for_renaming)
-            self.refreshGeneratedSampleSubfolderAndName = True
-                
-            if not self.preferencesDialogDisplayed:
-                self.postPreferenceChange()
-                
-        elif key in ['download_folder', 'video_download_folder']:
-            self.refreshSampleDownloadFolder = True
-            if not self.preferencesDialogDisplayed:
-                self.postPreferenceChange()            
-            
-        elif key == 'job_codes':
-            # update job code list in left pane
-            self.selection_vbox.update_job_code_combo()
-        
-            
-    def postPreferenceChange(self):
+    def size_files_to_be_downloaded(self, files):
+        """
+        Returns the total size of the files to be downloaded in bytes
         """
-        Handle changes in program preferences after the preferences dialog window has been closed
+        size = 0
+        for i in range(len(files)):
+            size += files[i].size
+
+        return size
+                                              
+    def check_download_folder_validity(self, files_by_scan_pid):
+        """
+        Checks validity of download folders based on the file types the user
+        is attempting to download.
         """
-        if self.rerunSetupAvailableImageAndVideoMedia:
-            if self.usingVolumeMonitor():
-                self.startVolumeMonitor()
-            cmd_line("\n" + _("Download device settings preferences were changed."))
+        valid = True
+        # first, check what needs to be downloaded - photos and / or videos
+        need_photo_folder = False
+        need_video_folder = False
+        while not need_photo_folder and not need_video_folder:
+            for scan_pid in files_by_scan_pid:
+                files = files_by_scan_pid[scan_pid]
+                if not need_photo_folder:
+                    if self.files_of_type_present(files, rpdfile.FILE_TYPE_PHOTO):
+                        need_photo_folder = True
+                if not need_video_folder:
+                    if self.files_of_type_present(files, rpdfile.FILE_TYPE_VIDEO):
+                        need_video_folder = True
             
-            self.selection_vbox.selection_treeview.clear_all()
-            self.setupAvailableImageAndBackupMedia(onStartup = False, onPreferenceChange = True, doNotAllowAutoStart = True)
-            if is_beta and verbose and False:
-                workers.printWorkerStatus()
+        # second, check validity
+        if need_photo_folder:
+            if not self.is_valid_download_dir(self.prefs.download_folder):
+                valid = False
                 
-            self.rerunSetupAvailableImageAndVideoMedia = False
-            
-        if self.rerunSetupAvailableBackupMedia:
-            if self.usingVolumeMonitor():
-                self.startVolumeMonitor()            
-            cmd_line("\n" + _("Backup preferences were changed."))
-            
-            self.refreshBackupMedia()
-            self.rerunSetupAvailableBackupMedia = False
-            
-        if self.refreshGeneratedSampleSubfolderAndName:
-            cmd_line("\n" + _("Subfolder and filename preferences were changed."))
-            for w in workers.getScanningWorkers():
-                if not w.scanResultsStale:
-                    w.scanResultsStale = True
-                    self.noAfterScanRefreshGeneratedSampleSubfolderAndName += 1
+        if need_video_folder:
+            if not self.is_valid_download_dir(self.prefs.video_download_folder):
+                valid = False
                 
-            self.selection_vbox.selection_treeview.refreshGeneratedSampleSubfolderAndName()
-            self.refreshGeneratedSampleSubfolderAndName = False
-            self.setDownloadButtonSensitivity()
-            
-        if self.refreshSampleDownloadFolder:
-            cmd_line("\n" + _("Download folder preferences were changed."))
-            for w in workers.getScanningWorkers():
-                if not w.scanResultsStaleDownloadFolder:
-                    w.scanResultsStaleDownloadFolder = True
-                    self.noAfterScanRefreshSampleDownloadFolders += 1
-            
-            self.selection_vbox.selection_treeview.refreshSampleDownloadFolders()
-            self.refreshSampleDownloadFolder = False
+        return valid
 
-    def regenerateScannedDevices(self, thread_id):
+    def same_file_system(self, file1, file2):
+        """Returns True if the files / diretories are on the same file system
         """
-        Regenerate the filenames / subfolders / download folders for this thread
+        f1 = gio.File(file1)
+        f2 = gio.File(file2)
+        f1_info = f1.query_info(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
+        f1_id = f1_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
+        f2_info = f2.query_info(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
+        f2_id = f2_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
+        return f1_id == f2_id
         
-        The user must have adjusted their preferences as the device was being scanned
+    
+    def same_file(self, file1, file2):
+        """Returns True if the files / directories are the same
         """
+        f1 = gio.File(file1)
+        f2 = gio.File(file2)
         
-        if self.noAfterScanRefreshSampleDownloadFolders:
-            # no point updating it if we're going to update it in the
-            # refresh of sample names and subfolders anway!
-            if not self.noAfterScanRefreshGeneratedSampleSubfolderAndName:
-                self.selection_vbox.selection_treeview.refreshSampleDownloadFolders(thread_id)
-            self.noAfterScanRefreshSampleDownloadFolders -= 1
-                
-        if self.noAfterScanRefreshGeneratedSampleSubfolderAndName:
-            self.selection_vbox.selection_treeview.refreshGeneratedSampleSubfolderAndName(thread_id)
-            self.noAfterScanRefreshGeneratedSampleSubfolderAndName -= 1
-            
-
+        file_attributes = "id::file"
+        f1_info = f1.query_filesystem_info(file_attributes)
+        f1_id = f1_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILE)
+        f2_info = f2.query_filesystem_info(file_attributes)
+        f2_id = f2_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILE)
+        return f1_id == f2_id
         
- 
-    def on_error_eventbox_button_press_event(self,  widget,  event):
-        self.prefs.show_log_dialog = True
-        log_dialog.widget.show()
-
-class VMonitor:
-    """ Transistion to gvfs from gnomevfs"""
-    def __init__(self,  app):
-        self.app = app
-        if using_gio:
-            self.vmonitor = gio.volume_monitor_get()
-            self.vmonitor.connect("mount-added", self.app.on_volume_mounted)
-            self.vmonitor.connect("mount-removed", self.app.on_volume_unmounted)
-        else:
-            self.vmonitor = gnomevfs.VolumeMonitor()
-            self.vmonitor.connect("volume-mounted", self.app.on_volume_mounted)
-            self.vmonitor.connect("volume-unmounted", self.app.on_volume_unmounted)
-            
+    def is_valid_download_dir(self, path):
+        """
+        Checks the following conditions:
+        Does the directory exist?
+        Is it writable?
+        """
+        valid = False
+        try:
+            d = gio.File(path)
+            if not d.query_exists(cancellable=None):
+                logger.error("Download directory does not exist: %s", path)
+            else:
+                file_attributes = "standard::type,access::can-read,access::can-write"
+                file_info = d.query_filesystem_info(file_attributes)
+                file_type = file_info.get_file_type()
+                
+                if file_type != gio.FILE_TYPE_DIRECTORY and file_type != gio.FILE_TYPE_UNKNOWN:
+                    logger.error("%s is an invalid directory", path)
+                else:
+                    # is the directory writable?
+                    try:
+                        temp_dir = tempfile.mkdtemp(prefix="rpd-tmp", dir=path)
+                        valid = True
+                    except:
+                        logger.error("%s is not writable", path)
+                    else:
+                        f = gio.File(temp_dir)
+                        f.delete(cancellable=None)
 
-    def get_mounts(self):        
-        if using_gio:
-            return self.vmonitor.get_mounts()
-        else:
-            return self.vmonitor.get_mounted_volumes()
+        except gio.Error, inst:
+            logger.error("Error checking download directory %s", path)
+            logger.error(inst)
             
-class Volume:
-    """ Transistion to gvfs from gnomevfs"""
-    def __init__(self,  volume):
-        self.volume = volume
-        
-    def get_name(self, limit=config.MAX_LENGTH_DEVICE_NAME):
-        if using_gio:
-            v = self.volume.get_name()
-        else:
-            v = self.volume.get_display_name()
-
-        if limit:
-            if len(v) > limit:
-                v = v[:limit] + '...'
-        return v
+        return valid
+                
+    
+    
+    # # #
+    #  Process results and management
+    # # #
         
-    def get_path(self,  avoid_gnomeVFS_bug = False):
-        if using_gio:
-            path = self.volume.get_root().get_path()
-        else:
-            uri = self.volume.get_activation_uri()
-            path = None
-            if avoid_gnomeVFS_bug:
-                # ugly hack to work around bug where gnomevfs.get_local_path_from_uri(uri) causes a crash
-                mediaLocation = "file://" + config.MEDIA_LOCATION
-                if uri.find(mediaLocation) == 0:
-                    path = gnomevfs.get_local_path_from_uri(uri)
-            else:
-                path = gnomevfs.get_local_path_from_uri(uri)
-        return path
         
+    def _start_process_managers(self):
+        """
+        Set up process managers.
+        
+        A task such as scanning a device or copying files is handled in its
+        own process.        
+        """
         
-    def get_icon_pixbuf(self, size):
-        """ returns icon for the volume, or None if not available"""
+        self.batch_size = 10
+        self.batch_size_MB = 2
         
-        return common.get_icon_pixbuf(using_gio, self.volume.get_icon(), size)
+        sequence_values = (self.downloads_today_value,
+                           self.downloads_today_date_value,
+                           self.day_start_value,
+                           self.refresh_downloads_today_value,
+                           self.stored_sequence_value, 
+                           self.uses_stored_sequence_no_value,
+                           self.uses_session_sequece_no_value,
+                           self.uses_sequence_letter_value)
+                           
+        self.subfolder_file_manager = SubfolderFileManager(
+                                        self.subfolder_file_results,
+                                        sequence_values)
             
-    def unmount(self,  callback):
-        self.volume.unmount(callback)
-
-class DownloadStats:
-    def __init__(self):
-        self.clear()
         
-    def adjust(self, size, noImagesDownloaded, noVideosDownloaded, noImagesSkipped, noVideosSkipped, noWarnings,  noErrors):
-        self.downloadSize += size
-        self.noImagesDownloaded += noImagesDownloaded
-        self.noVideosDownloaded += noVideosDownloaded
-        self.noImagesSkipped += noImagesSkipped
-        self.noVideosSkipped += noVideosSkipped
-        self.noWarnings += noWarnings
-        self.noErrors += noErrors
-        
-    def clear(self):
-        self.noImagesDownloaded = self.noVideosDownloaded = self.noImagesSkipped = self.noVideosSkipped = 0
-        self.downloadSize = 0
-        self.noWarnings = self.noErrors = 0
-        
-class DownloadedFiles:
-    def __init__(self):
-        self.images = {}
-        
-    def add_download(self, name, extension, date_time, sub_seconds, sequence_number_used):
-        if name not in self.images:
-            self.images[name] = ([extension], date_time, sub_seconds, sequence_number_used)
-        else:
-            if extension not in self.images[name][0]:
-                self.images[name][0].append(extension)
-
+        self.generate_folder = False
+        self.scan_manager = ScanManager(self.scan_results, self.batch_size, 
+                    self.generate_folder, self.device_collection.add_device)
+        self.copy_files_manager = CopyFilesManager(self.copy_files_results, 
+                                                   self.batch_size_MB)        
         
-    def matching_pair(self, name, extension, date_time, sub_seconds):
-        """Checks to see if the image matches an image that has already been downloaded.
-        Image name (minus extension), exif date time, and exif subseconds are checked.
+    def scan_results(self, source, condition):
+        """
+        Receive results from scan processes
+        """
+        connection = self.scan_manager.get_pipe(source)
         
-        Returns -1 and a sequence number if the name, extension, and exif values match (i.e. it has already been downloaded)
-        Returns 0 and a sequence number if name and exif values match, but the extension is different (i.e. a matching RAW + JPG image)
-        Returns -99 and a sequence number of None if images detected with the same filenames, but taken at different times
-        Returns 1 and a sequence number of None if no match"""
+        conn_type, data = connection.recv()
         
-        if name in self.images:
-            if self.images[name][1] == date_time and self.images[name][2] == sub_seconds:
-                if extension in self.images[name][0]:
-                    return (-1, self.images[name][3])
-                else:
-                    return (0, self.images[name][3])
+        if conn_type == rpdmp.CONN_COMPLETE:
+            connection.close()
+            size, file_type_counter, scan_pid = data
+            size = format_size_for_user(bytes=size)
+            results_summary, file_types_present = file_type_counter.summarize_file_count()
+            self.file_types_present_by_scan_pid[scan_pid] = file_types_present
+            logger.info('Found %s' % results_summary)
+            logger.info('Files total %s' % size)
+            self.device_collection.update_device(scan_pid, size)
+            self.device_collection.update_progress(scan_pid, 0.0, results_summary, 0)
+            self.testing_auto_exit_trip_counter += 1
+            if self.testing_auto_exit_trip_counter == self.testing_auto_exit_trip and self.testing_auto_exit:
+                self.on_rapidapp_destroy(self.rapidapp)
             else:
-                return (-99, None)
-        return (1, None)
-        
-    def extExifDateTime(self, name):
-        """Returns first extension, exif date time and subseconds data for the already downloaded  image"""
-        return (self.images[name][0][0], self.images[name][1], self.images[name][2])
-        
-class TimeForDownload:
-    # used to store variables, see below
-    pass
-
-class TimeRemaining:
-    gap = 2
-    def __init__(self):
-        self.clear()
-        
-    def set(self,  w,  size):
-        t = TimeForDownload()
-        t.timeRemaining = None
-        t.size = size
-        t.downloaded = 0
-        t.sizeMark = 0
-        t.timeMark = time.time()
-        self.times[w] = t
-        
-    def update(self,  w,  size):
-        if w in self.times:
-            self.times[w].downloaded += size
-            now = time.time()
-            tm = self.times[w].timeMark
-            amtTime = now - tm
-            if amtTime > self.gap:
-                self.times[w].timeMark = now
-                amtDownloaded = self.times[w].downloaded - self.times[w].sizeMark
-                self.times[w].sizeMark = self.times[w].downloaded
-                timefraction = amtDownloaded / float(amtTime)
-                amtToDownload = float(self.times[w].size) - self.times[w].downloaded
-                if timefraction:
-                    self.times[w].timeRemaining = amtToDownload / timefraction
-        
-    def _timeEstimates(self):
-        for t in self.times:
-            yield self.times[t].timeRemaining
+                if not self.testing_auto_exit:
+                    self.download_progressbar.set_text(_("Thumbnails"))
+                    self.thumbnails.generate_thumbnails(scan_pid)
+            self.set_download_action_sensitivity()
+            self.set_thumbnail_sort()
             
-    def timeRemaining(self):
-        return max(self._timeEstimates())
-
-    def setTimeMark(self,  w):
-        if w in self.times:
-            self.times[w].timeMark = time.time()
+            # signal that no more data is coming, finishing io watch for this pipe
+            return False
+        else:
+            if len(data) > self.batch_size:
+                logger.error("incoming pipe length is %s" % len(data))
+            else:
+                for rpd_file in data:
+                    self.thumbnails.add_file(rpd_file)
         
-    def clear(self):
-        self.times = {}         
+        # must return True for this method to be called again
+        return True
         
-    def remove(self,  w):
-        if w in self.times:
-            del self.times[w]
         
-def programStatus():
-    print _("Goodbye")
 
+    @dbus.service.method (config.DBUS_NAME,
+                           in_signature='', out_signature='b')
+    def is_running (self):
+        return self.running
+    
+    @dbus.service.method (config.DBUS_NAME,
+                            in_signature='', out_signature='')
+    def start (self):
+        if self.is_running():
+            self.rapidapp.present()
+        else:
+            self.running = True
+            gtk.main()
         
-def start ():
-    global is_beta
-    is_beta = config.version.find('~b') > 0
+def start():
+
+    is_beta = config.version.find('~') > 0
     
-    parser = OptionParser(version= "%%prog %s" % config.version)
+    parser = OptionParser(version= "%%prog %s" % utilities.human_readable_version(config.version))
     parser.set_defaults(verbose=is_beta,  extensions=False)
     # Translators: this text is displayed to the user when they request information on the command line options. 
     # The text %default should not be modified or left out.
@@ -6468,19 +2547,18 @@ def start ():
     parser.add_option("-e",  "--extensions", action="store_true", dest="extensions", help=_("list photo and video file extensions the program recognizes and exit"))
     parser.add_option("--reset-settings", action="store_true", dest="reset", help=_("reset all program settings and preferences and exit"))
     (options, args) = parser.parse_args()
-    global verbose
-    verbose = options.verbose
     
-    global debug_info
-    debug_info = options.debug
-    if debug_info:
-        verbose = True
+    if options.debug:
+        logging_level = logging.DEBUG
+    elif options.verbose:
+        logging_level = logging.INFO
+    else:
+        logging_level = logging.ERROR
     
-    if verbose:
-        atexit.register(programStatus)
-        
+    logger.setLevel(logging_level)
+
     if options.extensions:
-        extensions = ((metadata.RAW_FILE_EXTENSIONS + metadata.NON_RAW_IMAGE_FILE_EXTENSIONS, _("Photos:")), (videometadata.VIDEO_FILE_EXTENSIONS, _("Videos:")))
+        extensions = ((rpdfile.RAW_FILE_EXTENSIONS + rpdfile.NON_RAW_IMAGE_FILE_EXTENSIONS, _("Photos:")), (rpdfile.VIDEO_FILE_EXTENSIONS, _("Videos:")))
         for exts, file_type in extensions:
             v = ''
             for e in exts[:-1]:
@@ -6496,43 +2574,25 @@ def start ():
         print _("All settings and preferences have been reset")
         sys.exit(0)
 
-    cmd_line(_("Rapid Photo Downloader") + " %s" % config.version)
-    cmd_line(_("Using") + " pyexiv2 " + metadata.version_info())
-    cmd_line(_("Using") + " exiv2 " + metadata.exiv2_version_info())
+    logger.info("Rapid Photo Downloader %s", utilities.human_readable_version(config.version))
+    logger.info("Using pyexiv2 %s", metadataphoto.pyexiv2_version_info())
+    logger.info("Using exiv2 %s", metadataphoto.exiv2_version_info())
     if DOWNLOAD_VIDEO:
-        cmd_line(_("Using") + " hachoir " + videometadata.version_info())
-    else:
-        cmd_line(_("\n" + "Video downloading functionality disabled.\nTo download videos, please install the hachoir metadata and kaa metadata packages for python.") + "\n")
-        
-    if using_gio:
-        cmd_line(_("Using") + " GIO")
-        gobject.threads_init()
+        logger.info("Using hachoir %s", metadatavideo.version_info())
     else:
-        # Which volume management code is being used (GIO or GnomeVFS)
-        cmd_line(_("Using") + " GnomeVFS")
-        gdk.threads_init()
-        
-    
-
-    display_queue.open("rw")
-    tube.tube_add_watch(display_queue, updateDisplay)
+        logger.info(_("Video downloading functionality disabled.\nTo download videos, please install the hachoir metadata and kaa metadata packages for python."))
 
-    gdk.threads_enter()
-
-    # run only a single instance of the application 
     bus = dbus.SessionBus ()
     request = bus.request_name (config.DBUS_NAME, dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
-    if request != dbus.bus.REQUEST_NAME_REPLY_EXISTS:
-        app = RapidApp (bus, '/', config.DBUS_NAME)
+    if request != dbus.bus.REQUEST_NAME_REPLY_EXISTS: 
+        app = RapidApp(bus, '/', config.DBUS_NAME)
     else:
         # this application is already running
-        print _("%s is already running") % PROGRAM_NAME
+        print "Rapid Photo Downloader is already running"
         object = bus.get_object (config.DBUS_NAME, "/")
         app = dbus.Interface (object, config.DBUS_NAME)
     
-    app.start()
-
-    gdk.threads_leave()    
+    app.start()            
 
 if __name__ == "__main__":
     start()