Imported Upstream version 0.3.6upstream/0.3.6

1 files changed, 5976 insertions, 2126 deletions

diff --git a/rapid/rapid.py b/rapid/rapid.py
index 3603025..f41c79f 100755
--- a/rapid/rapid.py
+++ b/rapid/rapid.py
@@ -1,7 +1,7 @@
 #!/usr/bin/python
 # -*- coding: latin1 -*-
 
-### Copyright (C) 2011 Damon Lynch <damonlynch@gmail.com>
+### Copyright (C) 2007, 2008, 2009, 2010 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,8 +17,19 @@
 ### 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
@@ -26,89 +37,1549 @@ import dbus.service
 from dbus.mainloop.glib import DBusGMainLoop
 DBusGMainLoop(set_as_default=True)
 
-from optparse import OptionParser
+from threading import Thread, Lock
+from thread import error as thread_error
+from thread import get_ident
 
-import gtk
 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
 
-import webbrowser
-
-import sys, time, types, os, datetime
+from optparse import OptionParser
 
-import gobject, pango, cairo, array, pangocairo, gio
+import pynotify
 
-from multiprocessing import Process, Pipe, Queue, Event, Value, Array, current_process, log_to_stderr
-from ctypes import c_int, c_bool, c_char
+import idletube as tube
 
-import logging
-logger = log_to_stderr()
+import config
 
-# Rapid Photo Downloader modules
+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 rpdfile
+from media import getDefaultPhotoLocation, getDefaultVideoLocation, \
+                  getDefaultBackupPhotoIdentifier, \
+                  getDefaultBackupVideoIdentifier
                   
-import problemnotification as pn
-import thumbnail as tn
-import rpdmultiprocessing as rpdmp
+import ValidatedEntry
+                  
+from media import CardMedia
 
-import preferencesdialog
-import prefsrapid
+import media
+
+import metadata
+import videometadata
+from videometadata import DOWNLOAD_VIDEO
+
+import renamesubfolderprefs as rn
+import problemnotification as pn
 
 import tableplusminus as tpm
-import generatename as gn
 
-import downloadtracker
+__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')
 
-from metadatavideo import DOWNLOAD_VIDEO
-import metadataphoto
-import metadatavideo
+TINY_SCREEN = gtk.gdk.screen_height() <= config.TINY_SCREEN_HEIGHT
+#~ TINY_SCREEN = True
 
-import scan as scan_process
-import copyfiles
-import subfolderfile
+def today():
+    return datetime.date.today().strftime('%Y-%m-%d')
 
-import errorlog
 
-import device as dv
-import utilities
 
-import config
-__version__ = config.version
+def cmd_line(msg):    
+    if verbose:
+        print msg
 
-import paths
+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
 
-import gettext
-gettext.bindtextdomain(config.APP_NAME)
-gettext.textdomain(config.APP_NAME)
 
-from gettext import gettext as _
+class Queue(tube.Tube):
+    def __init__(self, maxSize = config.MAX_NO_READERS):
+        tube.Tube.__init__(self, maxSize)
 
+    def setMaxSize(self, maxSize):
+        self.maxsize = maxSize
 
-from utilities import format_size_for_user
-from utilities import register_iconsets
 
+# 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 :(
 
-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
+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")
                     
-DOWNLOADED = [STATUS_DOWNLOADED, STATUS_DOWNLOADED_WITH_WARNING, STATUS_BACKUP_PROBLEM]
+        self.table_type = self.errorTitle[len("Error in "):]
+        self.i = 0
 
-#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
+        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)
+
+            
+    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()
+
+class SubfolderTable(ImageRenameTable):
+    def __init__(self, parentApp, adjustScollWindow):    
+        self.errorTitle = _("Error in Photo Download Subfolders preferences")
+        ImageRenameTable.__init__(self, parentApp, adjustScollWindow)
+
+    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
+
+    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)
+
+    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
+
+        self._setupTabSelector()
+        
+        self._setupControlSpacing()
+        
+        if DOWNLOAD_VIDEO:
+            self.file_types = _("photos and videos")
+        else:
+            self.file_types = _("photos")
+
+        # 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):
+
+        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):
+
+        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>")
+
+        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")
+                    
+            self.widget.destroy()
+            self.parentApp.preferencesDialogDisplayed = False
+            self.parentApp.postPreferenceChange()
+            
+
+
+
+    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)
+
+        
+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")}
     else:
         return _("%(date)s %(time)s") % {'date':date.strftime("%x"), 'time':date.strftime("%X")}
         
+def time_subseconds_human_readable(date, subseconds):
+    return _("%(hour)s:%(minute)s:%(second)s:%(subsecond)s") % \
+            {'hour':date.strftime("%H"),
+             'minute':date.strftime("%M"), 
+             'second':date.strftime("%S"),
+             'subsecond': subseconds}
+
 def date_time_subseconds_human_readable(date, subseconds):
     return _("%(date)s %(hour)s:%(minute)s:%(second)s:%(subsecond)s") % \
             {'date':date.strftime("%x"), 
@@ -117,19 +1588,1498 @@ 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 DeviceCollection(gtk.TreeView):
+class NeedAJobCode():
     """
-    TreeView display of devices and how many files have been copied, shown
-    immediately under the menu in the main application window.
+    Convenience class to check whether a job code is missing for a given
+    file type (photo or video)
     """
-    def __init__(self, parent_app):
+    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)
+        
 
-        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 = {}
+    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):
+    """
+    TreeView display of devices and associated copying progress.
+    
+    Assumes a threaded environment.
+    """
+    def __init__(self, parentApp):
+
+        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 = {}
 
         gtk.TreeView.__init__(self, self.liststore)
         
@@ -138,357 +3088,587 @@ class DeviceCollection(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"))
-        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)
+        # 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)
         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=2)
+        # Size refers to the total size of images on the device, typically in MB or GB
+        column1 = gtk.TreeViewColumn(_("Size"), gtk.CellRendererText(), text=1)
         self.append_column(column1)
         
         column2 = gtk.TreeViewColumn(_("Download Progress"), 
-                                    gtk.CellRendererProgress(),
-                                    value=3,
-                                    text=4)
+                                    gtk.CellRendererProgress(), value=2, text=3)
         self.append_column(column2)
         self.show_all()
         
-    def add_device(self, process_id, device, progress_bar_text = ''):
+    def addCard(self, thread_id, cardName, sizeFiles, progress = 0.0, progressBarText = ''):
         
         # add the row, and get a temporary pointer to the row
-        size_files = ''
-        progress = 0.0
-        iter = self.liststore.append((device.get_icon(),
-                                      device.get_name(),
-                                      size_files,
-                                      progress,
-                                      progress_bar_text))
+        iter = self.liststore.append((cardName, sizeFiles, progress, progressBarText))
+        
+        self._setThreadMap(thread_id, iter)
         
-        self._set_process_map(process_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)
 
         
-    def update_device(self, process_id, total_size_files):
+    def updateCard(self, thread_id, totalSizeFiles):
         """
         Updates the size of the photos and videos on the device, displayed to the user
         """
-        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)
+        if thread_id in self.mapThreadToRow:
+            iter = self._getThreadMap(thread_id)
+            self.liststore.set_value(iter, 1, totalSizeFiles)
         else:
-            logger.error("This device is unknown")
+            sys.stderr.write("FIXME: this card is unknown")
     
-    def remove_device(self, process_id):
-        if process_id in self.map_process_to_row:
-            iter = self._get_process_map(process_id)
+    def removeCard(self, thread_id):
+        if thread_id in self.mapThreadToRow:
+            iter = self._getThreadMap(thread_id)
             self.liststore.remove(iter)
-            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()
+            del self.mapThreadToRow[thread_id]
 
 
-    def _set_process_map(self, process_id, iter):
+    def _setThreadMap(self, thread_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.map_process_to_row[process_id] = treerowref
+        treerowRef = gtk.TreeRowReference(self.liststore, path)
+        self.mapThreadToRow[thread_id] = treerowRef
     
-    def _get_process_map(self, process_id):
+    def _getThreadMap(self, thread_id):
         """
-        return the tree iter for this process
+        return the tree iter for this thread
         """
         
-        if process_id in self.map_process_to_row:
-            treerowref = self.map_process_to_row[process_id]
-            path = treerowref.get_path()
+        if thread_id in self.mapThreadToRow:
+            treerowRef = self.mapThreadToRow[thread_id]
+            path = treerowRef.get_path()
             iter = self.liststore.get_iter(path)
             return iter
         else:
             return None
     
-    def update_progress(self, scan_pid, percent_complete, progress_bar_text, bytes_downloaded):
+    def updateProgress(self, thread_id, percentComplete, progressBarText, bytesDownloaded):
         
-        iter = self._get_process_map(scan_pid)
+        iter = self._getThreadMap(thread_id)
         if iter:
-            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")
+            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)
+        
 
+    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 ThumbnailCellRenderer(gtk.CellRenderer):
-    __gproperties__ = {
-        "image": (gobject.TYPE_PYOBJECT, "Image",
-        "Image", gobject.PARAM_READWRITE),
-        
-        "filename": (gobject.TYPE_STRING, "Filename", 
-        "Filename", '', gobject.PARAM_READWRITE),
-        
-        "status": (gtk.gdk.Pixbuf, "Status",
-        "Status", gobject.PARAM_READWRITE),
-    }
-    
-    def __init__(self, checkbutton_height):
-        gtk.CellRenderer.__init__(self)
-        self.image = None
+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
         
-        self.image_area_size = 100
-        self.text_area_size = 30
-        self.padding = 6
-        self.checkbutton_height = checkbutton_height
-        self.icon_width = 20
+        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.")
         
-    def do_set_property(self, pspec, value):
-        setattr(self, pspec.name, value)
+        self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg'))
 
-    def do_get_property(self, pspec):
-        return getattr(self, pspec.name)
-        
-    def do_render(self, window, widget, background_area, cell_area, expose_area, flags):
-        
-        cairo_context = window.cairo_create()
-        
-        x = cell_area.x
-        y = cell_area.y + self.checkbutton_height - 8
-        w = cell_area.width
-        h = cell_area.height
-        
-        
-        #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()
-        
-        #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()
-        
-        #image width and height
-        image_w = self.image.size[0]
-        image_h = self.image.size[1]
-        
-        #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
+        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)
 
-        #convert PIL image to format suitable for cairo
-        image = create_cairo_image_surface(self.image, image_w, image_h)
+        secondary_label = gtk.Label()
+        secondary_label.set_text(secondary_msg)
+        secondary_label.set_line_wrap(True)
+        secondary_label.set_alignment(0, 0.5)
 
-        # 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()
+        self.show_again_checkbutton = gtk.CheckButton(_('_Show this message again'), True)
+        self.show_again_checkbutton.set_active(True)
         
-        #place the image
-        cairo_context.set_source_surface(image, image_x, image_y)
-        cairo_context.paint()
-        
-        #text
-        context = pangocairo.CairoContext(cairo_context)
+        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)
+
+        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)   
         
-        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()        
+        self.set_default_response(gtk.RESPONSE_OK)
+      
+        self.set_transient_for(parent_window)
+        self.show_all()
         
-        layout = context.create_layout()
-
-        width = text_w * pango.SCALE
-        layout.set_width(width)
-        
-        layout.set_alignment(pango.ALIGN_CENTER)
-        layout.set_ellipsize(pango.ELLIPSIZE_END)
+        self.connect('response', self.on_response)
         
-        #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)
-
-        layout.set_text(self.filename)        
+    def on_response(self,  device_dialog, response):
+        show_again = self.show_again_checkbutton.get_active()
+        self.postChoiceCB(self,  show_again)
 
-        context.move_to(text_x, text_y)
-        context.show_layout(layout)
+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)
 
-        #status
-        cairo_context.set_source_pixbuf(self.status, x, y + self.image_area_size + 10)
-        cairo_context.paint()
+        self.set_border_width(6)
+        self.set_has_separator(False)   
         
-    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)
+        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'))
         
-
-gobject.type_register(ThumbnailCellRenderer)
- 
-
-class ThumbnailDisplay(gtk.IconView):
-    def __init__(self, parent_app):
-        gtk.IconView.__init__(self)
-        self.rapid_app = parent_app
+        prompt_hbox = gtk.HBox()
         
-        self.batch_size = 10
+        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.thumbnail_manager = ThumbnailManager(self.thumbnail_results, self.batch_size)
-        self.preview_manager = PreviewManager(self.preview_results)
+        self.set_default_response(gtk.RESPONSE_OK)
+      
+       
+        self.set_transient_for(parent_window)
+        self.show_all()
+
         
-        self.treerow_index = {} 
-        self.process_index = {} 
+        self.connect('response', self.on_response)
         
-        self.rpd_files = {}
+    def on_response(self,  device_dialog, response):
+        userSelected = response == gtk.RESPONSE_OK
+        self.postChoiceCB(self, userSelected)   
         
-        self.total_files = 0
-        self.thumbnails_generated = 0
         
-        self.thumbnails = {}
-        self.previews = {}
-        self.previews_being_fetched = set()
+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))
+                        
         
-        self.stock_photo_thumbnails = tn.PhotoIcons()
-        self.stock_video_thumbnails = tn.VideoIcons()
+        self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg'))
+        self.postJobCodeEntryCB = postJobCodeEntryCB
+        self.autoStart = autoStart
+        self.downloadSelected = downloadSelected
         
-        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.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)
         
-        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
-             )
+        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)
 
+        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)
+        
+        self.set_border_width(6)
+        self.set_has_separator(False)
 
-        self.clear()
-        self.set_model(self.liststore)
+        # make entry box have entry completion
+        self.entry = self.combobox.child
         
-        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)
+        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)
         
-        checkbutton_size = checkbutton.get_size(self, None)
-        checkbutton_height = checkbutton_size[3]
-        checkbutton_width = checkbutton_size[2]
+        # 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)
         
-        #~ status_icon = gtk.CellRendererPixbuf()
-        #~ self.pack_start(status_icon, expand=False)
-        #~ self.add_attribute(status_icon, "pixbuf", self.STATUS_ICON_COL)
+        self.vbox.pack_start(task_hbox, False, False, padding = 6)
+        self.vbox.pack_start(self.job_code_hbox, False, False, padding=12)
         
-        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)
+        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()
         
-        #set the background color to a darkish grey
-        self.modify_base(gtk.STATE_NORMAL, gtk.gdk.Color('#444444'))
-        
-        self.set_spacing(0)
-        #~ self.set_column_spacing(0)
-        self.set_row_spacing(5)
-        #~ self.set_row_spacing(0)
-        self.set_margin(25)
+    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._setup_icons()
+        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)
         
+        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.connect('item-activated', self.on_item_activated)
+        # 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.user_has_clicked_header = False
         
-    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)
+        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)
         
         # 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'))
+        
+        self.previewed_file_treerowref = None
+        self.icontheme = gtk.icon_theme_get_default()
+        
         
-    def get_status_icon(self, status):
+        
+    def get_thread(self, iter):
+        """
+        Returns the thread associated with the liststore's iter
+        """
+        return self.liststore.get_value(iter, 14)
+        
+    def get_status(self, iter):
+        """
+        Returns the status associated with the liststore's iter
+        """
+        return self.liststore.get_value(iter, 11)
+        
+    def get_mediaFile(self, iter):
+        """
+        Returns the mediaFile associated with the liststore's iter
+        """
+        return self.liststore.get_value(iter, 9)
+        
+    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)
+        
+    def get_job_code(self, iter):
+        """
+        Returns the job code associated with the liststore's iter
+        """
+        return self.liststore.get_value(iter, 8)
+        
+    def get_status_icon(self, status, preview=False):
         """
         Returns the correct icon, based on the status
         """
@@ -499,7 +3679,10 @@ class ThumbnailDisplay(gtk.IconView):
         elif status == STATUS_DOWNLOADED:
             status_icon =  self.downloaded_icon
         elif status == STATUS_NOT_DOWNLOADED:
-            status_icon = self.not_downloaded_icon
+            if preview:
+                status_icon = self.not_downloaded_icon_tick
+            else:
+                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]:
@@ -507,1196 +3690,1464 @@ class ThumbnailDisplay(gtk.IconView):
         elif status == STATUS_DOWNLOAD_PENDING:
             status_icon = self.download_pending_icon
         else:
-            logger.critical("FIXME: unknown status: %s", status)
+            sys.stderr.write("FIXME: unknown status: %s\n" % status)
             status_icon = self.not_downloaded_icon
-        return status_icon        
-    
-    def sort_by_timestamp(self):
-        self.liststore.set_sort_column_id(self.TIMESTAMP_COL, gtk.SORT_ASCENDING)
+        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
         
-    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()
+        If selected_only is True, then only those from the selected
+        rows will be returned.
         
-    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)
+        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 add_file(self, rpd_file):
+    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)
 
-        thumbnail_icon = self.get_stock_icon(rpd_file.file_type)
-        unique_id = rpd_file.unique_id
-        scan_pid = rpd_file.scan_pid
+        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)
 
-        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
-                                      ))
-        
-        path = self.liststore.get_path(iter)
-        treerowref = gtk.TreeRowReference(self.liststore, path)
         
-        if scan_pid in self.process_index:
-            self.process_index[scan_pid].append(unique_id)
+        if mediaFile.isImage:
+            type_icon = self.icon_photo
         else:
-            self.process_index[scan_pid] = [unique_id,]
-            
-        self.treerow_index[unique_id] = treerowref
-        self.rpd_files[unique_id] = rpd_file
+            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)
         
-        self.total_files += 1
-
-    def get_sample_file(self, file_type):
-        """Returns an rpd_file for of a given file type, or None if it does 
-        not exist"""
-        for unique_id, rpd_file in self.rpd_files.iteritems():
-            if rpd_file.file_type == file_type:
-                if rpd_file.status <> STATUS_CANNOT_DOWNLOAD:
-                    return rpd_file
-                    
-        return None
-    
-    def get_unique_id_from_iter(self, iter):
-        return self.liststore.get_value(iter, 2)
+        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)
         
-    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 on_item_activated(self, iconview, path):        
+    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
         """
-        iter = self.liststore.get_iter(path)
-        self.show_preview(iter=iter)
-        self.advance_get_preview_image(iter)
-
+        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
     
-    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
+    def update_download_selected_button(self):
+        """
+        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)
-            unique_id = self.get_unique_id_from_iter(iter)
             
+            #update button text
+            no_available_for_download, threads = self.no_selected_rows_available_for_download()
             
-        rpd_file = self.rpd_files[unique_id]    
-        
-        if unique_id in self.previews:
-            preview_image = self.previews[unique_id]
+        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:
-            # 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)
+            #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)
+        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)
             
-    def _get_next_iter(self, iter):
-        iter = self.liststore.iter_next(iter)
-        if iter is None:
+    def clear_all(self, thread_id = None):
+        if thread_id is None:
+            self.liststore.clear()
+            self.show_preview(None)
+        else:
             iter = self.liststore.get_iter_first()
-        return iter
+            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)
         
-    def _get_prev_iter(self, iter):
-        row = self.liststore.get_path(iter)[0]
-        if row == 0:
-            row = len(self.liststore)-1
+        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
         else:
-            row -= 1
-        iter = self.liststore.get_iter(row)
-        return iter        
+            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)        
     
-    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)
+    
+    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):
             
-            # cache next image
-            self.advance_get_preview_image(iter, prev=False, next=True)
+        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
             
-    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)
+        
+        elif not self.suspend_previews:
+            mediaFile = self.get_mediaFile(iter)
             
-            # cache next image
-            self.advance_get_preview_image(iter, prev=True, next=False)
-
+            self.previewed_file_treerowref = mediaFile.treerowref
             
-    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))
+            self.parentApp.set_base_preview_image(mediaFile.thumbnail)
+            thumbnail = self.parentApp.scaledPreviewImage()
+                
+            self.parentApp.preview_image.set_from_pixbuf(thumbnail)
             
-        if prev:
-            prev_iter = self._get_prev_iter(iter)
-            unique_ids.append(self.get_unique_id_from_iter(prev_iter))
+            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)
             
-        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)
+            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)
+
+            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 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
             
-    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
+            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)
                 else:
-                    row[self.SELECTED_COL] = check_all
-        self.rapid_app.set_download_action_sensitivity()
+                    selection.unselect_iter(iter)
+                iter = self.liststore.iter_next(iter)
             
-    def files_are_checked_to_download(self):
+            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):
         """
-        Returns True if there is any file that the user has indicated they
-        intend to download, else returns False.
+        if display is true, the column will be shown
+        otherwise, it will not be shown
         """
-        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
+        self.filename_column.set_visible(display)
         
-    def get_files_checked_for_download(self):
+    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)
+        
+    def apply_job_code(self, job_code, overwrite=True, to_all_rows=False, thread_id=None):
         """
-        Returns a dict of scan ids and associated files the user has indicated
-        they want to download
+        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.
         """
-        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)
+
+        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
                     else:
-                        files[scan_pid] = [rpd_file,]
+                        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
                     
-        return files
-                
-
-    def mark_download_pending(self, files_by_scan_pid):
+        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
+                    
+                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):
         """
-        Sets status to download pending and updates thumbnails display
+        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.
         """
-        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 get_stock_icon(self, file_type):
-        if file_type == rpdfile.FILE_TYPE_PHOTO:
-            return self.stock_photo_thumbnails.stock_thumbnail_image_icon
+        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
         else:
-            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)
+            iter = self.liststore.get_iter_first()
+            while iter:
+                v = _job_code_missing(iter)
+                if v:
+                    break
+                iter = self.liststore.iter_next(iter)
+        return v
+
     
-    def update_thumbnail(self, thumbnail_data):
+    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):
         """
-        Takes the generated thumbnail and updates the display
+        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)
         
-        If the thumbnail_data includes a second image, that is used to
-        update the thumbnail list using the unique_id
+        Returns a list of threads which can be downloaded
         """
-        unique_id = thumbnail_data[0]
-        thumbnail_icon = thumbnail_data[1]
+        threads = []
         
-        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()
+        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:
             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 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()
+            # If this row is currently previewed, then should update the preview
+            if mediaFile.treerowref == self.previewed_file_treerowref:
+                self.show_preview(iter)
 
-            
-    def thumbnail_results(self, source, condition):
-        connection = self.thumbnail_manager.get_pipe(source)
+
+class SelectionVBox(gtk.VBox):
+    """
+    Dialog from which the user can select photos and videos to download
+    """
+
+    
+    def __init__(self, parentApp):
+        """
+        Initialize values for log dialog, but do not display.
+        """
         
-        conn_type, data = connection.recv()
+        gtk.VBox.__init__(self)
+        self.parentApp = parentApp
         
-        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)
-            
+        tiny_screen = TINY_SCREEN
+        if tiny_screen:
+            config.max_thumbnail_size = 160
         
-        return True
+        selection_scrolledwindow = gtk.ScrolledWindow()
+        selection_scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        selection_viewport = gtk.Viewport()
         
-    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.
         
-        If scan_pid is not None, then only files matching that scan_pid will
-        be removed. Otherwise, everything will be removed.
+        self.selection_treeview = SelectionTreeView(self)
         
-        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)
-        logger.debug("TaskManager PID: %s", pid)
-        return pid
+        selection_scrolledwindow.add(self.selection_treeview)
+
 
+        # 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)
         
-        source = task_results_conn.fileno()
-        self._pipes[source] = task_results_conn
-        gobject.io_add_watch(source, gobject.IO_IN, self.results_callback)
+        # Preview pane
         
-        terminate_queue = Queue()
-        run_event = Event()
-        run_event.set()
+        # Zoom in and out slider (make the image bigger / smaller)
         
-        return self._initiate_task(task, task_process_conn, terminate_queue, run_event)
+        # 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)
         
-    def _initiate_task(self, task, task_process_conn, terminate_queue, run_event):
-        logger.error("Implement child class method!")
+        # 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 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. 
+        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)
         
-        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.'
-        """
         
-        for p in self.processes():
-            if p[0].is_alive():
-                p[0].terminate()
+        #Preview image
+        self.base_preview_image = None # large size image used to scale down from
+        self.preview_image = gtk.Image()
 
-            
-    def get_pipe(self, source):
-        return self._pipes[source]
+        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_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
+        image_size, shadow_size, offset = self._imageAndShadowSize()
         
-    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]
+        self.preview_image.set_size_request(image_size, image_size)
         
-        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
+        #labels to display file information
         
-class ThumbnailManager(TaskManager):
+        #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)
         
-    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
         
-        self.task_results_conn, self.task_process_conn = Pipe(duplex=True)
+        #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()
         
-        source = self.task_results_conn.fileno()
-        gobject.io_add_watch(source, gobject.IO_IN, self.task_results)
-
+        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)
         
-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()
+        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)
         
-    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))
+        self.preview_device_expander.set_label_widget(device_hbox)
         
-    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 
+        #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)
         
-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()
-        logger.debug("SubfolderFile PID: %s", self._subfolder_file.pid)
-        
-    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
+        #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()
         
+        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)
 
-
-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)
+        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)
         
-    def set_image(self, image):
-        self.base_image = image
+        self.preview_destination_expander.set_label_widget(destination_hbox)
+
         
-        #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
+        #Status of the file
         
-        self.queue_draw()
+        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)
         
-    def expose(self, widget, event):
+        #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)
 
-        cairo_context = self.window.cairo_create()
+        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
         
-        x = event.area.x 
-        y = event.area.y 
-        w = event.area.width
-        h = event.area.height
+    def zoom_in(self):
+        self.slider_adjustment.set_value(min([config.max_thumbnail_size, int(self.slider_adjustment.get_value()) + config.THUMBNAIL_INCREMENT]))
         
-        #constrain operations to event area 
-        cairo_context.rectangle(x, y, w, h)
-        cairo_context.clip_preserve()
+    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)
         
-        #set background color, if needed
-        if self.bg_color:
-            cairo_context.set_source_rgb(*self.bg_color)
-            cairo_context.fill_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()
 
-        if not self.base_image:
-            return False
-            
-        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:
-            # Frame is taller than image
-            width = w
-            height = int(width / self.base_image_aspect)
+            self.preview_destination_expander.hide()
+            self.preview_device_expander.hide()
             
-        #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))
+    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
         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]
-        
-        #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()        
-
-        return False    
-        
+            pixbuf = common.scale2pixbuf(size, size, self.base_preview_image)
+            
+            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
         
+        If user is not using job codes in their file or subfolder names
+        then do not prompt for it
+        """
 
-class PreviewImage:
+        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 __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
+    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('')
         
-        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)
-        
-        self.unique_id = None
+    
+    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 set_preview_image(self, unique_id, pil_image, include_checkbutton_visible=None, 
-                          checked=None):
+        # 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.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
+        self.job_code_chosen(widget.get_text())
         
-    def update_preview_image(self, unique_id, pil_image):
-        if unique_id == self.unique_id:
-            self.set_preview_image(unique_id, pil_image)
-      
-
+    def job_code_chosen(self, job_code):
+        """
+        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)
+            
         
-class RapidApp(dbus.service.Object):
+class LogDialog(gnomeglade.Component):
     """
-    The main Rapid Photo Downloader application class.
-    
-    Contains functionality for main program window, and directs all other
-    processes.
+    Displays a log of errors, warnings or other information to the user
     """
-     
-    def __init__(self,  bus, path, name, taskserver=None): 
-        
-        dbus.service.Object.__init__ (self, bus, path, name)
-        self.running = False
+    
+    def __init__(self, parentApp):
+        """
+        Initialize values for log dialog, but do not display.
+        """
         
-        self.taskserver = taskserver
+        gnomeglade.Component.__init__(self, 
+                                    paths.share_dir(config.GLADE_FILE), 
+                                    "logdialog")
+                                    
         
-        # Setup program preferences, and set callback for when they change
-        self._init_prefs()
+        self.widget.connect("delete-event", self.hide_window)
         
-        # Initialize widgets in the main window, and variables that point to them
-        self._init_widgets()
+        self.parentApp = parentApp
+        self.log_textview.set_cursor_visible(False)
+        self.textbuffer = self.log_textview.get_buffer()
         
-        # Initialize job code handling
-        self._init_job_code()
+        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)
         
-        # Remember the window size from the last time the program was run, or
-        # set a default size
-        self._set_window_size()
+    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()
         
-        # Setup various widgets
-        self._setup_buttons()
-        self._setup_error_icons()
-        self._setup_icons()
+        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)
             
-        # Show the main window
-        self.rapidapp.show()
-        
-        # 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()
-        
-        # Set up process managers.
-        # A task such as scanning a device or copying files is handled in its
-        # own process.
-        self._start_process_managers()
+        iter = self.textbuffer.get_end_iter()
+        self.textbuffer.insert(iter, "\n")
         
-        # 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)
+        # move viewport to display the latest message
+        adjustment = self.log_scrolledwindow.get_vadjustment()
+        adjustment.set_value(adjustment.upper)
         
-        # 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):
+    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
 
-        self._terminate_processes(terminate_file_copies = True)
+    def hide_window(self,  window, event):
+        window.hide()
+        return True
 
-        # save window and component sizes
-        self.prefs.vpaned_pos = self.main_vpaned.get_position()
 
-        x, y, width, height = self.rapidapp.get_allocation()
-        self.prefs.main_window_size_x = width
-        self.prefs.main_window_size_y = height
-        
-        self.prefs.set_downloads_today_from_tracker(self.downloads_today_tracker)
-        
-        gtk.main_quit()
-        
-    def _terminate_processes(self, terminate_file_copies=False):
-        
-        # FIXME: need more fine grained tuning here - must cancel large file
-        # copies midstream
-        if terminate_file_copies:
-            logger.info("Terminating all processes...")
-
-        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:
-            copy_files_termination_requested = False
-        
-        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()
-        
-        if terminate_file_copies:
-            self._clean_all_temp_dirs()
-        
-    # # #
-    # Events and tasks related to displaying preview images and thumbnails
-    # # #
-
-    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):
-        
-        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()
-        
-    def on_show_image_action_activate(self, action):
-        logger.debug("on_show_image_action_activate")
-        self.thumbnails.show_preview()
-        
-    def on_check_all_action_activate(self, action):
-        self.thumbnails.check_all(check_all=True)
-        
-    def on_uncheck_all_action_activate(self, action):
-        self.thumbnails.check_all(check_all=False)
-
-    def on_check_all_photos_action_activate(self, action):
-        self.thumbnails.check_all(check_all=True, 
-                                  file_type=rpdfile.FILE_TYPE_PHOTO)
-        
-    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)
-        
-    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")
-        
-    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)
-        
-    def update_preview_image(self, unique_id, image):
-        self.preview_image.update_preview_image(unique_id, image)
-        
-    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)
+
+class RapidApp(gnomeglade.GnomeApp,  dbus.service.Object): 
+    def __init__(self,  bus, path, name): 
         
+        dbus.service.Object.__init__ (self, bus, path, name)
+        self.running = False
         
-    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)
+        gladefile = paths.share_dir(config.GLADE_FILE)
+
+        gnomeglade.GnomeApp.__init__(self, "rapid", __version__, gladefile, "rapidapp")
     
-    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)
+        # notifications
+        self.displayDownloadSummaryNotification = False
+        self.initPyNotify()
         
-    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.prefs = RapidPreferences()
+        self.prefs.notify_add(self.on_preference_changed)
+        
+        self.testing = False
+        if self.testing:
+            self.setTestingEnv()
+            
+#        sys.exit(0)
 
-    # # #
-    # 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) 
-    
+        # 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)
+        else:
+            # set a default size
+            self.rapidapp.set_default_size(650, 650)
             
-    def setup_devices(self, on_startup, on_preference_change, do_not_allow_auto_start):
-        """
+        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()
         
-        Setup devices from which to download from and backup to
+        self._setupIcons()
         
-        Sets up volumes for downloading from and backing up to
+        # 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)
         
-        on_startup should be True if the program is still starting, 
-        i.e. this is being called from the program's initialization.
+        self.checkIfFirstTimeProgramEverRun()
+
+        displayPreferences = self.checkForUpgrade(__version__)
+        self.prefs.program_version = __version__
         
-        on_preference_change should be True if this is being called as the
-        result of a preference being changed
+        self.timeRemaining = TimeRemaining()
+        self._resetDownloadInfo()
+        self.statusbar_context_id = self.rapid_statusbar.get_context_id("progress")
         
-        Removes any image media that are currently not downloaded, 
-        or finished downloading        
-        """
+        # 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()
         
-        if self.using_volume_monitor():
-            self.start_volume_monitor()
+        if not displayPreferences:
+            displayPreferences = not self.checkPreferencesOnStartup()
         
+        # display download information using threads
+        global media_collection_treeview, log_dialog
+        global workers
 
-        self.clear_non_running_downloads()
-        
-        mounts = []
-        self.backup_devices = {}
+        #track files that should have a suffix added to them
+        global duplicate_files
         
-        # Clear download statistics and tracking
-        # FIXME
+        #track files that have been downloaded in this session
+        global downloaded_files
         
-        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))
-                    
+        # control sequence numbers and letters
+        global sequences
         
-        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)
+        # whether we need to prompt for a job code
+        global need_job_code_for_renaming
 
-        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
+        duplicate_files = {}
+        downloaded_files = DownloadedFiles()
         
-        # Display amount of free space in a status bar message
-        self.display_free_space()
+        self.download_start_time = None
         
-        if do_not_allow_auto_start:
-            self.auto_start_is_on = False
-        else:
-            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)))
+        downloadsToday = self.prefs.getAndMaybeResetDownloadsToday()
+        sequences = rn.Sequences(downloadsToday, self.prefs.stored_sequence_no)
+        
+        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()
 
-        self.testing_auto_exit = False
-        self.testing_auto_exit_trip = len(mounts)
-        self.testing_auto_exit_trip_counter = 0
+        # log window, in dialog format
+        # used for displaying download information to the user
         
+        log_dialog = LogDialog(self)
 
-        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
+
+        self.volumeMonitor = None
+        if self.usingVolumeMonitor():
+            self.startVolumeMonitor()
         
-    def get_use_device(self, device):  
-        """ Prompt user whether or not to download from this device """
+        # 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
         
-        logger.info("Prompting whether to use %s", device.get_name())
-        d = dv.UseDeviceDialog(self.rapidapp, device, self.got_use_device)
+        # flag to indicate the user changes some preferences and the display
+        # of sample names and subfolders needs to be refreshed
+        self.refreshGeneratedSampleSubfolderAndName = False
         
-    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()
+        # 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
         
-        path = device.get_path()
+        # 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
         
-        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
+        # flag to indicate that the preferences dialog window is being 
+        # displayed to the user
+        self.preferencesDialogDisplayed = False
+        
+        # set up tree view display to display image devices and download status
+        media_collection_treeview = MediaTreeView(self)        
 
-    def check_if_backup_mount(self,  path):
-        """
-        Checks to see if backups are enabled and path represents a valid backup location
+        self.media_collection_vbox.pack_start(media_collection_treeview)
         
-        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
-        """
+        #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)
         
-        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
-        """
+        self.backupVolumes = {}
 
+        #Help button and download buttons
+        self._setupDownloadbuttons()
+        
+        #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 mount.is_shadowed():
-            # ignore this type of mount
-            return
-            
-        path = mount.get_root().get_path()
+        # menus
 
-        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})
+        #preview panes
+        self.menu_display_selection.set_active(self.prefs.display_selection)
+        self.menu_preview_folders.set_active(self.prefs.display_preview_folders)
+        
+        #preview columns in pane
+        if not DOWNLOAD_VIDEO:
+            self.menu_type_column.set_active(False)
+            self.menu_type_column.set_sensitive(False)
         else:
-            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()
+            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.menu_clear.set_sensitive(False)
 
-            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
+        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)
+        
+        #job code initialization
+        self.last_chosen_job_code = None
+        self.prompting_for_job_code = False
+        
+        #check to see if the download folder exists and is writable
+        displayPreferences_2 = not self.checkDownloadPathOnStartup()
+        displayPreferences = displayPreferences or displayPreferences_2
             
-    def on_mount_removed(self, vmonitor, mount):
-        """
-        callback run when gio indicates a new volume
-        has been mounted
-        """
+        if self.prefs.device_autodetection == False:
+            displayPreferences_2 = not self.checkImageDevicePathOnStartup()
+            displayPreferences = displayPreferences or displayPreferences_2
         
-        path = mount.get_root().get_path()
+        #setup download and backup mediums, initiating scans
+        self.setupAvailableImageAndBackupMedia(onStartup=True, onPreferenceChange=False, doNotAllowAutoStart = displayPreferences)
 
-        # 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
+        #adjust viewport size for displaying media
+        #this is important because the code in MediaTreeView.addCard() is inaccurate at program startup
         
-        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)
-            
-                
-                    
-        # 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()
-            
-    def clear_non_running_downloads(self):
-        """
-        Clears the display of downloads that are currently not running
-        """
+        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)
         
-        # Stop any processes currently scanning or creating thumbnails
-        self._terminate_processes(terminate_file_copies=False)
+        self.download_button.grab_default()
+        # for some reason, the grab focus command is not working... unsure why
+        self.download_button.grab_focus()
         
-        # 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 displayPreferences:
+            PreferencesDialog(self)
             
-        
 
+
+    @dbus.service.method (config.DBUS_NAME,
+                           in_signature='', out_signature='b')
+    def is_running (self):
+        return self.running
     
-    # # #
-    # Download and help buttons, and menu items
-    # # #
+    @dbus.service.method (config.DBUS_NAME,
+                            in_signature='', out_signature='')
+    def start (self):
+        if self.is_running():
+            self.rapidapp.present()
+        else:
+            self.running = True
+#            if not using_gio:
+            self.main()
+#            else:
+#                mainloop = gobject.MainLoop()
+#                mainloop.run()
+            self.running = False
+            
+    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 on_download_action_activate(self, action):
+    def displayFreeSpace(self):
         """
-        Called when a download is activated
+        Displays the amount of space free on the filesystem the files will be downloaded to.
+        Also displays backup volumes / path being used.
         """
+        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}
         
-        if self.copy_files_manager.paused:
-            logger.debug("Download resumed")
-            self.resume_download()
-        else:
-            logger.debug("Download activated")
             
-            if self.download_action_is_download:
-                self.start_download()
+        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:
-                self.pause_download()
-
+                msg2 = self.displayBackupVolumes()
+                
+            if msg:
+                msg = _("%(freespace)s. %(backuppaths)s.") % {'freespace': msg, 'backuppaths': msg2}
+            else:
+                msg = msg2
+            
+        self.rapid_statusbar.push(self.statusbar_context_id, msg)
     
-    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
+    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})
+            
+        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
         
-        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
+    def checkDownloadPathOnStartup(self):
+        if DOWNLOAD_VIDEO:
+            paths = ((self.prefs.download_folder, _('Photo')), (self.prefs.video_download_folder, _('Video')))
+        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)
             
-            self.download_action.set_sensitive(sensitivity)
+        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")
+            else:
+                title = _("Problem with Download Folders")
             
-    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
+            misc.run_dialog(title, msg, 
+                self,
+                gtk.MESSAGE_ERROR)
+            return False
         else:
-            self.download_action.set_label(_("Pause"))
-            self.download_action_is_download = False
-    
-    # # #
-    # Job codes
-    # # #
-    
-    
-    def _init_job_code(self):
-        self.job_code = None
-        self.need_job_code_for_naming = self.prefs.any_pref_uses_job_code()
+            return True
     
-    def assign_job_code(self,  code):
+    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):
         """ 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.
         """
-        # FIXME
-        #~ global job_code
+        global job_code
         if code == None:
             code = ''
         job_code = code
@@ -1712,921 +5163,1301 @@ class RapidApp(dbus.service.Object):
                 jcs.remove(code)
                 
             self.prefs.job_codes = [code] + jcs
-
-    def _get_job_code(self,  post_job_code_entry_callback,  autoStart, downloadSelected):
+            
+    
+    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):
         """ prompt for a job code """
         
         if not self.prompting_for_job_code:
-            logger.debug("Prompting for Job Code")
+            cmd_line(_("Prompting for Job Code"))
             self.prompting_for_job_code = True
-            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)
+            j = JobCodeDialog(self.widget, self.prefs.job_codes,  self.last_chosen_job_code, postJobCodeEntryCB,  autoStart, downloadSelected, False)
         else:
-            logger.debug("Already prompting for Job Code, do not prompt again")
+            cmd_line(_("Already prompting for Job Code, do not prompt again"))
         
-    def get_job_code(self):
-        self._get_job_code(self.got_job_code)
+    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 got_job_code(self, dialog, user_chose_code, code):
+    def gotJobCode(self, dialog, userChoseCode, code, autoStart, downloadSelected):
         dialog.destroy()
         self.prompting_for_job_code = False
         
-        if user_chose_code:
-            self.assign_job_code(code)
+        if userChoseCode:
+            self.assignJobCode(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:
-                #~ 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()    
+            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()    
                 
         else:
             # user cancelled
-            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.download_tracker = downloadtracker.DownloadTracker()
+            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)
         
-        # Track which temporary directories are created when downloading files
-        self.temp_dirs_by_scan_pid = dict()
+    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)
         
-        # Track which downloads are running
-        self.download_active_by_scan_pid = []
+    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)
         
-
-    
-    def start_download(self):
-        """
-        Start download, renaming and backup of files.
-        """
+    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)
         
-        self.download_start_time = datetime.datetime.now()
-        files_by_scan_pid = self.thumbnails.get_files_checked_for_download()
-        folders_valid, invalid_dirs = self.check_download_folder_validity(files_by_scan_pid)
+    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)        
         
-        if not folders_valid:
-            if len(invalid_dirs) > 1:
-                msg = _("These download folders are invalid:\n%(folder1)s\n%(folder2)s") % {
-                        'folder1': invalid_dirs[0], 'folder2': invalid_dirs[1]}
-            else:
-                msg = _("This download folder is invalid:\n%s") % invalid_dirs[0]
-            self.log_error(config.CRITICAL_ERROR, _("Download cannot proceed"),
-                msg)
-        else:
-            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)
+    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)
                 
-            self.set_download_action_label(is_download = False)
+    def checkIfFirstTimeProgramEverRun(self):
+        """
+        if this is the first time the program has been run, then
+        might need to create default directories
+        """
+        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.
         
-    def pause_download(self):
+        If the version is different, then the preferences are checked to see whether they should be upgraded or not.
         
-        self.copy_files_manager.pause()
+        returns True if program preferences window should be opened """
         
-        # set action to display Download
-        if not self.download_action_is_download:
-            self.set_download_action_label(is_download = True)
-            
-    def resume_download(self):
-        self.copy_files_manager.start()
-
-    def download_files(self, files, scan_pid):
-        """
-        Initiate downloading and renaming of files
-        """
+        displayPrefs = upgraded = False
         
-        # 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 self.files_of_type_present(files, rpdfile.FILE_TYPE_VIDEO):
-            video_download_folder = self.prefs.video_download_folder
-        else:
-            video_download_folder = None
+        previousVersion = self.prefs.program_version
+        if len(previousVersion) > 0:
+            # the program has been run previously for this user
+        
+            pv = common.pythonifyVersion(previousVersion)
+            rv = common.pythonifyVersion(runningVersion)
             
-        self.download_tracker.init_stats(scan_pid=scan_pid, 
-                                bytes=self.size_files_to_be_downloaded(files),
-                                no_files=len(files))
+            title = PROGRAM_NAME
+            imageRename = subfolder = None
             
-        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
-                self.download_tracker.set_total_bytes_copied(scan_pid, 
-                                                             total_downloaded)
-                percent_complete = self.download_tracker.get_percent_complete(scan_pid)
-                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_tracker.set_download_count_for_file(
-                                            rpd_file.unique_id, download_count)
-                self.download_tracker.set_download_count(
-                                            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)
-                    rpd_file.download_conflict_resolution = self.prefs.download_conflict_resolution
-                    rpd_file.synchronize_raw_jpg = self.prefs.must_synchronize_raw_jpg() 
-                
-                self.subfolder_file_manager.rename_file_and_move_to_subfolder(
-                        download_succeeded, 
-                        download_count, 
-                        rpd_file
-                        )
-                
+            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
                 
-            return 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."))
         else:
-            # Process is complete, i.e. conn_type == rpdmp.CONN_COMPLETE
-            connection.close()
-            return False
-            
+            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'))
+        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)
 
+        
     
-    def download_is_occurring(self):
-        """Returns True if a file is currently being downloaded or renamed
+    def usingVolumeMonitor(self):
+        """
+        Returns True if programs needs to use gio or gnomevfs volume monitor
         """
-        return not len(self.download_active_by_scan_pid) == 0
+        
+        return (self.prefs.device_autodetection or 
+                (self.prefs.backup_images and 
+                self.prefs.backup_device_autodetection
+                ))
+        
     
-    # # #
-    # Create folder and file names for downloaded files
-    # # #
+    def startVolumeMonitor(self):
+        if not self.volumeMonitor:
+            self.volumeMonitor = VMonitor(self)
     
-    def subfolder_file_results(self, move_succeeded, rpd_file):
+    def displayBackupVolumes(self):
         """
-        Handle results of subfolder creation and file renaming
+        Create a message to be displayed to the user showing which backup volumes will be used
         """
-            
-        scan_pid = rpd_file.scan_pid
-        unique_id = rpd_file.unique_id
+        message =  ''
         
-        self.thumbnails.update_status_post_download(rpd_file)
+        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
         
-        # Update error log window if neccessary
-        if not move_succeeded:
-            self.log_error(config.SERIOUS_ERROR, rpd_file.error_title, 
-                           rpd_file.error_msg, rpd_file.error_extra_detail)
-        elif rpd_file.status == config.STATUS_DOWNLOADED_WITH_WARNING:
-            self.log_error(config.WARNING, rpd_file.error_title, 
-                           rpd_file.error_msg, rpd_file.error_extra_detail)
+    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.download_tracker.file_downloaded_increment(scan_pid)
-        self._update_file_download_device_progress(scan_pid, unique_id)
-                
-        download_count = self.download_tracker.get_download_count_for_file(unique_id)
-        if download_count == self.download_tracker.get_no_files_in_download(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)
-            self.download_tracker.purge(scan_pid)
-            self.download_active_by_scan_pid.remove(scan_pid)
+
+    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
             
-            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()
+    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
         else:
-            pass
-            #~ logger.info("Download count: %s", download_count)
-
+            return False
 
+    def workerHasThisPath(self,  path):
+        havePath= False
+        for w in workers.getNonFinishedWorkers():
+            if w.cardMedia.path == path:
+                havePath = True
+                break
+        return havePath
         
-    def _update_file_download_device_progress(self, scan_pid, unique_id):
+    def on_volume_mounted(self, monitor, mount):
         """
-        Increments the progress bar for an individual device
+        callback run when gnomevfs indicates a new volume
+        has been mounted
         """
-        progress_bar_text = _("%(number)s of %(total)s %(filetypes)s") % \
-                             {'number':  self.download_tracker.get_download_count_for_file(unique_id), 
-                              'total': self.download_tracker.get_no_files_in_download(scan_pid),
-                              'filetypes': self.download_tracker.get_file_types_present(scan_pid)}
-        percent_complete = self.download_tracker.get_percent_complete(scan_pid)
-        self.device_collection.update_progress(scan_pid=scan_pid,
-                                        percent_complete=percent_complete,
-                                        progress_bar_text=progress_bar_text, 
-                                        bytes_downloaded=None)        
-
-    def _clean_all_temp_dirs(self):
+        
+        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):
         """
-        Cleans all temp dirs if they exist
+        callback run when gnomevfs indicates a volume
+        has been unmounted
         """
-        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)
+        
+        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()
                 
-        self.temp_dirs_by_scan_pid = {}
-            
+            # may need to disable download button
+            self.setDownloadButtonSensitivity()
+        
     
-    def _clean_temp_dirs_for_scan_pid(self, scan_pid):
+    def clearCompletedDownloads(self):
         """
-        Deletes temp files and folders used in download
+        clears the display of completed downloads
         """
-        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]
 
-    def _purge_dir(self, directory):
-        """
-        Deletes all files in the directory, and the directory itself.
+        for w in workers.getFinishedWorkers():
+            media_collection_treeview.removeCard(w.thread_id)
+            self.selection_vbox.selection_treeview.clear_all(w.thread_id)
+
+            
+
         
-        Does not recursively traverse any subfolders in the directory.
+    def clearNotStartedDownloads(self):
+        """
+        Clears the display of the download and instructs the thread not to run
         """
         
-        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)
-    
+        for w in workers.getNotDownloadingWorkers():
+            media_collection_treeview.removeCard(w.thread_id)
+            workers.disableWorker(w.thread_id)
     
-    # # # 
-    # Preferences
-    # # #
-
-    def check_prefs_on_startup(self):
+    def checkIfBackupVolume(self,  path):
         """
-        Checks the image & video rename, and subfolder prefs for validity.
+        Checks to see if backups are enabled and path represents a valid backup location
         
-        Returns True if no problem, false otherwise.
+        Checks against user preferences.
         """
-        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 relating to file renaming and subfolder creation. Some preferences will be reset.")
-        return prefs_ok
+        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 _init_prefs(self): 
-        self.prefs = prefsrapid.RapidPreferences()
-        self.prefs.notify_add(self.on_preference_changed)
+    def _printAutoStart(self,  autoStart):
+        if autoStart:
+            cmd_line(_("Automatically start download is true") )
+        else:
+            cmd_line(_("Automatically start download is false") )
         
-        # 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
+    def setupAvailableImageAndBackupMedia(self, onStartup, onPreferenceChange, doNotAllowAutoStart):
+        """
+        Sets up volumes for downloading from and backing up to
         
-        # flag to indicate that the preferences dialog window is being 
-        # displayed to the user
-        self.preferences_dialog_displayed = False
-
-        # flag to indicate that the user has modified the download today
-        # related values in the preferences dialog window
-        self.refresh_downloads_today = False
+        onStartup should be True if the program is still starting, i.e. this is being called from the 
+        program's initialization.
+        
+        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
+        """
+        
+        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.downloads_today_tracker = self.prefs.get_downloads_today_tracker()
+        self.displayFreeSpace()
+        # add each memory card / other device to the list of threads
         
-        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)
+        if doNotAllowAutoStart:
+            autoStart = False
         else:
-            logger.info("No downloads have occurred so far today")        
-
-        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())
+            autoStart = (not onPreferenceChange) and ((self.prefs.auto_download_at_startup and onStartup) or (self.prefs.auto_download_upon_device_insertion and not onStartup))
         
-        self.prefs.program_version = __version__
+        self._printAutoStart(autoStart)
         
-    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 on_preference_changed(self, key, value):
+        shownWarning = 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):
         """
-        Called when user changes the program's preferences
+        Setup the backup media
+        
+        Assumptions: this is being called after the user has changed their preferences AND download media has already been setup
         """
-        logger.debug("Preference change detected: %s", key)
+        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()
         
+    def _setupDownloadbuttons(self):
+        self.download_hbutton_box = gtk.HButtonBox()
+        self.download_hbutton_box.set_spacing(12)
+        self.download_hbutton_box.set_homogeneous(False)
 
-        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()
-                
-        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()
+        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()
+        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
                 
-        # Downloads today and stored sequence numbers are kept in shared memory,
-        # so that the subfolderfile daemon process can access and modify them
+            self.startTime = time.time()
+            self.timeStatusBarUpdated = self.startTime
+
+            self.timeMark = self.startTime
+            self.sizeMark = 0            
         
-        # Note, totally ignore any changes in downloads today, as it
-        # is modified in a special manner via a tracking class
-                
-        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()
+    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()
+
             
-        elif key in ['download_folder', 'video_download_folder']:
-            self.display_free_space()
+        #start any new workers that have downloads pending
+        for i in threads:
+            workers[i].startStop()
+        
+        if is_beta and verbose and False:
+            workers.printWorkerStatus()
     
-    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)
-            if self.main_notebook.get_current_page() == 1: # preview of file
-                self.main_notebook.set_current_page(0)
+    def setDownloadStartTime(self):
+        if not self.download_start_time:
+            self.download_start_time = datetime.datetime.now()
+        
+    def updateOverallProgress(self, thread_id, bytesDownloaded, percentComplete):
+        """
+        Updates progress bar and status bar text with time remaining
+        to download images
+        """
                 
-            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)
+        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)
+                
+                timeRemaining = self.timeRemaining.timeRemaining()
+                if timeRemaining:
+                    secs =  int(timeRemaining)
+                
+                    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)
+                    
     
-    # # #
-    # Main app window management and setup
-    # # #
+    def resetSequences(self):
+        if self.downloadComplete():
+            sequences.reset(self.prefs.getDownloadsToday(),  self.prefs.stored_sequence_no)
     
-    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")
+    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 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.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")
-        self.menu_log_window = builder.get_object("menu_log_window")
+    
+    def downloadFailed(self, thread_id):
+        if workers.noDownloadingWorkers() == 0:
+            self.download_button_is_download = True
+            self._set_download_button()
+            self.setDownloadButtonSensitivity()
+    
+    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
         
-        # Only enable this action when actually displaying a preview
-        self.next_image_action.set_sensitive(False)
-        self.prev_image_action.set_sensitive(False)        
+        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
         
-        # About dialog
-        builder.add_from_file(paths.share_dir("glade3/about.ui"))
-        self.about = builder.get_object("about")
         
-        builder.connect_signals(self)
+    def on_rapidapp_destroy(self, widget):
+        """Called when the application is going to quit"""
         
-        self.preview_image = PreviewImage(self, builder)
+        # 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()
 
-        thumbnails_scrolledwindow = builder.get_object('thumbnails_scrolledwindow')
-        self.thumbnails = ThumbnailDisplay(self)
-        thumbnails_scrolledwindow.add(self.thumbnails)        
-        
-        #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)
+        x, y = self.rapidapp.get_size()
+        self.prefs.main_window_size_x = x
+        self.prefs.main_window_size_y = y
+
+        workers.quitAllWorkers()
+
+        self.flushevents() 
         
-        #error log window
-        self.error_log = errorlog.ErrorLog(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
+                
+
+    def on_menu_clear_activate(self, widget):
+        self.clearCompletedDownloads()
+        widget.set_sensitive(False)
         
-        # 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_refresh_activate(self, widget):
+        self.selection_vbox.selection_treeview.clear_all()
+        self.setupAvailableImageAndBackupMedia(onStartup = False,  onPreferenceChange = True,  doNotAllowAutoStart = True)
         
-        # Download action state
-        self.download_action_is_download = True
+    def on_menu_report_problem_activate(self,  widget):
+        webbrowser.open("https://bugs.launchpad.net/rapid") 
         
-        #job code initialization
-        self.last_chosen_job_code = None
-        self.prompting_for_job_code = False
+    def on_menu_get_help_online_activate(self,  widget):
+        webbrowser.open("http://www.damonlynch.net/rapid/help.html") 
 
-    def _set_window_size(self):
-        """
-        Remember the window size from the last time the program was run, or
-        set a default size        
-        """
-        
-        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:
-            # set a default size
-            self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH, 
-                                           config.DEFAULT_WINDOW_HEIGHT)
-        
+    def on_menu_donate_activate(self,  widget):
+        webbrowser.open("http://www.damonlynch.net/rapid/donate.html") 
 
-    def _set_device_collection_size(self):
-        """
-        Set the size of the device collection scrolled window widget
-        """
-        
+    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 """
+
+        PreferencesDialog(self)
         
-        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)
+    def on_menu_log_window_toggled(self, widget):
+        active = widget.get_active()
+        self.prefs.show_log_dialog = active
+        if active:
+            log_dialog.widget.show()
         else:
-            # don't allow the media collection to be absolutely empty
-            self.device_collection_scrolledwindow.set_size_request(-1, 47)
-        
-            
-    def on_rapidapp_window_state_event(self, widget, event):
-        """ Records the window maximization state in the preferences."""
-        
-        if event.changed_mask & gdk.WINDOW_STATE_MAXIMIZED:
-            self.prefs.main_window_maximized = event.new_window_state & gdk.WINDOW_STATE_MAXIMIZED
+            log_dialog.widget.hide()
+
+    def on_menu_display_selection_toggled(self, check_button):
+        self.prefs.display_selection = check_button.get_active()
         
-    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_preview_folders_toggled(self, check_button):
+        self.prefs.display_preview_folders = check_button.get_active()
         
-        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)
+    def on_menu_zoom_out_activate(self, widget):
+        self.selection_vbox.zoom_out()
         
-        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)
+    def on_menu_zoom_in_activate(self, widget):
+        self.selection_vbox.zoom_in()
         
-        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 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 _setup_error_icons(self):
-        """
-        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()
+    def on_menu_select_all_videos_activate(self, widget):
+        self.selection_vbox.selection_treeview.select_rows('videos')
         
-    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 on_menu_select_none_activate(self, widget):
+        self.selection_vbox.selection_treeview.select_rows('none')
         
-    def display_free_space(self):
+    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):
         """
-        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)
+        Sets download button to appropriate state
         """
-        photo_dir = self.is_valid_download_dir(path=self.prefs.download_folder, is_photo_dir=True, show_error_in_log=True)
-        video_dir = self.is_valid_download_dir(path=self.prefs.video_download_folder, is_photo_dir=False, show_error_in_log=True)
-        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")))
-        
-        msg = ''
-        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:
-                #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}
         
+        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()
             
-        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:
-                msg2 = self.displayBackupVolumes() #FIXME
-                
-            if msg:
-                msg = _("%(freespace)s. %(backuppaths)s.") % {'freespace': msg, 'backuppaths': msg2}
+            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()
             else:
-                msg = msg2
-        
-        msg = msg.rstrip()
+                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()
             
-        self.statusbar_message(msg)
+    def on_menu_download_pause_activate(self, widget):
+        self.on_download_button_clicked(widget)
         
-    def log_error(self, severity, problem, details, extra_detail=None):
-        """
-        Display error and warning messages to user in log window
+    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):
         """
-        self.error_log.add_message(severity, problem, details, extra_detail)
-        
-    
-    def on_error_eventbox_button_press_event(self, widget, event):
-        self.prefs.show_log_dialog = True
-        self.error_log.widget.show()     
+        Handle download button click.
         
+        Button is in one of three states: download all, resume, or pause.
         
-    def on_menu_log_window_toggled(self, widget):
-        active = widget.get_active()
-        self.prefs.show_log_dialog = active
-        if active:
-            self.error_log.widget.show()
+        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)
+            else:
+                threads = self.selection_vbox.selection_treeview.set_status_to_download_pending(selected_only = False)
+                self.startDownload(threads)
+            self._set_download_button()
         else:
-            self.error_log.widget.hide()
-    
-    
-    # # #
-    # Utility functions
-    # # #
+            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)
+                
 
-    def files_of_type_present(self, files, file_type):
-        """
-        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
         
-    def size_files_to_be_downloaded(self, files):
-        """
-        Returns the total size of the files to be downloaded in bytes
+    def on_help_button_clicked(self, widget):
+        webbrowser.open("http://www.damonlynch.net/rapid/help.html")
+            
+    def on_preference_changed(self, key, value):
         """
-        size = 0
-        for i in range(len(files)):
-            size += files[i].size
-
-        return size
-                                              
-    def check_download_folder_validity(self, files_by_scan_pid):
+        Called when user changes the program's preferences
         """
-        Checks validity of download folders based on the file types the user
-        is attempting to download.
         
-        If valid, returns a tuple of True and an empty list.
-        If invalid, returns a tuple of False and a list of the invalid directores.
+        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):
         """
-        valid = True
-        invalid_dirs = []
-        # 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
+        Handle changes in program preferences after the preferences dialog window has been closed
+        """
+        if self.rerunSetupAvailableImageAndVideoMedia:
+            if self.usingVolumeMonitor():
+                self.startVolumeMonitor()
+            cmd_line("\n" + _("Download device settings preferences were changed."))
             
-        # second, check validity
-        if need_photo_folder:
-            if not self.is_valid_download_dir(self.prefs.download_folder, 
-                                                        is_photo_dir=True):
-                valid = False
-                invalid_dirs.append(self.prefs.download_folder)
+            self.selection_vbox.selection_treeview.clear_all()
+            self.setupAvailableImageAndBackupMedia(onStartup = False, onPreferenceChange = True, doNotAllowAutoStart = True)
+            if is_beta and verbose and False:
+                workers.printWorkerStatus()
                 
-        if need_video_folder:
-            if not self.is_valid_download_dir(self.prefs.video_download_folder,
-                                                        is_photo_dir=False):            
-                valid = False
-                invalid_dirs.append(self.prefs.video_download_folder)
+            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
                 
-        return (valid, invalid_dirs)
+            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
 
-    def same_file_system(self, file1, file2):
-        """Returns True if the files / diretories are on the same file system
+    def regenerateScannedDevices(self, thread_id):
         """
-        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
+        Regenerate the filenames / subfolders / download folders for this thread
         
-    
-    def same_file(self, file1, file2):
-        """Returns True if the files / directories are the same
+        The user must have adjusted their preferences as the device was being scanned
         """
-        f1 = gio.File(file1)
-        f2 = gio.File(file2)
-        
-        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 is_valid_download_dir(self, path, is_photo_dir, show_error_in_log=False):
-        """
-        Checks the following conditions:
-        Does the directory exist?
-        Is it writable?
+        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
+            
+
         
-        if show_error_in_log is True, then display warning in log window, using
-        is_photo_dir, which if true means the download directory is for photos,
-        if false, for Videos
-        """
-        valid = False
-        if is_photo_dir:
-            download_folder_type = _("Photo")
+ 
+    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:
-            download_folder_type = _("Video")
+            self.vmonitor = gnomevfs.VolumeMonitor()
+            self.vmonitor.connect("volume-mounted", self.app.on_volume_mounted)
+            self.vmonitor.connect("volume-unmounted", self.app.on_volume_unmounted)
             
-        try:
-            d = gio.File(path)
-            if not d.query_exists(cancellable=None):
-                logger.error("%s download folder does not exist: %s", 
-                             download_folder_type, path)
-                if show_error_in_log:
-                    severity = config.WARNING
-                    problem = _("%(file_type)s download folder does not exist") % {
-                                'file_type': download_folder_type}
-                    details = _("Folder: %s") % path
-                    self.log_error(severity, problem, details)
-            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 download folder is invalid: %s", 
-                                 download_folder_type, path)
-                    if show_error_in_log:
-                        severity = config.WARNING
-                        problem = _("%(file_type)s download folder is invalid") % {
-                                    'file_type': download_folder_type}
-                        details = _("Folder: %s") % path
-                        self.log_error(severity, problem, details)                  
-                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)
-                        if show_error_in_log:
-                            severity = config.WARNING
-                            problem = _("%(file_type)s download folder is not writable") % {
-                                        'file_type': download_folder_type}
-                            details = _("Folder: %s") % path
-                            self.log_error(severity, problem, details)                          
-                    else:
-                        f = gio.File(temp_dir)
-                        f.delete(cancellable=None)
 
-        except gio.Error, inst:
-            logger.error("Error checking download directory %s", path)
-            logger.error(inst)
+    def get_mounts(self):        
+        if using_gio:
+            return self.vmonitor.get_mounts()
+        else:
+            return self.vmonitor.get_mounted_volumes()
             
-        return valid
-                
-    
-    
-    # # #
-    #  Process results and management
-    # # #
-        
+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
         
-    def _start_process_managers(self):
-        """
-        Set up process managers.
+    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
         
-        A task such as scanning a device or copying files is handled in its
-        own process.        
-        """
         
-        self.batch_size = 10
-        self.batch_size_MB = 2
+    def get_icon_pixbuf(self, size):
+        """ returns icon for the volume, or None if not available"""
         
-        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)
+        return common.get_icon_pixbuf(using_gio, self.volume.get_icon(), size)
             
+    def unmount(self,  callback):
+        self.volume.unmount(callback)
+
+class DownloadStats:
+    def __init__(self):
+        self.clear()
         
-        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 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)
+
         
-    def scan_results(self, source, condition):
-        """
-        Receive results from scan processes
-        """
-        connection = self.scan_manager.get_pipe(source)
+    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.
         
-        conn_type, data = connection.recv()
+        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"""
         
-        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.download_tracker.set_file_types_present(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:
-                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()
-            
-            # signal that no more data is coming, finishing io watch for this pipe
-            return False
-        else:
-            if len(data) > self.batch_size:
-                logger.critical("incoming pipe length is unexpectedly long: %s" % len(data))
+        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])
             else:
-                for rpd_file in data:
-                    self.thumbnails.add_file(rpd_file)
+                return (-99, None)
+        return (1, None)
         
-        # must return True for this method to be called again
-        return True
+    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
+            
+    def timeRemaining(self):
+        return max(self._timeEstimates())
 
-    @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 setTimeMark(self,  w):
+        if w in self.times:
+            self.times[w].timeMark = time.time()
+        
+    def clear(self):
+        self.times = {}         
+        
+    def remove(self,  w):
+        if w in self.times:
+            del self.times[w]
         
-def start():
+def programStatus():
+    print _("Goodbye")
 
-    is_beta = config.version.find('~') > 0
+        
+def start ():
+    global is_beta
+    is_beta = config.version.find('~b') > 0
     
-    parser = OptionParser(version= "%%prog %s" % utilities.human_readable_version(config.version))
+    parser = OptionParser(version= "%%prog %s" % 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.
@@ -2637,18 +6468,19 @@ 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
     
-    if options.debug:
-        logging_level = logging.DEBUG
-    elif options.verbose:
-        logging_level = logging.INFO
-    else:
-        logging_level = logging.ERROR
+    global debug_info
+    debug_info = options.debug
+    if debug_info:
+        verbose = True
     
-    logger.setLevel(logging_level)
-
+    if verbose:
+        atexit.register(programStatus)
+        
     if options.extensions:
-        extensions = ((rpdfile.RAW_FILE_EXTENSIONS + rpdfile.NON_RAW_IMAGE_FILE_EXTENSIONS, _("Photos:")), (rpdfile.VIDEO_FILE_EXTENSIONS, _("Videos:")))
+        extensions = ((metadata.RAW_FILE_EXTENSIONS + metadata.NON_RAW_IMAGE_FILE_EXTENSIONS, _("Photos:")), (videometadata.VIDEO_FILE_EXTENSIONS, _("Videos:")))
         for exts, file_type in extensions:
             v = ''
             for e in exts[:-1]:
@@ -2664,25 +6496,43 @@ def start():
         print _("All settings and preferences have been reset")
         sys.exit(0)
 
-    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())
+    cmd_line(_("Rapid Photo Downloader") + " %s" % config.version)
+    cmd_line(_("Using") + " pyexiv2 " + metadata.version_info())
+    cmd_line(_("Using") + " exiv2 " + metadata.exiv2_version_info())
     if DOWNLOAD_VIDEO:
-        logger.info("Using hachoir %s", metadatavideo.version_info())
+        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()
     else:
-        logger.info(_("Video downloading functionality disabled.\nTo download videos, please install the hachoir metadata and kaa metadata packages for python."))
+        # 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)
 
+    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 "Rapid Photo Downloader is already running"
+        print _("%s is already running") % PROGRAM_NAME
         object = bus.get_object (config.DBUS_NAME, "/")
         app = dbus.Interface (object, config.DBUS_NAME)
     
-    app.start()            
+    app.start()
+
+    gdk.threads_leave()    
 
 if __name__ == "__main__":
     start()