Imported Upstream version 0.4.6upstream/0.4.6

1 files changed, 902 insertions, 869 deletions

diff --git a/rapid/rapid.py b/rapid/rapid.py
index fab5796..7de18c2 100755
--- a/rapid/rapid.py
+++ b/rapid/rapid.py
@@ -18,6 +18,7 @@
 ### Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 ### USA
 
+use_pynotify = True
 
 import tempfile
 
@@ -39,7 +40,9 @@ import webbrowser
 import sys, time, types, os, datetime
 
 import gobject, pango, cairo, array, pangocairo, gio
-import pynotify
+
+if use_pynotify:
+    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
@@ -50,7 +53,7 @@ logger = log_to_stderr()
 # Rapid Photo Downloader modules
 
 import rpdfile
-                  
+
 import problemnotification as pn
 import thumbnail as tn
 import rpdmultiprocessing as rpdmp
@@ -105,10 +108,10 @@ from config import  STATUS_CANNOT_DOWNLOAD, STATUS_DOWNLOADED, \
                     STATUS_NOT_DOWNLOADED, \
                     STATUS_DOWNLOAD_AND_BACKUP_FAILED, \
                     STATUS_WARNING
-                    
+
 DOWNLOADED = [STATUS_DOWNLOADED, STATUS_DOWNLOADED_WITH_WARNING, STATUS_BACKUP_PROBLEM]
 
-#Translators: if neccessary, for guidance in how to translate this program, you may see http://damonlynch.net/translate.html 
+#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
 
@@ -117,12 +120,12 @@ def date_time_human_readable(date, with_line_break=True):
         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 date_time_subseconds_human_readable(date, subseconds):
     return _("%(date)s %(hour)s:%(minute)s:%(second)s:%(subsecond)s") % \
-            {'date':date.strftime("%x"), 
+            {'date':date.strftime("%x"),
              'hour':date.strftime("%H"),
-             'minute':date.strftime("%M"), 
+             'minute':date.strftime("%M"),
              'second':date.strftime("%S"),
              'subsecond': subseconds}
 
@@ -135,7 +138,7 @@ class DeviceCollection(gtk.TreeView):
     def __init__(self, parent_app):
 
         self.parent_app = parent_app
-        # device icon & name, size of images on the device (human readable), 
+        # device icon & name, size of images on the device (human readable),
         # copy progress (%), copy text, eject button (None if irrelevant),
         # process id, pulse
         self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, str, float, str,
@@ -144,15 +147,15 @@ class DeviceCollection(gtk.TreeView):
         self.devices_by_scan_pid = {}
 
         gtk.TreeView.__init__(self, self.liststore)
-        
+
         self.props.enable_search = False
         # make it impossible to select a row
         selection = self.get_selection()
         selection.set_mode(gtk.SELECTION_NONE)
         self.set_headers_visible(False)
-        
-        
-        # Device refers to a thing like a camera, memory card in its reader, 
+
+
+        # 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()
@@ -168,46 +171,46 @@ class DeviceCollection(gtk.TreeView):
         column0.add_attribute(text_renderer, 'text', 1)
         column0.add_attribute(eject_renderer, 'pixbuf', 5)
         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)
         self.append_column(column1)
-        
-        column2 = gtk.TreeViewColumn(_("Download Progress"), 
+
+        column2 = gtk.TreeViewColumn(_("Download Progress"),
                                     gtk.CellRendererProgress(),
                                     value=3,
                                     text=4,
                                     pulse=7)
         self.append_column(column2)
         self.show_all()
-        
+
         icontheme = gtk.icon_theme_get_default()
         try:
-            self.eject_pixbuf = icontheme.load_icon('media-eject', 16, 
+            self.eject_pixbuf = icontheme.load_icon('media-eject', 16,
                                                 gtk.ICON_LOOKUP_USE_BUILTIN)
         except:
             self.eject_pixbuf = gtk.gdk.pixbuf_new_from_file(
                                     paths.share_dir('glade3/media-eject.png'))
-                                    
+
         self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
         self.connect('button-press-event', self.button_clicked)
-        
+
 
     def add_device(self, process_id, device, progress_bar_text = ''):
-        
+
         # add the row, and get a temporary pointer to the row
         size_files = ''
         progress = 0.0
-        
+
         if device.mount is None:
             eject = None
         else:
             eject = self.eject_pixbuf
-            
+
         self.devices_by_scan_pid[process_id] = device
-            
+
         iter = self.liststore.append((device.get_icon(),
                                       device.get_name(),
                                       size_files,
@@ -216,9 +219,9 @@ class DeviceCollection(gtk.TreeView):
                                       eject,
                                       process_id,
                                       -1))
-        
+
         self._set_process_map(process_id, iter)
-        
+
         # adjust scrolled window height, based on row height and number of ready to start downloads
 
         # please note, at program startup, self.row_height() will be less than it will be when already running
@@ -228,7 +231,8 @@ class DeviceCollection(gtk.TreeView):
         row_height = self.get_background_area(0, self.get_column(0))[3] + 1
         height = max(((len(self.map_process_to_row) + 1) * row_height), 24)
         self.parent_app.device_collection_scrolledwindow.set_size_request(-1, height)
-        
+
+
     def update_device(self, process_id, total_size_files):
         """
         Updates the size of the photos and videos on the device, displayed to the user
@@ -238,39 +242,39 @@ class DeviceCollection(gtk.TreeView):
             self.liststore.set_value(iter, 2, total_size_files)
         else:
             logger.critical("This device is unknown")
-            
+
     def get_device(self, process_id):
         return self.devices_by_scan_pid.get(process_id)
-    
+
     def remove_device(self, process_id):
         if process_id in self.map_process_to_row:
             iter = self._get_process_map(process_id)
             self.liststore.remove(iter)
             del self.map_process_to_row[process_id]
             del self.devices_by_scan_pid[process_id]
-            
+
     def get_all_displayed_processes(self):
         """
-        returns a list of the processes currently being displayed to the user 
+        returns a list of the processes currently being displayed to the user
         """
         return self.map_process_to_row.keys()
 
 
     def _set_process_map(self, process_id, iter):
         """
-        convert the temporary iter into a tree reference, which is 
+        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
-    
+
     def _get_process_map(self, process_id):
         """
         return the tree iter for this process
         """
-        
+
         if process_id in self.map_process_to_row:
             treerowref = self.map_process_to_row[process_id]
             path = treerowref.get_path()
@@ -278,16 +282,16 @@ class DeviceCollection(gtk.TreeView):
             return iter
         else:
             return None
-    
+
     def update_progress(self, scan_pid, percent_complete, progress_bar_text, bytes_downloaded, pulse=None):
-        
+
         iter = self._get_process_map(scan_pid)
         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 pulse is not None:
                 if pulse:
                     # Make the bar pulse
@@ -316,14 +320,14 @@ class DeviceCollection(gtk.TreeView):
                             iter = self.liststore.get_iter(path)
                             if self.liststore.get_value(iter, 5) is not None:
                                 self.unmount(process_id = self.liststore.get_value(iter, 6))
-            
+
     def unmount(self, process_id):
         device = self.devices_by_scan_pid[process_id]
         if device.mount is not None:
             logger.debug("Unmounting device with scan pid %s", process_id)
             device.mount.unmount(self.unmount_callback)
-        
-    
+
+
     def unmount_callback(self, mount, result):
         name = mount.get_name()
 
@@ -332,13 +336,14 @@ class DeviceCollection(gtk.TreeView):
             logger.debug("%s successfully unmounted" % name)
         except gio.Error, inst:
             logger.error("%s did not unmount: %s", name, inst)
-            
-            title = _("%(device)s did not unmount") % {'device': name}
-            message = '%s' % inst
-                       
-            n = pynotify.Notification(title, message)
-            n.set_icon_from_pixbuf(self.parent_app.application_icon)
-            n.show()             
+
+            if use_pynotify:
+                title = _("%(device)s did not unmount") % {'device': name}
+                message = '%s' % inst
+
+                n = pynotify.Notification(title, message)
+                n.set_icon_from_pixbuf(self.parent_app.application_icon)
+                n.show()
 
 
 def create_cairo_image_surface(pil_image, image_width, image_height):
@@ -353,55 +358,55 @@ class ThumbnailCellRenderer(gtk.CellRenderer):
     __gproperties__ = {
         "image": (gobject.TYPE_PYOBJECT, "Image",
         "Image", gobject.PARAM_READWRITE),
-        
-        "filename": (gobject.TYPE_STRING, "Filename", 
+
+        "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
-        
+
         self.image_area_size = 100
         self.text_area_size = 30
         self.padding = 6
         self.checkbutton_height = checkbutton_height
         self.icon_width = 20
-        
+
     def do_set_property(self, pspec, value):
         setattr(self, pspec.name, value)
 
     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 
+
+        #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:
@@ -416,33 +421,33 @@ class ThumbnailCellRenderer(gtk.CellRenderer):
         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
         #~ cairo_context.set_source_rgb(0.33,0.33,0.33)
         #~ cairo_context.rectangle(x, y, w, h)
         #~ cairo_context.stroke()
-        
+
         #place the image
         cairo_context.set_source_surface(image, image_x, image_y)
         cairo_context.paint()
-        
+
         #text
         context = pangocairo.CairoContext(cairo_context)
-        
+
         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()        
-        
+        #~ context.clip()
+
         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)
-        
+
         #font color and size
         fg_color = pango.AttrForeground(65535, 65535, 65535, 0, -1)
         font_size = pango.AttrSize(8192, 0, -1) # 8 * 1024 = 8192
@@ -453,7 +458,7 @@ class ThumbnailCellRenderer(gtk.CellRenderer):
         attr.insert(font_family)
         layout.set_attributes(attr)
 
-        layout.set_text(self.filename)        
+        layout.set_text(self.filename)
 
         context.move_to(text_x, text_y)
         context.show_layout(layout)
@@ -461,13 +466,13 @@ class ThumbnailCellRenderer(gtk.CellRenderer):
         #status
         cairo_context.set_source_pixbuf(self.status, x, y + self.image_area_size + 10)
         cairo_context.paint()
-        
+
     def do_get_size(self, widget, cell_area):
         return (0, 0, self.image_area_size, self.image_area_size + self.text_area_size - self.checkbutton_height + 4)
-        
+
 
 gobject.type_register(ThumbnailCellRenderer)
- 
+
 
 class ThumbnailDisplay(gtk.IconView):
     def __init__(self, parent_app):
@@ -475,39 +480,39 @@ class ThumbnailDisplay(gtk.IconView):
         self.set_spacing(0)
         self.set_row_spacing(5)
         self.set_margin(25)
-        
+
         self.set_selection_mode(gtk.SELECTION_MULTIPLE)
         self.connect('selection-changed', self.on_selection_changed)
         self._selected_items = []
-        
+
         self.rapid_app = parent_app
-        
+
         self.batch_size = 10
-        
+
         self.thumbnail_manager = ThumbnailManager(self.thumbnail_results, self.batch_size)
         self.preview_manager = PreviewManager(self.preview_results)
-        
-        self.treerow_index = {} 
-        self.process_index = {} 
-        
+
+        self.treerow_index = {}
+        self.process_index = {}
+
         self.rpd_files = {}
-        
+
         self.total_thumbs_to_generate = 0
         self.thumbnails_generated = 0
-        
+
         # dict of scan_pids that are having thumbnails generated
         # value is the thumbnail process id
         # this is needed when terminating thumbnailing early such as when
         # user clicks download before the thumbnailing is finished
         self.generating_thumbnails = {}
-        
+
         self.thumbnails = {}
         self.previews = {}
         self.previews_being_fetched = set()
-        
+
         self.stock_photo_thumbnails = tn.PhotoIcons()
         self.stock_video_thumbnails = tn.VideoIcons()
-        
+
         self.SELECTED_COL = 1
         self.UNIQUE_ID_COL = 2
         self.TIMESTAMP_COL = 4
@@ -515,11 +520,11 @@ class ThumbnailDisplay(gtk.IconView):
         self.CHECKBUTTON_VISIBLE_COL = 6
         self.DOWNLOAD_STATUS_COL = 7
         self.STATUS_ICON_COL = 8
-        
+
         self._create_liststore()
 
         self.clear()
-        
+
         checkbutton = gtk.CellRendererToggle()
         checkbutton.set_radio(False)
         checkbutton.props.activatable = True
@@ -529,11 +534,11 @@ class ThumbnailDisplay(gtk.IconView):
 
         self.add_attribute(checkbutton, "active", 1)
         self.add_attribute(checkbutton, "visible", 6)
-        
+
         checkbutton_size = checkbutton.get_size(self, None)
         checkbutton_height = checkbutton_size[3]
         checkbutton_width = checkbutton_size[2]
-        
+
         image = ThumbnailCellRenderer(checkbutton_height)
         self.pack_start(image, expand=True)
         self.add_attribute(image, "image", 0)
@@ -542,12 +547,12 @@ class ThumbnailDisplay(gtk.IconView):
 
         #set the background color to a darkish grey
         self.modify_base(gtk.STATE_NORMAL, gtk.gdk.Color('#444444'))
-        
+
         self.show_all()
         self._setup_icons()
-        
+
         self.connect('item-activated', self.on_item_activated)
-        
+
     def _create_liststore(self):
         """
         Creates the default list store to hold the icons
@@ -562,8 +567,8 @@ class ThumbnailDisplay(gtk.IconView):
              gobject.TYPE_BOOLEAN,  # 6 visibility of checkbutton
              int,                   # 7 status of download
              gtk.gdk.Pixbuf,        # 8 status icon
-             )        
-        
+             )
+
     def _setup_icons(self):
         # icons to be displayed in status column
 
@@ -582,19 +587,19 @@ class ThumbnailDisplay(gtk.IconView):
                size, size)
         self.download_pending_icon = gtk.gdk.pixbuf_new_from_file_at_size(
                paths.share_dir('glade3/rapid-photo-downloader-download-pending.png'),
-               size, size) 
+               size, size)
         self.downloaded_with_warning_icon = gtk.gdk.pixbuf_new_from_file_at_size(
                paths.share_dir('glade3/rapid-photo-downloader-downloaded-with-warning.svg'),
                size, size)
         self.downloaded_with_error_icon = gtk.gdk.pixbuf_new_from_file_at_size(
                paths.share_dir('glade3/rapid-photo-downloader-downloaded-with-error.svg'),
                size, size)
-        
+
         # make the not yet downloaded icon a transparent square
         self.not_downloaded_icon = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 16, 16)
         self.not_downloaded_icon.fill(0xffffffff)
         self.not_downloaded_icon = self.not_downloaded_icon.add_alpha(True, chr(255), chr(255), chr(255))
-        
+
     def get_status_icon(self, status):
         """
         Returns the correct icon, based on the status
@@ -616,33 +621,33 @@ class ThumbnailDisplay(gtk.IconView):
         else:
             logger.critical("FIXME: unknown status: %s", status)
             status_icon = self.not_downloaded_icon
-        return status_icon        
-    
+        return status_icon
+
     def sort_by_timestamp(self):
         self.liststore.set_sort_column_id(self.TIMESTAMP_COL, gtk.SORT_ASCENDING)
-    
+
     def on_selection_changed(self, iconview):
         self._selected_items = self.get_selected_items()
-        
+
     def on_checkbutton_toggled(self, cellrenderertoggle, path):
         paths = [p[0] for p in self._selected_items]
         if int(path) not in paths:
             self._selected_items = [path,]
-            
+
         for path in self._selected_items:
             iter = self.liststore.get_iter(path)
             status = self.liststore.get_value(iter, self.DOWNLOAD_STATUS_COL)
             if status == STATUS_NOT_DOWNLOADED:
                 self.liststore.set_value(iter, self.SELECTED_COL, not cellrenderertoggle.get_active())
             self.select_path(path)
-            
+
         self.rapid_app.set_download_action_sensitivity()
-        
-        
+
+
     def set_selected(self, unique_id, value):
         iter = self.get_iter_from_unique_id(unique_id)
         self.liststore.set_value(iter, self.SELECTED_COL, value)
-    
+
     def add_file(self, rpd_file, generate_thumbnail):
 
         thumbnail_icon = self.get_stock_icon(rpd_file.file_type)
@@ -650,7 +655,7 @@ class ThumbnailDisplay(gtk.IconView):
         scan_pid = rpd_file.scan_pid
 
         timestamp = int(rpd_file.modification_time)
-        
+
         iter = self.liststore.append((thumbnail_icon,
                                       True,
                                       unique_id,
@@ -661,47 +666,47 @@ class ThumbnailDisplay(gtk.IconView):
                                       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)
         else:
             self.process_index[scan_pid] = [unique_id,]
-            
+
         self.treerow_index[unique_id] = treerowref
         self.rpd_files[unique_id] = rpd_file
-        
+
         if generate_thumbnail:
             self.total_thumbs_to_generate += 1
 
     def get_sample_file(self, file_type):
-        """Returns an rpd_file for of a given file type, or None if it does 
+        """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)
-        
+
     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 on_item_activated(self, iconview, path):
         """
         """
         iter = self.liststore.get_iter(path)
         self.show_preview(iter=iter)
         self.advance_get_preview_image(iter)
 
-    
+
     def _get_preview(self, unique_id, rpd_file):
         if unique_id not in self.previews_being_fetched:
             #check if preview should be from a downloaded file, or the source
@@ -711,13 +716,13 @@ class ThumbnailDisplay(gtk.IconView):
             else:
                 file_location = rpd_file.full_file_name
                 thm_file_name = rpd_file.thm_full_name
-                
+
             self.preview_manager.get_preview(unique_id, file_location,
                                             thm_file_name,
                                             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)
@@ -734,31 +739,31 @@ class ThumbnailDisplay(gtk.IconView):
                 path = 0
             iter = self.liststore.get_iter(path)
             unique_id = self.get_unique_id_from_iter(iter)
-            
-            
-        rpd_file = self.rpd_files[unique_id]    
-        
+
+
+        rpd_file = self.rpd_files[unique_id]
+
         if unique_id in self.previews:
             preview_image = self.previews[unique_id]
         else:
             # request daemon process to get a full size thumbnail
             self._get_preview(unique_id, rpd_file)
-            if unique_id in self.thumbnails:    
+            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, 
+        self.rapid_app.show_preview_image(unique_id, preview_image,
                                             include_checkbutton_visible, checked)
-            
+
     def _get_next_iter(self, iter):
         iter = self.liststore.iter_next(iter)
         if iter is None:
             iter = self.liststore.get_iter_first()
         return iter
-        
+
     def _get_prev_iter(self, iter):
         row = self.liststore.get_path(iter)[0]
         if row == 0:
@@ -766,44 +771,44 @@ class ThumbnailDisplay(gtk.IconView):
         else:
             row -= 1
         iter = self.liststore.get_iter(row)
-        return iter        
-    
+        return iter
+
     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)
-            
+
             # cache next image
             self.advance_get_preview_image(iter, prev=False, next=True)
-            
+
     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)
-            
+
             # cache next image
             self.advance_get_preview_image(iter, prev=True, next=False)
 
-            
+
     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))
-            
+
         if prev:
             prev_iter = self._get_prev_iter(iter)
             unique_ids.append(self.get_unique_id_from_iter(prev_iter))
-            
+
         for unique_id in unique_ids:
             if not unique_id in self.previews:
                 rpd_file = self.rpd_files[unique_id]
                 self._get_preview(unique_id, rpd_file)
-            
+
     def check_all(self, check_all, file_type=None):
         for row in self.liststore:
             if row[self.CHECKBUTTON_VISIBLE_COL]:
@@ -813,7 +818,7 @@ class ThumbnailDisplay(gtk.IconView):
                 else:
                     row[self.SELECTED_COL] = check_all
         self.rapid_app.set_download_action_sensitivity()
-            
+
     def files_are_checked_to_download(self):
         """
         Returns True if there is any file that the user has indicated they
@@ -825,12 +830,12 @@ class ThumbnailDisplay(gtk.IconView):
                 if rpd_file.status not in DOWNLOADED:
                     return True
         return False
-        
+
     def get_files_checked_for_download(self, scan_pid):
         """
         Returns a dict of scan ids and associated files the user has indicated
         they want to download
-        
+
         If scan_pid is not None, then returns only those files from that scan_pid
         """
         files = dict()
@@ -853,7 +858,7 @@ class ThumbnailDisplay(gtk.IconView):
                     if self.liststore.get_value(iter, self.SELECTED_COL):
                         files[scan_pid].append(rpd_file)
         return files
-                
+
     def get_no_files_remaining(self, scan_pid):
         """
         Returns the number of files that have not yet been downloaded for the
@@ -865,17 +870,17 @@ class ThumbnailDisplay(gtk.IconView):
             if rpd_file.status == STATUS_NOT_DOWNLOADED:
                 i += 1
         return i
-        
+
     def files_remain_to_download(self):
         """
-        Returns True if any files remain that are not downloaded, else returns 
+        Returns True if any files remain that are not downloaded, else returns
         False
         """
         for row in self.liststore:
             if row[self.DOWNLOAD_STATUS_COL] == STATUS_NOT_DOWNLOADED:
                 return True
         return False
-            
+
 
     def mark_download_pending(self, files_by_scan_pid):
         """
@@ -895,19 +900,19 @@ class ThumbnailDisplay(gtk.IconView):
                 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
         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)
@@ -915,7 +920,7 @@ class ThumbnailDisplay(gtk.IconView):
         self.liststore.set_value(iter, self.STATUS_ICON_COL, icon)
         self.liststore.set_value(iter, self.CHECKBUTTON_VISIBLE_COL, False)
         self.rpd_files[rpd_file.unique_id] = rpd_file
-            
+
     def generate_thumbnails(self, scan_pid):
         """Initiate thumbnail generation for files scanned in one process
         """
@@ -923,81 +928,81 @@ class ThumbnailDisplay(gtk.IconView):
             rpd_files = [self.rpd_files[unique_id] for unique_id in self.process_index[scan_pid]]
             thumbnail_pid = self.thumbnail_manager.add_task((scan_pid, rpd_files))
             self.generating_thumbnails[scan_pid] = thumbnail_pid
-    
+
     def _set_thumbnail(self, unique_id, icon):
         treerowref = self.treerow_index[unique_id]
         path = treerowref.get_path()
         iter = self.liststore.get_iter(path)
-        self.liststore.set(iter, 0, icon)        
-    
+        self.liststore.set(iter, 0, icon)
+
     def update_thumbnail(self, thumbnail_data):
         """
         Takes the generated thumbnail and updates the display
-        
+
         If the thumbnail_data includes a second image, that is used to
         update the thumbnail list using the unique_id
         """
         unique_id = thumbnail_data[0]
         thumbnail_icon = thumbnail_data[1]
-        
+
         if thumbnail_icon is not None:
             # get the thumbnail icon in PIL format
             thumbnail_icon = thumbnail_icon.get_image()
-            
+
             if thumbnail_icon:
                 self._set_thumbnail(unique_id, thumbnail_icon)
-                
+
             if len(thumbnail_data) > 2:
                 # get the 2nd image in PIL format
                 self.thumbnails[unique_id] = thumbnail_data[2].get_image()
 
     def terminate_thumbnail_generation(self, scan_pid):
         """
-        Terminates thumbnail generation if thumbnails are currently 
+        Terminates thumbnail generation if thumbnails are currently
         being generated for this scan_pid
         """
-        
+
         if scan_pid in self.generating_thumbnails:
             terminated = True
             self.thumbnail_manager.terminate_process(
                                         self.generating_thumbnails[scan_pid])
             del self.generating_thumbnails[scan_pid]
-            
+
             if len(self.generating_thumbnails) == 0:
                 self._reset_thumbnail_tracking_and_display()
         else:
             terminated = False
-            
+
         return terminated
-                
+
     def mark_thumbnails_needed(self, rpd_files):
         for rpd_file in rpd_files:
             if rpd_file.unique_id not in self.thumbnails:
                 rpd_file.generate_thumbnail = True
-        
+
     def _reset_thumbnail_tracking_and_display(self):
         self.rapid_app.download_progressbar.set_fraction(0.0)
         self.rapid_app.download_progressbar.set_text('')
         self.thumbnails_generated = 0
         self.total_thumbs_to_generate = 0
-    
+
     def thumbnail_results(self, source, condition):
         connection = self.thumbnail_manager.get_pipe(source)
-        
+
         conn_type, data = connection.recv()
-        
+
         if conn_type == rpdmp.CONN_COMPLETE:
             scan_pid = data
             del self.generating_thumbnails[scan_pid]
             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_thumbs_to_generate:
@@ -1006,10 +1011,10 @@ class ThumbnailDisplay(gtk.IconView):
                 if self.total_thumbs_to_generate:
                     self.rapid_app.download_progressbar.set_fraction(
                         float(self.thumbnails_generated) / self.total_thumbs_to_generate)
-            
-        
+
+
         return True
-        
+
     def preview_results(self, unique_id, preview_full_size, preview_small):
         """
         Receive a full size preview image and update
@@ -1019,24 +1024,24 @@ class ThumbnailDisplay(gtk.IconView):
             preview_image = preview_full_size.get_image()
             self.previews[unique_id] = preview_image
             self.rapid_app.update_preview_image(unique_id, preview_image)
-            
+
             # user can turn off option for thumbnail generation after a scan
             if unique_id not in self.thumbnails and preview_small is not None:
                 self._set_thumbnail(unique_id, preview_small.get_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.
-        
+
         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:
-            
+
             # Here it is critically important to create a brand new liststore,
             # because the old one is set to be sorted, which is extremely slow.
             logger.debug("Creating new thumbnails model")
@@ -1045,7 +1050,7 @@ class ThumbnailDisplay(gtk.IconView):
 
             self.treerow_index = {}
             self.process_index = {}
-            
+
             self.rpd_files = {}
         else:
             if scan_pid in self.process_index:
@@ -1060,80 +1065,80 @@ class ThumbnailDisplay(gtk.IconView):
                         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]
-                    
+
     def display_thumbnails(self):
         self.set_model(self.liststore)
-    
+
 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
         self.no_tasks = 0
-       
-    
+
+
     def add_task(self, task):
         pid = self._setup_task(task)
         logger.debug("TaskManager PID: %s", pid)
         self.no_tasks += 1
         return pid
 
-        
+
     def _setup_task(self, task):
         task_results_conn, task_process_conn = self._setup_pipe()
-        
+
         source = task_results_conn.fileno()
         self._pipes[source] = task_results_conn
         gobject.io_add_watch(source, gobject.IO_IN, self.results_callback)
-        
+
         terminate_queue = Queue()
         run_event = Event()
         run_event.set()
-        
-        return self._initiate_task(task, task_results_conn, task_process_conn, 
+
+        return self._initiate_task(task, task_results_conn, task_process_conn,
                                    terminate_queue, run_event)
-        
+
     def _setup_pipe(self):
         return Pipe(duplex=False)
-        
+
     def _initiate_task(self, task, task_process_conn, terminate_queue, run_event):
         logger.error("Implement child class method!")
-        
-    
+
+
     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 _terminate_process(self, p):
         self._send_termination_msg(p)
         # The process might be paused: let it run
         run_event = p[2]
         if not run_event.is_set():
             run_event.set()
-            
+
     def _send_termination_msg(self, p):
         p[1].put(None)
-    
+
     def terminate_process(self, process_id):
         """
         Send a signal to process with matching process_id that it should
@@ -1143,7 +1148,7 @@ class TaskManager:
             if p[0].pid == process_id:
                 if p[0].is_alive():
                     self._terminate_process(p)
-    
+
     def request_termination(self):
         """
         Send a signal to processes that they should immediately terminate
@@ -1153,29 +1158,29 @@ class TaskManager:
             if p[0].is_alive():
                 requested = True
                 self._terminate_process(p)
-                    
+
         return requested
-    
+
     def terminate_forcefully(self):
         """
         Forcefully terminates any running processes. Use with great caution.
-        No cleanup action is performed. 
-        
+        No cleanup action is performed.
+
         As python essential reference (4th edition) says, if the process
         'holds a lock or is involved with interprocess communication,
         terminating it might cause a deadlock or corrupted I/O.'
         """
-        
+
         for p in self.processes():
             if p[0].is_alive():
-                logger.info("Forcefully terminating %s in %s" , p[0].name, 
+                logger.info("Forcefully terminating %s in %s" , p[0].name,
                                                 self.__class__.__name__)
                 p[0].terminate()
 
-            
+
     def get_pipe(self, source):
         return self._pipes[source]
-        
+
     def get_no_active_processes(self):
         """
         Returns how many processes are currently active, i.e. running
@@ -1188,38 +1193,38 @@ class TaskManager:
 
 
 class ScanManager(TaskManager):
-    
-    def __init__(self, results_callback, batch_size, 
+
+    def __init__(self, results_callback, batch_size,
                  add_device_function):
         TaskManager.__init__(self, results_callback, batch_size)
         self.add_device_function = add_device_function
-        
-    def _initiate_task(self, task, task_results_conn, task_process_conn, 
+
+    def _initiate_task(self, task, task_results_conn, task_process_conn,
                        terminate_queue, run_event):
-        
+
         device = task[0]
         ignored_paths = task[1]
         use_re_ignored_paths = task[2]
-        
+
         scan = scan_process.Scan(device.get_path(),
                                 ignored_paths,
                                 use_re_ignored_paths,
-                                self.batch_size, 
+                                self.batch_size,
                                 task_process_conn, terminate_queue, run_event)
         scan.start()
         self._processes.append((scan, terminate_queue, run_event))
-        self.add_device_function(scan.pid, device, 
+        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 
+            # 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_results_conn, 
+
+    def _initiate_task(self, task, task_results_conn,
                        task_process_conn, terminate_queue, run_event):
         photo_download_folder = task[0]
         video_download_folder = task[1]
@@ -1227,25 +1232,25 @@ class CopyFilesManager(TaskManager):
         files = task[3]
         modify_files_during_download = task[4]
         modify_pipe = task[5]
-        
+
         copy_files = copyfiles.CopyFiles(photo_download_folder,
                                 video_download_folder,
-                                files, 
+                                files,
                                 modify_files_during_download,
                                 modify_pipe,
-                                scan_pid, self.batch_size, 
+                                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
-        
+
 class ThumbnailManager(TaskManager):
     def _initiate_task(self, task, task_results_conn,
                        task_process_conn, terminate_queue, run_event):
         scan_pid = task[0]
         files = task[1]
-        generator = tn.GenerateThumbnails(scan_pid, files, self.batch_size, 
-                                          task_process_conn, terminate_queue, 
+        generator = tn.GenerateThumbnails(scan_pid, files, self.batch_size,
+                                          task_process_conn, terminate_queue,
                                           run_event)
         generator.start()
         self._processes.append((generator, terminate_queue, run_event))
@@ -1256,44 +1261,44 @@ class FileModifyManager(TaskManager):
     Duplex, multiprocess, similar to BackupFilesManager
     """
     def __init__(self, results_callback):
-        TaskManager.__init__(self, results_callback=results_callback, 
+        TaskManager.__init__(self, results_callback=results_callback,
                             batch_size=0)
         self.file_modify_by_scan_pid = {}
-                            
-    def _initiate_task(self, task, task_results_conn, task_process_conn, 
+
+    def _initiate_task(self, task, task_results_conn, task_process_conn,
                        terminate_queue, run_event):
         scan_pid = task[0]
         auto_rotate_jpeg = task[1]
         focal_length = task[2]
-        
+
         file_modify = filemodify.FileModify(auto_rotate_jpeg, focal_length,
-                                        task_process_conn, terminate_queue, 
+                                        task_process_conn, terminate_queue,
                                         run_event)
         file_modify.start()
-        self._processes.append((file_modify, terminate_queue, run_event, 
+        self._processes.append((file_modify, terminate_queue, run_event,
                                 task_results_conn))
-                                
+
         self.file_modify_by_scan_pid[scan_pid] = (task_results_conn, file_modify.pid)
-        
+
         return file_modify.pid
 
     def _setup_pipe(self):
         return Pipe(duplex=True)
-        
+
     def _send_termination_msg(self, p):
         p[1].put(None)
         p[3].send((None, None))
-        
+
     def get_modify_pipe(self, scan_pid):
         return self.file_modify_by_scan_pid[scan_pid][0]
-        
-        
+
+
 class BackupFilesManager(TaskManager):
     """
     Handles backup processes. This is a little different from some other Task
     Manager classes in that its pipe is Duplex, and the work done by it
     is not pre-assigned when the process is started.
-    
+
     Duplex, multiprocess.
     """
     def __init__(self, results_callback, batch_size):
@@ -1302,30 +1307,31 @@ class BackupFilesManager(TaskManager):
 
     def _setup_pipe(self):
         return Pipe(duplex=True)
-        
+
     def _send_termination_msg(self, p):
         p[1].put(None)
-        p[3].send((None, None, None, None))
-        
-    def _initiate_task(self, task, task_results_conn, task_process_conn, 
+        p[3].send((None, None, None, None, None))
+
+    def _initiate_task(self, task, task_results_conn, task_process_conn,
                        terminate_queue, run_event):
         path = task[0]
         name = task[1]
         backup_type = task[2]
-        backup_files = backupfile.BackupFiles(path, name, self.batch_size, 
-                                        task_process_conn, terminate_queue, 
+        backup_files = backupfile.BackupFiles(path, name, self.batch_size,
+                                        task_process_conn, terminate_queue,
                                         run_event)
         backup_files.start()
-        self._processes.append((backup_files, terminate_queue, run_event, 
+        self._processes.append((backup_files, terminate_queue, run_event,
                                 task_results_conn))
-        
+
         self.backup_devices_by_path[path] = (task_results_conn, backup_files.pid,
                                             backup_type)
-        
+
         return backup_files.pid
-        
-    def backup_file(self, move_succeeded, rpd_file, path_suffix, 
-                                                backup_duplicate_overwrite):
+
+    def backup_file(self, move_succeeded, rpd_file, path_suffix,
+                                                backup_duplicate_overwrite,
+                                                download_count):
 
         if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
             logger.debug("Backing up photo %s", rpd_file.download_name)
@@ -1334,124 +1340,124 @@ class BackupFilesManager(TaskManager):
 
         for path in self.backup_devices_by_path:
             backup_type = self.backup_devices_by_path[path][2]
-            if ((backup_type == PHOTO_VIDEO_BACKUP) or 
+            if ((backup_type == PHOTO_VIDEO_BACKUP) or
                     (rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO and backup_type == PHOTO_BACKUP) or
                     (rpd_file.file_type == rpdfile.FILE_TYPE_VIDEO and backup_type == VIDEO_BACKUP)):
                 logger.debug("Backing up to %s", path)
                 task_results_conn = self.backup_devices_by_path[path][0]
-                task_results_conn.send((move_succeeded, rpd_file, path_suffix, 
-                                    backup_duplicate_overwrite))
+                task_results_conn.send((move_succeeded, rpd_file, path_suffix,
+                                    backup_duplicate_overwrite, download_count))
             else:
                 logger.debug("Not backing up to %s", path)
-            
+
     def add_device(self, path, name, backup_type):
         """
         Convenience function to setup adding a backup device
         """
         return self.add_task((path, name, backup_type))
-    
+
     def remove_device(self, path):
         pid = self.backup_devices_by_path[path][1]
         self.terminate_process(pid)
         del self.backup_devices_by_path[path]
-        
-                
+
+
 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):    
+    def __init__(self, results_callback):
         self.results_callback = results_callback
-        
+
         self.task_results_conn, self.task_process_conn = Pipe(duplex=True)
-        
+
         source = self.task_results_conn.fileno()
         gobject.io_add_watch(source, gobject.IO_IN, self.task_results)
 
-        
+
 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()
-        
+
     def get_preview(self, unique_id, full_file_name, thm_file_name, file_type, size_max):
         self.task_results_conn.send((unique_id, full_file_name, thm_file_name, file_type, size_max))
-        
+
     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 
-        
+        return True
+
 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, 
+        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, 
+
+    def rename_file_and_move_to_subfolder(self, download_succeeded,
             download_count, rpd_file):
-                                              
-        self.task_results_conn.send((download_succeeded, download_count, 
+
+        logger.debug("Sending file for rename: %s.", download_count)
+        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)
+        move_succeeded, rpd_file, download_count = self.task_results_conn.recv()
+        self.results_callback(move_succeeded, rpd_file, download_count)
         return True
-        
+
 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)
-        
+
     def set_image(self, image):
         self.base_image = image
-        
+
         #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
-        
+
         self.queue_draw()
-        
+
     def expose(self, widget, event):
 
         cairo_context = self.window.cairo_create()
-        
-        x = event.area.x 
-        y = event.area.y 
+
+        x = event.area.x
+        y = event.area.y
         w = event.area.width
         h = event.area.height
-        
-        #constrain operations to event area 
+
+        #constrain operations to event area
         cairo_context.rectangle(x, y, w, h)
         cairo_context.clip_preserve()
-        
+
         #set background color, if needed
         if self.bg_color:
             cairo_context.set_source_rgb(*self.bg_color)
-            cairo_context.fill_preserve()        
+            cairo_context.fill_preserve()
 
         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
@@ -1460,7 +1466,7 @@ class ResizblePilImage(gtk.DrawingArea):
             # Frame is taller than image
             width = w
             height = int(width / self.base_image_aspect)
-            
+
         #resize image
         pil_image = self.base_image.copy()
         if self.base_image_w < width or self.base_image_h < height:
@@ -1473,38 +1479,38 @@ class ResizblePilImage(gtk.DrawingArea):
         #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()        
+        cairo_context.paint()
+
+        return False
+
 
-        return False    
-        
-        
 
 class PreviewImage:
-    
+
     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 = 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
-        
+
         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 set_preview_image(self, unique_id, pil_image, include_checkbutton_visible=None, 
+
+    def set_preview_image(self, unique_id, pil_image, include_checkbutton_visible=None,
                           checked=None):
         """
         """
@@ -1516,72 +1522,74 @@ class PreviewImage:
 
         if include_checkbutton_visible is not None:
             self.download_this_checkbutton.props.visible = include_checkbutton_visible
-        
+
     def update_preview_image(self, unique_id, pil_image):
         if unique_id == self.unique_id:
             self.set_preview_image(unique_id, pil_image)
 
-        
+
 class RapidApp(dbus.service.Object):
     """
     The main Rapid Photo Downloader application class.
-    
+
     Contains functionality for main program window, and directs all other
     processes.
     """
-     
+
     def __init__(self,  bus, path, name, taskserver=None, focal_length=None,
-    auto_detect=None, device_location=None): 
-        
+    auto_detect=None, device_location=None):
+
         dbus.service.Object.__init__ (self, bus, path, name)
         self.running = False
-        
+
         self.taskserver = taskserver
-        
+
         self.focal_length = focal_length
-        
+
         # Setup program preferences, and set callback for when they change
         self._init_prefs(auto_detect, device_location)
-        
+
         # Initialize widgets in the main window, and variables that point to them
         self._init_widgets()
-        self._init_pynotify()
-        
+
+        if use_pynotify:
+            self._init_pynotify()
+
         # Initialize job code handling
         self._init_job_code()
-        
+
         # Remember the window size from the last time the program was run, or
         # set a default size
         self._set_window_size()
-        
+
         # Setup various widgets
         self._setup_buttons()
         self._setup_error_icons()
         self._setup_icons()
-            
+
         # Show the main window
         self.rapidapp.show()
-        
+
         # Check program preferences - don't allow auto start if there is a problem
         prefs_valid, msg = prefsrapid.check_prefs_for_validity(self.prefs)
         if not prefs_valid:
             self.notify_prefs_are_invalid(details=msg)
-        
+
         # 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()
-        
+
         # Setup devices from which to download from and backup to
-        self.setup_devices(on_startup=True, on_preference_change=False, 
+        self.setup_devices(on_startup=True, on_preference_change=False,
                            block_auto_start=not prefs_valid)
-        
+
         # Ensure the device collection scrolled window is not too small
         self._set_device_collection_size()
-    
+
     def on_rapidapp_destroy(self, widget, data=None):
 
         self._terminate_processes(terminate_file_copies = True)
@@ -1592,30 +1600,30 @@ class RapidApp(dbus.service.Object):
         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):
-        
+
         if terminate_file_copies:
             logger.info("Terminating all processes...")
 
-        scan_termination_requested = self.scan_manager.request_termination()        
+        scan_termination_requested = self.scan_manager.request_termination()
         thumbnails_termination_requested = self.thumbnails.thumbnail_manager.request_termination()
         backup_termination_requested = self.backup_manager.request_termination()
         file_modify_termination_requested = self.file_modify_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 or
                 backup_termination_requested or file_modify_termination_requested):
             time.sleep(1)
-            if (self.scan_manager.get_no_active_processes() > 0 or 
+            if (self.scan_manager.get_no_active_processes() > 0 or
                 self.thumbnails.thumbnail_manager.get_no_active_processes() > 0 or
                 self.backup_manager.get_no_active_processes() > 0 or
                 self.file_modify_manager.get_no_active_processes() > 0):
@@ -1626,14 +1634,14 @@ class RapidApp(dbus.service.Object):
                 self.scan_manager.terminate_forcefully()
                 self.backup_manager.terminate_forcefully()
                 self.file_modify_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
     # # #
@@ -1642,61 +1650,61 @@ class RapidApp(dbus.service.Object):
         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()    
-    
+            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, 
+        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, 
+        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.thumbnails.clear_all()
         self.setup_devices(on_startup=False, on_preference_change=False,
                            block_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.hide()
-        
+
     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")
@@ -1704,26 +1712,26 @@ class RapidApp(dbus.service.Object):
         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)
-        
-        
+
+
     def on_next_image_action_activate(self, action):
         if self.preview_image.unique_id is not None:
             self.thumbnails.show_next_image(self.preview_image.unique_id)
-    
+
     def on_prev_image_action_activate(self, action):
-        if self.preview_image.unique_id is not None:        
+        if self.preview_image.unique_id is not None:
             self.thumbnails.show_prev_image(self.preview_image.unique_id)
-        
+
     def display_scan_thumbnails(self):
         """
         If all the scans are complete, sets the sort order and displays
@@ -1737,35 +1745,36 @@ class RapidApp(dbus.service.Object):
     # # #
     # 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) 
-    
-    
+            self.vmonitor.connect("mount-removed", self.on_mount_removed)
+
+
     def _backup_device_name(self, path):
         if self.backup_devices[path][0] is None:
             name = path
         else:
             name = self.backup_devices[path][0].get_name()
         return name
-        
+
     def start_device_scan(self, device):
         """
-        Commences the scanning of a device using the preference values for 
+        Commences the scanning of a device using the preference values for
         any paths to ignore while scanning
         """
-        return self.scan_manager.add_task([device, 
+        logger.debug("Starting a device scan for device %s", device.get_name())
+        return self.scan_manager.add_task([device,
                                           self.prefs.ignored_paths,
                                           self.prefs.use_re_ignored_paths])
-        
+
     def confirm_manual_location(self):
         """
-        Queries the user to ask if they really want to download from locations 
+        Queries the user to ask if they really want to download from locations
         that could take a very long time to scan. They can choose yes or no.
-        
+
         Returns True if yes or there was no need to ask the user, False if the
         user said no.
         """
@@ -1781,34 +1790,34 @@ class RapidApp(dbus.service.Object):
                     question="<b>" + _("Downloading from %(location)s.") %  {'location': l} + "</b>\n\n" +
                     _("Do you really want to download from here? On some systems, scanning this location can take a very long time."),
                     default_to_yes=False,
-                    use_markup=True)        
+                    use_markup=True)
             response = c.run()
             user_confirmed = response == gtk.RESPONSE_OK
             c.destroy()
             if not user_confirmed:
                 return False
         return True
-    
+
     def setup_devices(self, on_startup, on_preference_change, block_auto_start):
         """
-        
+
         Setup devices from which to download from and backup to
-        
+
         Sets up volumes for downloading from and backing up to
-        
-        on_startup should be True if the program is still starting, 
+
+        on_startup should be True if the program is still starting,
         i.e. this is being called from the program's initialization.
-        
+
         on_preference_change should be True if this is being called as the
         result of a preference being changed
-        
+
         block_auto_start should be True if automation options to automatically
         start a download should be ignored
-        
-        Removes any image media that are currently not downloaded, 
-        or finished downloading        
+
+        Removes any image media that are currently not downloaded,
+        or finished downloading
         """
-        
+
         if self.using_volume_monitor():
             self.start_volume_monitor()
 
@@ -1816,10 +1825,10 @@ class RapidApp(dbus.service.Object):
         if not self.prefs.device_autodetection:
             if not self.confirm_manual_location():
                 return
-            
+
         mounts = []
         self.backup_devices = {}
-        
+
         if self.using_volume_monitor():
             # either using automatically detected backup devices
             # or download devices
@@ -1827,7 +1836,7 @@ class RapidApp(dbus.service.Object):
                 if not mount.is_shadowed():
                     path = mount.get_root().get_path()
                     if path:
-                        if (path in self.prefs.device_blacklist and 
+                        if (path in self.prefs.device_blacklist and
                                     self.search_for_PSD()):
                             logger.info("%s ignored", mount.get_name())
                         else:
@@ -1835,17 +1844,17 @@ class RapidApp(dbus.service.Object):
                             is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
                             if is_backup_mount:
                                 self.backup_devices[path] = (mount, backup_file_type)
-                            elif (self.prefs.device_autodetection and 
-                                 (dv.is_DCIM_device(path) or 
+                            elif (self.prefs.device_autodetection and
+                                 (dv.is_DCIM_device(path) or
                                   self.search_for_PSD())):
                                 logger.debug("Appending %s", mount.get_name())
                                 mounts.append((path, mount))
                             else:
                                 logger.debug("Ignoring %s", mount.get_name())
-                    
-        
+
+
         if not self.prefs.device_autodetection:
-            # user manually specified the path from which to download 
+            # user manually specified the path from which to download
             path = self.prefs.device_location
             if path:
                 logger.info("Using manually specified path %s", path)
@@ -1858,35 +1867,47 @@ class RapidApp(dbus.service.Object):
             if not self.prefs.backup_device_autodetection:
                 self._setup_manual_backup()
             self._add_backup_devices()
-                
+
         self.update_no_backup_devices()
-        
+
         # Display amount of free space in a status bar message
         self.display_free_space()
-        
+
         if block_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_at_startup and
+                                      on_startup) or
                                       (self.prefs.auto_download_upon_device_insertion and
                                        not on_startup)))
-        
+
+        logger.debug("Working with %s devices", len(mounts))
         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.start_device_scan(device)
-                if mount is not None:
-                    self.mounts_by_path[path] = scan_pid
+
+
+            if not self._device_already_detected(device):
+                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.start_device_scan(device)
+                    if mount is not None:
+                        self.mounts_by_path[path] = scan_pid
         if not mounts:
             self.set_download_action_sensitivity()
-        
+
+    def _device_already_detected(self, device):
+        path = device.get_path()
+        if path in self.mounts_by_path:
+            logger.debug("Ignoring device %s as already have path %s", device.get_name(), path)
+            return True
+        else:
+            return False
+
     def _setup_manual_backup(self):
         """
         Setup backup devices that the user has manually specified.
@@ -1894,8 +1915,8 @@ class RapidApp(dbus.service.Object):
         video backup will either be the same or they will differ.
         """
         # user manually specified backup locations
-        # will backup to these paths, but don't need any volume info 
-        # associated with them        
+        # will backup to these paths, but don't need any volume info
+        # associated with them
         self.backup_devices[self.prefs.backup_location] = (None, PHOTO_BACKUP)
         if DOWNLOAD_VIDEO:
             if self.prefs.backup_location <> self.prefs.backup_video_location:
@@ -1908,7 +1929,7 @@ class RapidApp(dbus.service.Object):
                 logger.info("Backing up photos and videos to %s", self.prefs.backup_location)
         else:
             logger.info("Backing up photos to %s", self.prefs.backup_location)
-            
+
     def _add_backup_devices(self):
         """
         Add each backup devices / path to backup manager
@@ -1917,20 +1938,28 @@ class RapidApp(dbus.service.Object):
             name = self._backup_device_name(path)
             backup_type = self.backup_devices[path][1]
             self.backup_manager.add_device(path, name, backup_type)
-        
-        
-    def get_use_device(self, device):  
+
+
+    def get_use_device(self, device):
         """ Prompt user whether or not to download from this device """
-        
+
         logger.info("Prompting whether to use %s", device.get_name())
+
+        # On some systems, e.g. Ubuntu 12.10, the GTK/Gnome environment
+        # unexpectedly results in a device being added twice and not once.
+        # The hack on the next line ensures the user is not prompted twice
+        # for the same device.
+
+        self.mounts_by_path[device.get_path()] = "PROMPTING"
+
         d = dv.UseDeviceDialog(self.rapidapp, device, self.got_use_device)
-        
+
     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()
-        
+
         path = device.get_path()
-        
+
         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,
@@ -1941,37 +1970,37 @@ class RapidApp(dbus.service.Object):
                     self.prefs.device_whitelist = [path]
             scan_pid = self.start_device_scan(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]    
-     
+                self.prefs.device_blacklist = [path]
+
     def search_for_PSD(self):
         """
-        Check to see if user preferences are to automatically search for 
+        Check to see if user preferences are to automatically search for
         Portable Storage Devices or not
         """
         return self.prefs.device_autodetection_psd and self.prefs.device_autodetection
 
     def check_if_backup_mount(self, path):
         """
-        Checks to see if backups are enabled and path represents a valid backup 
+        Checks to see if backups are enabled and path represents a valid backup
         location. It must be writeable.
-        
+
         Checks against user preferences.
-        
+
         Returns a tuple:
         (True, <backup-type> (one of PHOTO_VIDEO_BACKUP, PHOTO_BACKUP, or VIDEO_BACKUP)) or
-        (False, None) 
+        (False, None)
         """
         if self.prefs.backup_images:
             if self.prefs.backup_device_autodetection:
-                # Determine if the auto-detected backup device is 
+                # Determine if the auto-detected backup device is
                 # to be used to backup only photos, or videos, or both.
-                # Use the presence of a corresponding directory to 
+                # Use the presence of a corresponding directory to
                 # determine this.
                 # The directory must be writable.
                 photo_path = os.path.join(path, self.prefs.backup_identifier)
@@ -1991,7 +2020,7 @@ class RapidApp(dbus.service.Object):
                     logger.info("Videos will be backed up to %s", path)
                     return (True, VIDEO_BACKUP)
             elif path == self.prefs.backup_location:
-                # user manually specified the path    
+                # user manually specified the path
                 if os.access(self.prefs.backup_location, os.W_OK):
                     return (True, PHOTO_BACKUP)
             elif path == self.prefs.backup_video_location:
@@ -2013,22 +2042,22 @@ class RapidApp(dbus.service.Object):
                 #both videos and photos are backed up to this device / path
                 self.no_photo_backup_devices += 1
                 self.no_video_backup_devices += 1
-        logger.info("# photo backup devices: %s; # video backup devices: %s", 
+        logger.info("# photo backup devices: %s; # video backup devices: %s",
                     self.no_photo_backup_devices, self.no_video_backup_devices)
-        self.download_tracker.set_no_backup_devices(self.no_photo_backup_devices, 
+        self.download_tracker.set_no_backup_devices(self.no_photo_backup_devices,
                                                     self.no_video_backup_devices)
 
     def refresh_backup_media(self):
         """
         Setup the backup media
-        
-        Assumptions: this is being called after the user has changed their 
+
+        Assumptions: this is being called after the user has changed their
         preferences AND download media has already been setup
         """
-        
+
         # terminate any running backup processes
         self.backup_manager.request_termination()
-        
+
         self.backup_devices = {}
         if self.prefs.backup_images:
             if not self.prefs.backup_device_autodetection:
@@ -2043,22 +2072,22 @@ class RapidApp(dbus.service.Object):
                                 # is a backup volume
                                 if path not in self.backup_devices:
                                     self.backup_devices[path] = (mount, backup_file_type)
-            
+
             self._add_backup_devices()
 
         self.update_no_backup_devices()
         self.display_free_space()
-            
+
     def using_volume_monitor(self):
         """
         Returns True if programs needs to use gio volume monitor
         """
-        
-        return (self.prefs.device_autodetection or 
-                (self.prefs.backup_images and 
+
+        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
@@ -2069,7 +2098,7 @@ class RapidApp(dbus.service.Object):
         if mount.is_shadowed():
             # ignore this type of mount
             return
-            
+
         path = mount.get_root().get_path()
         if path is not None:
 
@@ -2078,7 +2107,7 @@ class RapidApp(dbus.service.Object):
                             'device': mount.get_name(), 'path': path})
             else:
                 is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
-                            
+
                 if is_backup_mount:
                     if path not in self.backup_devices:
                         self.backup_devices[path] = mount
@@ -2087,84 +2116,86 @@ class RapidApp(dbus.service.Object):
                         self.update_no_backup_devices()
                         self.display_free_space()
 
-                elif self.prefs.device_autodetection and (dv.is_DCIM_device(path) or 
+                elif self.prefs.device_autodetection and (dv.is_DCIM_device(path) or
                                                             self.search_for_PSD()):
-                    
+
                     self.auto_start_is_on = self.prefs.auto_download_upon_device_insertion
                     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.start_device_scan(device)
-                        self.mounts_by_path[path] = scan_pid
-            
+
+                    if not self._device_already_detected(device):
+                        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.start_device_scan(device)
+                            self.mounts_by_path[path] = scan_pid
+
     def on_mount_removed(self, vmonitor, mount):
         """
         callback run when gio indicates a new volume
         has been mounted
         """
-        
+
         path = mount.get_root().get_path()
 
         # three scenarios -
         # the mount has been scanned but downloading has not yet started
         # files are being downloaded from mount (it must be a messy unmount)
         # files have finished downloading from mount
-        
+
         if path in self.mounts_by_path:
             scan_pid = self.mounts_by_path[path]
             del self.mounts_by_path[path]
             # temp directory should be cleaned by finishing of process
-            
-            self.thumbnails.clear_all(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()
             self.backup_manager.remove_device(path)
             self.update_no_backup_devices()
-                
+
         # 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
         """
-        
+
         # Stop any processes currently scanning or creating thumbnails
         self._terminate_processes(terminate_file_copies=False)
-        
+
         # Remove them from the user interface
         for scan_pid in self.device_collection.get_all_displayed_processes():
             if scan_pid not in self.download_active_by_scan_pid:
                 self.device_collection.remove_device(scan_pid)
                 self.thumbnails.clear_all(scan_pid=scan_pid)
-            
-        
 
-    
+
+
+
     # # #
     # Download and help buttons, and menu items
     # # #
-    
+
     def on_download_action_activate(self, action):
         """
         Called when a download is activated
         """
-        
+
         if self.copy_files_manager.paused:
             logger.debug("Download resumed")
             self.resume_download()
         else:
             logger.debug("Download activated")
-            
+
             if self.download_action_is_download:
                 if self.need_job_code_for_naming and not self.prompting_for_job_code:
                     self.get_job_code()
@@ -2173,18 +2204,18 @@ class RapidApp(dbus.service.Object):
             else:
                 self.pause_download()
 
-    
+
     def on_help_action_activate(self, action):
         webbrowser.open("http://www.damonlynch.net/rapid/documentation")
-        
+
     def on_preferences_action_activate(self, action):
 
         preferencesdialog.PreferencesDialog(self)
-        
+
     def set_download_action_sensitivity(self):
         """
         Sets sensitivity of Download action to enable or disable it
-        
+
         Affects download button and menu item
         """
         if not self.download_is_occurring():
@@ -2192,26 +2223,26 @@ class RapidApp(dbus.service.Object):
             if self.scan_manager.no_tasks == 0:
                 if self.thumbnails.files_are_checked_to_download():
                     sensitivity = True
-                    
+
             self.download_action.set_sensitive(sensitivity)
-            
+
     def set_download_action_label(self, is_download):
         """
-        Toggles label betwen pause and download 
+        Toggles label betwen pause and download
         """
-        
+
         if is_download:
             self.download_action.set_label(_("Download"))
             self.download_action_is_download = True
         else:
             self.download_action.set_label(_("Pause"))
             self.download_action_is_download = False
-    
+
     # # #
     # Job codes
     # # #
-    
-    
+
+
     def _init_job_code(self):
         self.job_code = self.last_chosen_job_code = ''
         self.need_job_code_for_naming = self.prefs.any_pref_uses_job_code()
@@ -2219,64 +2250,64 @@ class RapidApp(dbus.service.Object):
 
     def assign_job_code(self, code):
         """ assign job code (which may be empty) to member variable and update user preferences
-        
+
         Update preferences only if code is not empty. Do not duplicate job code.
         """
 
         self.job_code = code
-        
+
         if code:
             #add this value to job codes preferences
             #delete any existing value which is the same
             #(this way it comes to the front, which is where it should be)
             #never modify self.prefs.job_codes in place! (or prefs become screwed up)
-            
+
             jcs = self.prefs.job_codes
             while code in jcs:
                 jcs.remove(code)
-                
+
             self.prefs.job_codes = [code] + jcs
 
     def _get_job_code(self, post_job_code_entry_callback):
         """ prompt for a job code """
-        
+
         if not self.prompting_for_job_code:
             logger.debug("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, 
+                    default_job_code = self.last_chosen_job_code,
                     post_job_code_entry_callback=post_job_code_entry_callback,
                     entry_only = False)
         else:
             logger.debug("Already prompting for Job Code, do not prompt again")
-        
+
     def get_job_code(self):
         self._get_job_code(self.got_job_code)
-        
+
     def got_job_code(self, dialog, user_chose_code, code):
         dialog.destroy()
         self.prompting_for_job_code = False
-        
+
         if user_chose_code:
             if code is None:
                 code = ''
             self.assign_job_code(code)
             self.last_chosen_job_code = code
             logger.debug("Job Code %s entered", self.job_code)
-            self.start_download() 
-                
+            self.start_download()
+
         else:
             # user cancelled
             logger.debug("No Job Code entered")
             self.job_code = ''
             self.auto_start_is_on = False
-   
-    
+
+
     # # #
     # Download
     # # #
-    
+
     def _init_download_tracking(self):
         """
         Initialize variables to track downloads
@@ -2285,28 +2316,28 @@ class RapidApp(dbus.service.Object):
         # (Scan id acts as an index to each device. A device could be scanned
         #  more than once).
         self.download_tracker = downloadtracker.DownloadTracker()
-        
+
         # Track which temporary directories are created when downloading files
         self.temp_dirs_by_scan_pid = dict()
-        
+
         # Track which downloads are running
         self.download_active_by_scan_pid = []
-        
+
     def modify_files_during_download(self):
         """ Returns True if there is a need to modify files during download"""
         return self.prefs.auto_rotate_jpeg or (self.focal_length is not None)
 
-    
+
     def start_download(self, scan_pid=None):
         """
         Start download, renaming and backup of files.
-        
+
         If scan_pid is specified, only files matching it will be downloaded
         """
-        
+
         files_by_scan_pid = self.thumbnails.get_files_checked_for_download(scan_pid)
         folders_valid, invalid_dirs = self.check_download_folder_validity(files_by_scan_pid)
-        
+
         if not folders_valid:
             if len(invalid_dirs) > 1:
                 msg = _("These download folders are invalid:\n%(folder1)s\n%(folder2)s") % {
@@ -2319,40 +2350,40 @@ class RapidApp(dbus.service.Object):
             # set time download is starting if it is not already set
             # it is unset when all downloads are completed
             if self.download_start_time is None:
-                self.download_start_time = datetime.datetime.now()  
+                self.download_start_time = datetime.datetime.now()
 
-            # Set status to download pending 
+            # Set status to download pending
             self.thumbnails.mark_download_pending(files_by_scan_pid)
-            
+
             # disable refresh and preferences change while download is occurring
             self.enable_prefs_and_refresh(enabled=False)
-            
+
             for scan_pid in files_by_scan_pid:
                 files = files_by_scan_pid[scan_pid]
                 # if generating thumbnails for this scan_pid, stop it
                 if self.thumbnails.terminate_thumbnail_generation(scan_pid):
                     self.thumbnails.mark_thumbnails_needed(files)
-                
+
                 self.download_files(files, scan_pid)
-                
+
             self.set_download_action_label(is_download = False)
-        
+
     def pause_download(self):
-        
+
         self.copy_files_manager.pause()
-        
+
         # set action to display Download
         if not self.download_action_is_download:
             self.set_download_action_label(is_download = True)
-            
+
         self.time_check.pause()
-            
+
     def resume_download(self):
         for scan_pid in self.download_active_by_scan_pid:
             self.time_remaining.set_time_mark(scan_pid)
-        
+
         self.time_check.set_download_mark()
-            
+
         self.copy_files_manager.start()
 
     def download_files(self, files, scan_pid):
@@ -2360,16 +2391,16 @@ class RapidApp(dbus.service.Object):
         Initiate downloading and renaming of files
         """
         # Check which file types will be downloaded for this particular process
-        no_photos_to_download = self.files_of_type_present(files, 
-                                                    rpdfile.FILE_TYPE_PHOTO, 
+        no_photos_to_download = self.files_of_type_present(files,
+                                                    rpdfile.FILE_TYPE_PHOTO,
                                                     return_file_count=True)
         if no_photos_to_download:
             photo_download_folder = self.prefs.download_folder
         else:
             photo_download_folder = None
-            
+
         if DOWNLOAD_VIDEO:
-            no_videos_to_download = self.files_of_type_present(files, 
+            no_videos_to_download = self.files_of_type_present(files,
                                         rpdfile.FILE_TYPE_VIDEO,
                                         return_file_count=True)
             if no_videos_to_download:
@@ -2379,30 +2410,30 @@ class RapidApp(dbus.service.Object):
         else:
             video_download_folder = None
             no_videos_to_download = 0
-        
+
         photo_download_size, video_download_size = self.size_files_to_be_downloaded(files)
-        self.download_tracker.init_stats(scan_pid=scan_pid, 
-                                photo_size_in_bytes=photo_download_size, 
+        self.download_tracker.init_stats(scan_pid=scan_pid,
+                                photo_size_in_bytes=photo_download_size,
                                 video_size_in_bytes=video_download_size,
                                 no_photos_to_download=no_photos_to_download,
                                 no_videos_to_download=no_videos_to_download)
-        
-        
+
+
         download_size = photo_download_size + video_download_size
-        
+
         if self.prefs.backup_images:
             download_size = download_size + ((self.no_photo_backup_devices * photo_download_size) +
                                              (self.no_video_backup_devices * video_download_size))
-            
+
         self.time_remaining.set(scan_pid, download_size)
         self.time_check.set_download_mark()
-            
+
         self.download_active_by_scan_pid.append(scan_pid)
-        
-        
+
+
         if len(self.download_active_by_scan_pid) > 1:
             self.display_summary_notification = True
-            
+
         if self.auto_start_is_on and self.prefs.generate_thumbnails:
             for rpd_file in files:
                 rpd_file.generate_thumbnail = True
@@ -2414,13 +2445,13 @@ class RapidApp(dbus.service.Object):
         else:
             modify_pipe = None
 
-            
+
         # Initiate copy files process
-        self.copy_files_manager.add_task((photo_download_folder, 
+        self.copy_files_manager.add_task((photo_download_folder,
                               video_download_folder, scan_pid,
                               files, modify_files_during_download,
                               modify_pipe))
-                              
+
     def copy_files_results(self, source, condition):
         """
         Handle results from copy files process
@@ -2434,7 +2465,7 @@ class RapidApp(dbus.service.Object):
             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)
-                
+
                 # Report which temporary directories are being used for this
                 # download
                 if photo_temp_dir and video_temp_dir:
@@ -2445,10 +2476,10 @@ class RapidApp(dbus.service.Object):
                                 photo_temp_dir)
                 else:
                     logger.debug("Using temp dir %s (videos)",
-                                video_temp_dir)                    
+                                video_temp_dir)
             elif msg_type == rpdmp.MSG_BYTES:
                 scan_pid, total_downloaded, chunk_downloaded = data
-                self.download_tracker.set_total_bytes_copied(scan_pid, 
+                self.download_tracker.set_total_bytes_copied(scan_pid,
                                                              total_downloaded)
                 self.time_check.increment(bytes_downloaded=chunk_downloaded)
                 percent_complete = self.download_tracker.get_percent_complete(scan_pid)
@@ -2457,39 +2488,39 @@ class RapidApp(dbus.service.Object):
                 self.time_remaining.update(scan_pid, bytes_downloaded=chunk_downloaded)
             elif msg_type == rpdmp.MSG_FILE:
                 self.copy_file_results_single_file(data)
-                
+
             return True
         else:
             # Process is complete, i.e. conn_type == rpdmp.CONN_COMPLETE
             connection.close()
             return False
-            
+
 
     def copy_file_results_single_file(self, data):
         """
         Handles results from one of two processes:
         1. copy_files
         2. file_modify
-        
+
         Operates after a single file has been copied from the download device
         to the local folder.
-        
+
         Calls the process to rename files and create subfolders (subfolderfile)
         """
-        
+
         download_succeeded, rpd_file, download_count, temp_full_file_name, thumbnail_icon, thumbnail = data
-        
+
         if thumbnail is not None or thumbnail_icon is not None:
-            self.thumbnails.update_thumbnail((rpd_file.unique_id, 
-                                              thumbnail_icon, 
+            self.thumbnails.update_thumbnail((rpd_file.unique_id,
+                                              thumbnail_icon,
                                               thumbnail))
-        
+
         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)
@@ -2498,21 +2529,21 @@ class RapidApp(dbus.service.Object):
             rpd_file.download_conflict_resolution = self.prefs.download_conflict_resolution
             rpd_file.synchronize_raw_jpg = self.prefs.must_synchronize_raw_jpg()
             rpd_file.job_code = self.job_code
-            
+
             self.subfolder_file_manager.rename_file_and_move_to_subfolder(
-                    download_succeeded, 
-                    download_count, 
+                    download_succeeded,
+                    download_count,
                     rpd_file
-                    )         
+                    )
     def file_modify_results(self, source, condition):
         """
-        'file modify' is a process that runs immediately after 'copy files', 
-        meaning there can be more than one at one time. 
-        
+        'file modify' is a process that runs immediately after 'copy files',
+        meaning there can be more than one at one time.
+
         It runs before the renaming process.
         """
         connection = self.file_modify_manager.get_pipe(source)
-        
+
         conn_type, data = connection.recv()
         if conn_type == rpdmp.CONN_PARTIAL:
             self.copy_file_results_single_file(data)
@@ -2520,31 +2551,31 @@ class RapidApp(dbus.service.Object):
         else:
             # Process is complete, i.e. conn_type == rpdmp.CONN_COMPLETE
             connection.close()
-            return False            
+            return False
+
 
-    
     def download_is_occurring(self):
-        """Returns True if a file is currently being downloaded, renamed or 
+        """Returns True if a file is currently being downloaded, renamed or
            backed up
         """
         return not len(self.download_active_by_scan_pid) == 0
-    
+
     # # #
     # Create folder and file names for downloaded files
     # # #
-    
-    def subfolder_file_results(self, move_succeeded, rpd_file):
+
+    def subfolder_file_results(self, move_succeeded, rpd_file, download_count):
         """
         Handle results of subfolder creation and file renaming
         """
-            
+
         scan_pid = rpd_file.scan_pid
         unique_id = rpd_file.unique_id
-        
+
         if rpd_file.status == config.STATUS_DOWNLOADED_WITH_WARNING:
-            self.log_error(config.WARNING, rpd_file.error_title, 
+            self.log_error(config.WARNING, rpd_file.error_title,
                            rpd_file.error_msg, rpd_file.error_extra_detail)
-                           
+
         if self.prefs.backup_images and len(self.backup_devices):
             if self.prefs.backup_device_autodetection:
                 if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
@@ -2553,23 +2584,24 @@ class RapidApp(dbus.service.Object):
                     path_suffix = self.prefs.video_backup_identifier
             else:
                 path_suffix = None
-            
-            self.backup_manager.backup_file(move_succeeded, rpd_file, 
+
+            self.backup_manager.backup_file(move_succeeded, rpd_file,
                                     path_suffix,
-                                    self.prefs.backup_duplicate_overwrite)
+                                    self.prefs.backup_duplicate_overwrite,
+                                    download_count)
         else:
             self.file_download_finished(move_succeeded, rpd_file)
-     
-    
+
+
     def multiple_backup_devices(self, file_type):
         """Returns true if more than one backup device is being used for that
         file type
         """
-        return ((file_type == rpdfile.FILE_TYPE_PHOTO and 
+        return ((file_type == rpdfile.FILE_TYPE_PHOTO and
                  self.no_photo_backup_devices > 1) or
-                (file_type == rpdfile.FILE_TYPE_VIDEO and 
+                (file_type == rpdfile.FILE_TYPE_VIDEO and
                  self.no_video_backup_devices > 1))
-                                 
+
     def backup_results(self, source, condition):
         """
         Handle results sent from backup processes
@@ -2578,30 +2610,30 @@ class RapidApp(dbus.service.Object):
         conn_type, msg_data = connection.recv()
         if conn_type == rpdmp.CONN_PARTIAL:
             msg_type, data = msg_data
-            
+
             if msg_type == rpdmp.MSG_BYTES:
                 scan_pid, backup_pid, total_downloaded, chunk_downloaded = data
-                self.download_tracker.increment_bytes_backed_up(scan_pid, 
+                self.download_tracker.increment_bytes_backed_up(scan_pid,
                                                              chunk_downloaded)
                 self.time_check.increment(bytes_downloaded=chunk_downloaded)
                 percent_complete = self.download_tracker.get_percent_complete(scan_pid)
                 self.device_collection.update_progress(scan_pid, percent_complete,
                                             None, None)
                 self.time_remaining.update(scan_pid, bytes_downloaded=chunk_downloaded)
-                
+
             elif msg_type == rpdmp.MSG_FILE:
                 backup_succeeded, rpd_file = data
-                
+
                 # Only show an error message if there is more than one device
                 # backing up files of this type - if that is the case,
-                # do not want to reply on showing an error message in the 
+                # do not want to reply on showing an error message in the
                 # function file_download_finished, as it is only called once,
                 # when all files have been backed up
                 if not backup_succeeded and self.multiple_backup_devices(rpd_file.file_type):
-                    self.log_error(config.SERIOUS_ERROR, 
-                        rpd_file.error_title, 
+                    self.log_error(config.SERIOUS_ERROR,
+                        rpd_file.error_title,
                         rpd_file.error_msg, rpd_file.error_extra_detail)
-                
+
                 self.download_tracker.file_backed_up(rpd_file.unique_id)
                 if self.download_tracker.all_files_backed_up(rpd_file.unique_id,
                                                              rpd_file.file_type):
@@ -2610,7 +2642,7 @@ class RapidApp(dbus.service.Object):
         else:
             return False
 
-    
+
     def file_download_finished(self, succeeded, rpd_file):
         """
         Called when a file has been downloaded i.e. copied, renamed, and backed up
@@ -2619,23 +2651,23 @@ class RapidApp(dbus.service.Object):
         unique_id = rpd_file.unique_id
         # Update error log window if neccessary
         if not succeeded and not self.multiple_backup_devices(rpd_file.file_type):
-            self.log_error(config.SERIOUS_ERROR, rpd_file.error_title, 
+            self.log_error(config.SERIOUS_ERROR, rpd_file.error_title,
                            rpd_file.error_msg, rpd_file.error_extra_detail)
         elif self.prefs.auto_delete:
-            # record which files to automatically delete when download 
+            # record which files to automatically delete when download
             # completes
             self.download_tracker.add_to_auto_delete(rpd_file)
-                           
+
         self.thumbnails.update_status_post_download(rpd_file)
-        self.download_tracker.file_downloaded_increment(scan_pid, 
+        self.download_tracker.file_downloaded_increment(scan_pid,
                                                         rpd_file.file_type,
                                                         rpd_file.status)
-                                                        
+
         completed, files_remaining = self._update_file_download_device_progress(scan_pid, unique_id, rpd_file.file_type)
-        
+
         if self.download_is_occurring():
             self.update_time_remaining()
-                
+
         if completed:
             # Last file for this scan pid has been downloaded, so clean temp directory
             logger.debug("Purging temp directories")
@@ -2649,63 +2681,63 @@ class RapidApp(dbus.service.Object):
             self.notify_downloaded_from_device(scan_pid)
             if files_remaining == 0 and self.prefs.auto_unmount:
                 self.device_collection.unmount(scan_pid)
-            
-            
+
+
             if not self.download_is_occurring():
                 logger.debug("Download completed")
                 self.enable_prefs_and_refresh(enabled=True)
                 self.notify_download_complete()
                 self.download_progressbar.set_fraction(0.0)
-                
+
                 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)
 
-                if ((self.prefs.auto_exit and self.download_tracker.no_errors_or_warnings()) 
+                if ((self.prefs.auto_exit and self.download_tracker.no_errors_or_warnings())
                                                 or self.prefs.auto_exit_force):
                     if not self.thumbnails.files_remain_to_download():
                         self._terminate_processes()
                         gtk.main_quit()
-                        
+
                 self.download_tracker.purge_all()
                 self.speed_label.set_label(" ")
-                                        
+
                 self.display_free_space()
-                
+
                 self.set_download_action_label(is_download=True)
                 self.set_download_action_sensitivity()
-                
+
                 self.job_code = ''
                 self.download_start_time = None
-        
-        
+
+
     def update_time_remaining(self):
         update, download_speed = self.time_check.check_for_update()
         if update:
             self.speed_label.set_text(download_speed)
-            
+
             time_remaining = self.time_remaining.time_remaining()
             if time_remaining:
                 secs =  int(time_remaining)
-            
+
                 if secs == 0:
                     message = ""
                 elif secs == 1:
                     message = _("About 1 second remaining")
                 elif secs < 60:
-                    message = _("About %i seconds remaining") % secs 
+                    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. 
+                    # 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)         
-            
+                self.rapid_statusbar.push(self.statusbar_context_id, message)
+
     def auto_delete(self, scan_pid):
         """Delete files from download device at completion of download"""
         for file in self.download_tracker.get_files_to_auto_delete(scan_pid):
@@ -2714,10 +2746,10 @@ class RapidApp(dbus.service.Object):
                 f.delete(cancellable=None)
             except gio.Error, inst:
                 logger.error("Failure deleting file %s", file)
-                logger.error(inst)            
-    
+                logger.error(inst)
+
     def file_types_by_number(self, no_photos, no_videos):
-        """ 
+        """
         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
@@ -2740,14 +2772,14 @@ class RapidApp(dbus.service.Object):
 
     def notify_downloaded_from_device(self, scan_pid):
         device = self.device_collection.get_device(scan_pid)
-        
+
         if device.mount is None:
             notification_name = PROGRAM_NAME
             icon = self.application_icon
         else:
             notification_name  = device.get_name()
             icon = device.get_icon(self.notification_icon_size)
-        
+
         no_photos_downloaded = self.download_tracker.get_no_files_downloaded(
                                             scan_pid, rpdfile.FILE_TYPE_PHOTO)
         no_videos_downloaded = self.download_tracker.get_no_files_downloaded(
@@ -2759,36 +2791,37 @@ class RapidApp(dbus.service.Object):
         no_files_downloaded = no_photos_downloaded + no_videos_downloaded
         no_files_failed = no_photos_failed + no_videos_failed
         no_warnings = self.download_tracker.get_no_warnings(scan_pid)
-                                            
+
         file_types = self.file_types_by_number(no_photos_downloaded, no_videos_downloaded)
         file_types_failed = self.file_types_by_number(no_photos_failed, no_videos_failed)
         message = _("%(noFiles)s %(filetypes)s downloaded") % \
                    {'noFiles':no_files_downloaded, 'filetypes': file_types}
-        
+
         if no_files_failed:
             message += "\n" + _("%(noFiles)s %(filetypes)s failed to download") % {'noFiles':no_files_failed, 'filetypes':file_types_failed}
-        
+
         if no_warnings:
-            message = "%s\n%s " % (message,  no_warnings) + _("warnings") 
-  
-        n = pynotify.Notification(notification_name, message)
-        n.set_icon_from_pixbuf(icon)
-        
-        n.show()
-    
+            message = "%s\n%s " % (message,  no_warnings) + _("warnings")
+
+        if use_pynotify:
+            n = pynotify.Notification(notification_name, message)
+            n.set_icon_from_pixbuf(icon)
+
+            n.show()
+
     def notify_download_complete(self):
         if self.display_summary_notification:
             message = _("All downloads complete")
-            
+
             # photo downloads
             photo_downloads = self.download_tracker.total_photos_downloaded
             if photo_downloads:
                 filetype = self.file_types_by_number(photo_downloads, 0)
                 message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                            {'number': photo_downloads, 
+                            {'number': photo_downloads,
                             'numberdownloaded': _("%(filetype)s downloaded") % \
                             {'filetype': filetype}}
-            
+
             # photo failures
             photo_failures = self.download_tracker.total_photo_failures
             if photo_failures:
@@ -2797,16 +2830,16 @@ class RapidApp(dbus.service.Object):
                             {'number': photo_failures,
                             'numberdownloaded': _("%(filetype)s failed to download") % \
                             {'filetype': filetype}}
-                            
+
             # video downloads
             video_downloads = self.download_tracker.total_videos_downloaded
             if video_downloads:
                 filetype = self.file_types_by_number(0, video_downloads)
                 message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                            {'number': video_downloads, 
+                            {'number': video_downloads,
                             'numberdownloaded': _("%(filetype)s downloaded") % \
                             {'filetype': filetype}}
-                            
+
             # video failures
             video_failures = self.download_tracker.total_video_failures
             if video_failures:
@@ -2815,65 +2848,66 @@ class RapidApp(dbus.service.Object):
                             {'number': video_failures,
                             'numberdownloaded': _("%(filetype)s failed to download") % \
                             {'filetype': filetype}}
-            
+
             # warnings
-            warnings = self.download_tracker.total_warnings 
+            warnings = self.download_tracker.total_warnings
             if warnings:
                 message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                            {'number': warnings, 
+                            {'number': warnings,
                             'numberdownloaded': _("warnings")}
-                            
-            n = pynotify.Notification(PROGRAM_NAME, message)
-            n.set_icon_from_pixbuf(self.application_icon)
-            n.show()
+
+            if use_pynotify:
+                n = pynotify.Notification(PROGRAM_NAME, message)
+                n.set_icon_from_pixbuf(self.application_icon)
+                n.show()
             self.display_summary_notification = False # don't show it again unless needed
-      
-        
+
+
     def _update_file_download_device_progress(self, scan_pid, unique_id, file_type):
         """
         Increments the progress bar for an individual device
-        
+
         Returns if the download is completed for that scan_pid
         It also returns the number of files remaining for the scan_pid, BUT
         this value is valid ONLY if the download is completed
         """
-        
+
         files_downloaded = self.download_tracker.get_download_count_for_file(unique_id)
         files_to_download = self.download_tracker.get_no_files_in_download(scan_pid)
         file_types = self.download_tracker.get_file_types_present(scan_pid)
         completed = files_downloaded == files_to_download
         if completed and (self.prefs.backup_images and len(self.backup_devices)):
             completed = self.download_tracker.all_files_backed_up(unique_id, file_type)
-        
+
         if completed:
             files_remaining = self.thumbnails.get_no_files_remaining(scan_pid)
         else:
             files_remaining = 0
-                    
+
         if completed and files_remaining:
             # e.g.: 3 of 205 photos and videos (202 remaining)
             progress_bar_text = _("%(number)s of %(total)s %(filetypes)s (%(remaining)s remaining)") % {
-                                  'number':  files_downloaded, 
+                                  'number':  files_downloaded,
                                   'total': files_to_download,
                                   'filetypes': file_types,
                                   'remaining': files_remaining}
         else:
             # e.g.: 205 of 205 photos and videos
             progress_bar_text = _("%(number)s of %(total)s %(filetypes)s") % \
-                                 {'number':  files_downloaded, 
+                                 {'number':  files_downloaded,
                                   'total': files_to_download,
                                   'filetypes': file_types}
         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, 
+                                        progress_bar_text=progress_bar_text,
                                         bytes_downloaded=None)
-        
+
         percent_complete = self.download_tracker.get_overall_percent_complete()
         self.download_progressbar.set_fraction(percent_complete)
-                                        
+
         return (completed, files_remaining)
-        
+
 
     def _clean_all_temp_dirs(self):
         """
@@ -2882,10 +2916,10 @@ class RapidApp(dbus.service.Object):
         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)
-                
+
         self.temp_dirs_by_scan_pid = {}
-            
-    
+
+
     def _clean_temp_dirs_for_scan_pid(self, scan_pid):
         """
         Deletes temp files and folders used in download
@@ -2897,10 +2931,10 @@ class RapidApp(dbus.service.Object):
     def _purge_dir(self, directory):
         """
         Deletes all files in the directory, and the directory itself.
-        
+
         Does not recursively traverse any subfolders in the directory.
         """
-        
+
         if directory:
             try:
                 path = gio.File(directory)
@@ -2916,16 +2950,16 @@ class RapidApp(dbus.service.Object):
             except gio.Error, inst:
                 logger.error("Failure deleting temporary folder %s", directory)
                 logger.error(inst)
-    
-    
-    # # # 
+
+
+    # # #
     # Preferences
     # # #
-        
-        
-    def _init_prefs(self, auto_detect, device_location): 
+
+
+    def _init_prefs(self, auto_detect, device_location):
         self.prefs = prefsrapid.RapidPreferences()
-        
+
         # handle device preferences set from the command line
         # do this before preference changes are handled with notify_add
         if auto_detect:
@@ -2933,82 +2967,82 @@ class RapidApp(dbus.service.Object):
         elif device_location:
             self.prefs.device_location = device_location
             self.prefs.device_autodetection = False
-                    
+
         self.prefs.notify_add(self.on_preference_changed)
-        
-        # flag to indicate whether the user changed some preferences that 
+
+        # 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
-        
-        # flag to indicate that the preferences dialog window is being 
+
+        # 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
-        
-        # these values are used to track the number of backup devices / 
+
+        # these values are used to track the number of backup devices /
         # locations for each file type
         self.no_photo_backup_devices = 0
         self.no_video_backup_devices = 0
-        
+
         self.downloads_today_tracker = self.prefs.get_downloads_today_tracker()
-        
+
         downloads_today = self.downloads_today_tracker.get_and_maybe_reset_downloads_today()
         if downloads_today > 0:
             logger.info("Downloads that have occurred so far today: %s", downloads_today)
         else:
-            logger.info("No downloads have occurred so far today")        
+            logger.info("No downloads have occurred so far today")
 
-        self.downloads_today_value = Value(c_int, 
+        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.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())
-        
+
         self.check_prefs_upgrade(__version__)
         self.prefs.program_version = __version__
-        
+
     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()    
-    
+        self.uses_sequence_letter_value.value = self.prefs.any_pref_uses_sequence_letter_value()
+
     def check_prefs_upgrade(self, running_version):
         """
-        Checks if the running version of the program is different from the 
+        Checks if the running version of the program is different from the
         version recorded in the preferences.
-        
+
         If the version is different, the preferences are checked to see
         whether they should be upgraded or not.
         """
         previous_version = self.prefs.program_version
         if len(previous_version) > 0:
             # the program has been run previously for this user
-        
+
             pv = utilities.pythonify_version(previous_version)
             rv = utilities.pythonify_version(running_version)
-        
+
             if pv <> rv:
                 # 0.4.1 and below had only one manual backup location
                 # 0.4.2 introduced a distinct video back up location that can be manually set
-                # Therefore must duplicate the previous photo & video manual backup location into the 
+                # Therefore must duplicate the previous photo & video manual backup location into the
                 # new video field, unless it has already been changed already.
-                
+
                 if pv < utilities.pythonify_version('0.4.2'):
                     if self.prefs.backup_video_location == os.path.expanduser('~'):
                         self.prefs.backup_video_location = self.prefs.backup_location
-                        logger.info("Migrated manual backup location preference to videos: %s", 
+                        logger.info("Migrated manual backup location preference to videos: %s",
                                     self.prefs.backup_video_location)
-    
+
     def on_preference_changed(self, key, value):
         """
         Called when user changes the program's preferences
@@ -3017,90 +3051,89 @@ class RapidApp(dbus.service.Object):
 
         if key == 'show_log_dialog':
             self.menu_log_window.set_active(value)
-        elif key in ['device_autodetection', 'device_autodetection_psd', 
+        elif key in ['device_autodetection', 'device_autodetection_psd',
                      'device_location', 'ignored_paths',
                      'use_re_ignored_paths', 'device_blacklist']:
             self.rerun_setup_available_image_and_video_media = True
             self._set_from_toolbar_state()
             if not self.preferences_dialog_displayed:
                 self.post_preference_change()
-            
-                
-        elif key in ['backup_images', 'backup_device_autodetection', 
-                     'backup_location', 'backup_video_location', 
+
+
+        elif key in ['backup_images', 'backup_device_autodetection',
+                     'backup_location', 'backup_video_location',
                      'backup_identifier', 'video_backup_identifier']:
             self.rerun_setup_available_backup_media = True
             if not self.preferences_dialog_displayed:
                 self.post_preference_change()
-                
+
         # Downloads today and stored sequence numbers are kept in shared memory,
         # so that the subfolderfile daemon process can access and modify them
-        
+
         # Note, totally ignore any changes in downloads today, as it
         # is modified in a special manner via a tracking class
-                
+
         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']:
             self.need_job_code_for_naming = self.prefs.any_pref_uses_job_code()
             # Check if stored sequence no is being used
             self._check_for_sequence_value_use()
-            
+
         elif key in ['download_folder', 'video_download_folder']:
             self._set_to_toolbar_values()
             self.display_free_space()
-    
+
     def post_preference_change(self):
         if self.rerun_setup_available_image_and_video_media:
 
             logger.info("Download device settings preferences were changed")
-            
+
             self.thumbnails.clear_all()
             self.setup_devices(on_startup = False, on_preference_change = True, block_auto_start = True)
             self._set_device_collection_size()
-            
+
             if self.main_notebook.get_current_page() == 1: # preview of file
                 self.main_notebook.set_current_page(0)
-                
+
             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()          
+                self.start_volume_monitor()
             logger.info("Backup preferences were changed.")
-            
+
             self.refresh_backup_media()
-            
+
             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)
-            
 
-    
+
+
     # # #
     # Main app window management and setup
     # # #
-    
+
     def _init_pynotify(self):
         """
         Initialize system notification messages
         """
-        
+
         if not pynotify.init("TestCaps"):
             logger.warning("There might be problems using pynotify.")
-            #~ sys.exit(1)
 
         do_not_size_icon = False
-        self.notification_icon_size = 48 
+        self.notification_icon_size = 48
         try:
             info = pynotify.get_server_info()
         except:
@@ -3111,7 +3144,7 @@ class RapidApp(dbus.service.Object):
                     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'))
@@ -3137,7 +3170,7 @@ class RapidApp(dbus.service.Object):
         self.main_notebook = builder.get_object("main_notebook")
         self.download_action = builder.get_object("download_action")
         self.download_button = builder.get_object("download_button")
-        
+
         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")
@@ -3148,71 +3181,71 @@ class RapidApp(dbus.service.Object):
         self.speed_label = builder.get_object("speed_label")
         self.refresh_action = builder.get_object("refresh_action")
         self.preferences_action = builder.get_object("preferences_action")
-        
+
         # Only enable this action when actually displaying a preview
         self.next_image_action.set_sensitive(False)
         self.prev_image_action.set_sensitive(False)
-        
+
         self._init_toolbars()
-        
+
         # About dialog
         builder.add_from_file(paths.share_dir("glade3/about.ui"))
         self.about = builder.get_object("about")
-        
+
         builder.connect_signals(self)
-        
+
         self.preview_image = PreviewImage(self, builder)
 
         thumbnails_scrolledwindow = builder.get_object('thumbnails_scrolledwindow')
         self.thumbnails = ThumbnailDisplay(self)
-        thumbnails_scrolledwindow.add(self.thumbnails)        
-        
+        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)
-        
+
         #error log window
         self.error_log = errorlog.ErrorLog(self)
-        
+
         # 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 = {}
-        
+
         # Download action state
         self.download_action_is_download = True
-        
+
         # Track the time a download commences
         self.download_start_time = None
-        
+
         # Whether a system wide notifcation message should be shown
         # after a download has occurred in parallel
         self.display_summary_notification = False
-        
+
         # Values used to display how much longer a download will take
         self.time_remaining = downloadtracker.TimeRemaining()
         self.time_check = downloadtracker.TimeCheck()
-        
+
     def _init_toolbars(self):
         """ Setup the 3 vertical toolbars on the main screen """
         self._setup_from_toolbar()
         self._setup_copy_move_toolbar()
         self._setup_dest_toolbar()
-        
+
         # size label widths so they are equal, or else the left border of the file chooser will not match
         self.photo_dest_label.realize()
         self._make_widget_widths_equal(self.photo_dest_label, self.video_dest_label)
         self.photo_dest_label.set_alignment(xalign=0.0, yalign=0.5)
         self.video_dest_label.set_alignment(xalign=0.0, yalign=0.5)
-        
+
         # size copy / move buttons so they are equal in length, so arrows align
         self._make_widget_widths_equal(self.copy_button, self.move_button)
-        
+
     def _setup_from_toolbar(self):
         self.from_toolbar.set_style(gtk.TOOLBAR_TEXT)
         self.from_toolbar.set_border_width(5)
-        
+
         from_label = gtk.Label()
         from_label.set_markup("<i>" + _("From") + "</i>")
         self.from_toolbar_label = gtk.ToolItem()
@@ -3229,32 +3262,32 @@ class RapidApp(dbus.service.Object):
             _("Select a folder containing %(file_types)s") % {'file_types':file_types_to_download()})
         self.from_filechooser_button.set_action(
                             gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
-        
+
         self.from_filechooser = gtk.ToolItem()
         self.from_filechooser.set_is_important(True)
         self.from_filechooser.add(self.from_filechooser_button)
         self.from_filechooser.set_expand(True)
         self.from_toolbar.insert(self.from_filechooser, 2)
-        
+
         self._set_from_toolbar_state()
-        
+
         #set events after having initialized the values
         self.auto_detect_button.connect("toggled", self.on_auto_detect_button_toggled_event)
-        self.from_filechooser_button.connect("selection-changed", 
+        self.from_filechooser_button.connect("selection-changed",
                             self.on_from_filechooser_button_selection_changed)
-                
+
         self.from_toolbar.show_all()
-    
+
     def _setup_copy_move_toolbar(self):
         self.copy_toolbar.set_style(gtk.TOOLBAR_TEXT)
         self.copy_toolbar.set_border_width(5)
-        
+
         copy_move_label = gtk.Label(" ")
         self.copy_move_toolbar_label = gtk.ToolItem()
         self.copy_move_toolbar_label.add(copy_move_label)
         self.copy_move_toolbar_label.set_is_important(True)
         self.copy_toolbar.insert(self.copy_move_toolbar_label, 0)
-        
+
         self.copy_hbox = gtk.HBox()
         self.move_hbox = gtk.HBox()
         self.forward_image = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
@@ -3265,7 +3298,7 @@ class RapidApp(dbus.service.Object):
         self.forward_label2 = gtk.Label(" ")
         self.forward_label3 = gtk.Label(" ")
         self.forward_label4 = gtk.Label(" ")
-        
+
         self.copy_button = gtk.RadioToolButton()
         self.copy_button.set_label(_("Copy"))
         self.copy_button.set_is_important(True)
@@ -3278,7 +3311,7 @@ class RapidApp(dbus.service.Object):
         copy_box = gtk.ToolItem()
         copy_box.add(self.copy_hbox)
         self.copy_toolbar.insert(copy_box, 1)
-            
+
         self.move_button = gtk.RadioToolButton(self.copy_button)
         self.move_button.set_label(_("Move"))
         self.move_button.set_is_important(True)
@@ -3290,27 +3323,27 @@ class RapidApp(dbus.service.Object):
         move_box = gtk.ToolItem()
         move_box.add(self.move_hbox)
         self.copy_toolbar.insert(move_box, 2)
-        
+
         self.move_button.set_active(self.prefs.auto_delete)
-        self.copy_button.connect("toggled", self.on_copy_button_toggle_event)        
-        
+        self.copy_button.connect("toggled", self.on_copy_button_toggle_event)
+
         self.copy_toolbar.show_all()
-        self._set_copy_toolbar_active_arrows()    
-    
+        self._set_copy_toolbar_active_arrows()
+
     def _setup_dest_toolbar(self):
         #Destination Toolbar
         self.dest_toolbar.set_border_width(5)
-        
+
         dest_label = gtk.Label()
         dest_label.set_markup("<i>" + _("To") + "</i>")
         self.dest_toolbar_label = gtk.ToolItem()
         self.dest_toolbar_label.add(dest_label)
         self.dest_toolbar_label.set_is_important(True)
         self.dest_toolbar.insert(self.dest_toolbar_label, 0)
-        
+
         photo_dest_hbox = gtk.HBox()
         self.photo_dest_label = gtk.Label(_("Photos:"))
-        
+
         self.to_photo_filechooser_button = gtk.FileChooserButton(
                 _("Select a folder to download photos to"))
         self.to_photo_filechooser_button.set_action(
@@ -3336,9 +3369,9 @@ class RapidApp(dbus.service.Object):
         self.to_video_filechooser.set_expand(True)
         self.to_video_filechooser.add(video_dest_hbox)
         self.dest_toolbar.insert(self.to_video_filechooser, 2)
-        
+
         self._set_to_toolbar_values()
-        self.to_photo_filechooser_button.connect("selection-changed", 
+        self.to_photo_filechooser_button.connect("selection-changed",
                         self.on_to_photo_filechooser_button_selection_changed)
         self.to_video_filechooser_button.connect("selection-changed",
                         self.on_to_video_filechooser_button_selection_changed)
@@ -3346,14 +3379,14 @@ class RapidApp(dbus.service.Object):
 
     def _make_widget_widths_equal(self, widget1, widget2):
         """takes two widgets and sets a width for both equal to widest one"""
-        
+
         x1, y1, w1, h1 = widget1.get_allocation()
         x2, y2, w2, h2 = widget2.get_allocation()
         w = max(w1, w2)
         h = max(h1, h2)
         widget1.set_size_request(w,h)
         widget2.set_size_request(w,h)
-        
+
     def _set_copy_toolbar_active_arrows(self):
         if self.copy_button.get_active():
             self.forward_image.set_visible(True)
@@ -3377,36 +3410,36 @@ class RapidApp(dbus.service.Object):
     def on_copy_button_toggle_event(self, radio_button):
         self._set_copy_toolbar_active_arrows()
         self.prefs.auto_delete = not self.copy_button.get_active()
-                    
+
     def _set_from_toolbar_state(self):
         logger.debug("_set_from_toolbar_state")
         self.auto_detect_button.set_active(self.prefs.device_autodetection)
         if self.prefs.device_autodetection:
             self.from_filechooser_button.set_sensitive(False)
         self.from_filechooser_button.set_current_folder(self.prefs.device_location)
-    
+
     def on_auto_detect_button_toggled_event(self, button):
         logger.debug("on_auto_detect_button_toggled_event")
         self.from_filechooser_button.set_sensitive(not button.get_active())
         if not self.rerun_setup_available_image_and_video_media:
             self.prefs.device_autodetection = button.get_active()
-                
+
     def on_from_filechooser_button_selection_changed(self, filechooserbutton):
         logger.debug("on_from_filechooser_button_selection_changed")
         path = filechooserbutton.get_current_folder()
         if path and not self.rerun_setup_available_image_and_video_media:
             self.prefs.device_location = path
-            
+
     def on_to_photo_filechooser_button_selection_changed(self, filechooserbutton):
         path = filechooserbutton.get_current_folder()
         if path:
             self.prefs.download_folder = path
-    
+
     def on_to_video_filechooser_button_selection_changed(self, filechooserbutton):
         path = filechooserbutton.get_current_folder()
         if path:
             self.prefs.video_download_folder = path
-            
+
     def _set_to_toolbar_values(self):
         self.to_photo_filechooser_button.set_current_folder(self.prefs.download_folder)
         self.to_video_filechooser_button.set_current_folder(self.prefs.video_download_folder)
@@ -3419,20 +3452,20 @@ class RapidApp(dbus.service.Object):
     def _set_window_size(self):
         """
         Remember the window size from the last time the program was run, or
-        set a default size        
+        set a default size
         """
-        
+
         if self.prefs.main_window_maximized:
             self.rapidapp.maximize()
-            self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH, 
+            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, 
+            self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH,
                                            config.DEFAULT_WINDOW_HEIGHT)
-        
+
 
     def _set_device_collection_size(self):
         """
@@ -3445,36 +3478,36 @@ class RapidApp(dbus.service.Object):
         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
-        
+
     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)
-        
+
         preview_button = self.builder.get_object("preview_button")
         image = gtk.image_new_from_file(paths.share_dir('glade3/photo_icon.png'))
         preview_button.set_image(image)
-        
+
         next_image_button = self.builder.get_object("next_image_button")
         image = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_BUTTON)
         next_image_button.set_image(image)
-        
+
         prev_image_button = self.builder.get_object("prev_image_button")
         image = gtk.image_new_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_BUTTON)
         prev_image_button.set_image(image)
-    
+
     def _setup_icons(self):
         icons = ['rapid-photo-downloader-jobcode',]
-        icon_list = [(icon, paths.share_dir('glade3/%s.svg' % icon)) for icon in icons]        
+        icon_list = [(icon, paths.share_dir('glade3/%s.svg' % icon)) for icon in icons]
         register_iconsets(icon_list)
-    
+
     def _setup_error_icons(self):
         """
         hide display of warning and error symbols in the taskbar until they
@@ -3486,7 +3519,7 @@ class RapidApp(dbus.service.Object):
         self.error_image.hide()
         self.warning_image.hide()
         self.warning_vseparator.hide()
-        
+
     def enable_prefs_and_refresh(self, enabled):
         """
         If enable is true, then the user is able to activate the preferences
@@ -3495,20 +3528,20 @@ class RapidApp(dbus.service.Object):
         """
         self.refresh_action.set_sensitive(enabled)
         self.preferences_action.set_sensitive(enabled)
-    
+
     def statusbar_message(self, msg):
         self.rapid_statusbar.push(self.statusbar_context_id, msg)
-        
+
     def statusbar_message_remove(self):
         self.rapid_statusbar.pop(self.statusbar_context_id)
 
     def display_backup_mounts(self):
         """
-        Create a message to be displayed to the user showing which backup 
+        Create a message to be displayed to the user showing which backup
         mounts will be used
         """
         message =  ''
-        
+
         paths = self.backup_devices.keys()
         i = 0
         v = len(paths)
@@ -3521,22 +3554,22 @@ class RapidApp(dbus.service.Object):
                     prefix = " " + _("and")  + " "
             i += 1
             message = "%s%s'%s'" % (message,  prefix, self.backup_devices[b][0].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
-        
+
     def display_free_space(self):
         """
-        Displays the amount of space free on the filesystem the files will be 
+        Displays the amount of space free on the filesystem the files will be
         downloaded to.
-        
-        Also displays backup volumes / path being used. 
+
+        Also displays backup volumes / path being used.
         """
         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)
@@ -3545,17 +3578,17 @@ class RapidApp(dbus.service.Object):
                                             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])
@@ -3563,13 +3596,13 @@ class RapidApp(dbus.service.Object):
             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 
+                #(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 
+                #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                
+                #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
@@ -3579,17 +3612,17 @@ class RapidApp(dbus.service.Object):
                 elif not self.prefs.backup_images:
                     #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).                    
+                    #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.prefs.backup_images: 
+
+
+        if self.prefs.backup_images:
             if not self.prefs.backup_device_autodetection:
                 if self.prefs.backup_location == self.prefs.backup_video_location:
                     if DOWNLOAD_VIDEO:
@@ -3604,29 +3637,29 @@ class RapidApp(dbus.service.Object):
                              'path':self.prefs.backup_location,
                              'path2': self.prefs.backup_video_location}
             else:
-                msg2 = self.display_backup_mounts() 
-                
+                msg2 = self.display_backup_mounts()
+
             if msg:
                 msg = _("%(freespace)s. %(backuppaths)s.") % {'freespace': msg, 'backuppaths': msg2}
             else:
                 msg = msg2
-        
+
         msg = msg.rstrip()
-            
+
         self.statusbar_message(msg)
-        
+
     def log_error(self, severity, problem, details, extra_detail=None):
         """
         Display error and warning messages to user in log window
         """
         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()     
-        
-        
+        self.error_log.widget.show()
+
+
     def on_menu_log_window_toggled(self, widget):
         active = widget.get_active()
         self.prefs.show_log_dialog = active
@@ -3634,14 +3667,14 @@ class RapidApp(dbus.service.Object):
             self.error_log.widget.show()
         else:
             self.error_log.widget.hide()
-            
+
     def notify_prefs_are_invalid(self, details):
         title = _("Program preferences are invalid")
         logger.critical(title)
         self.log_error(severity=config.CRITICAL_ERROR, problem=title,
                        details=details)
-    
-    
+
+
     # # #
     # Utility functions
     # # #
@@ -3650,7 +3683,7 @@ class RapidApp(dbus.service.Object):
         """
         Returns true if there is at least one instance of the file_type
         in the list of files to be copied
-        
+
         If return_file_count is True, then the number of files of that type
         will be counted and returned instead of True or False
         """
@@ -3665,7 +3698,7 @@ class RapidApp(dbus.service.Object):
             return False
         else:
             return i
-                
+
     def size_files_to_be_downloaded(self, files):
         """
         Returns the total sizes of the photos and videos to be downloaded in bytes
@@ -3679,12 +3712,12 @@ class RapidApp(dbus.service.Object):
                 video_size += rpd_file.size
 
         return (photo_size, video_size)
-                                              
+
     def check_download_folder_validity(self, files_by_scan_pid):
         """
         Checks validity of download folders based on the file types the user
         is attempting to download.
-        
+
         If valid, returns a tuple of True and an empty list.
         If invalid, returns a tuple of False and a list of the invalid directores.
         """
@@ -3702,27 +3735,27 @@ class RapidApp(dbus.service.Object):
                 if not need_video_folder:
                     if self.files_of_type_present(files, rpdfile.FILE_TYPE_VIDEO):
                         need_video_folder = True
-            
+
         # second, check validity
         if need_photo_folder:
-            if not self.is_valid_download_dir(self.prefs.download_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)
             else:
-                logger.debug("Photo download folder is valid: %s", 
+                logger.debug("Photo download folder is valid: %s",
                         self.prefs.download_folder)
-                
+
         if need_video_folder:
             if not self.is_valid_download_dir(self.prefs.video_download_folder,
-                                                        is_photo_dir=False):            
+                                                        is_photo_dir=False):
                 valid = False
                 invalid_dirs.append(self.prefs.video_download_folder)
             else:
-                logger.debug("Video download folder is valid: %s", 
+                logger.debug("Video download folder is valid: %s",
                         self.prefs.video_download_folder)
 
-                
+
         return (valid, invalid_dirs)
 
     def same_file_system(self, file1, file2):
@@ -3735,27 +3768,27 @@ class RapidApp(dbus.service.Object):
         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
-        
-    
+
+
     def same_file(self, file1, file2):
         """Returns True if the files / directories are the same
         """
         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 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
@@ -3765,11 +3798,11 @@ class RapidApp(dbus.service.Object):
             download_folder_type = _("Photo")
         else:
             download_folder_type = _("Video")
-            
+
         try:
             d = gio.File(path)
             if not d.query_exists(cancellable=None):
-                logger.error("%s download folder does not exist: %s", 
+                logger.error("%s download folder does not exist: %s",
                              download_folder_type, path)
                 if show_error_in_log:
                     severity = config.WARNING
@@ -3781,16 +3814,16 @@ class RapidApp(dbus.service.Object):
                 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", 
+                    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)                  
+                        self.log_error(severity, problem, details)
                 else:
                     # is the directory writable?
                     try:
@@ -3803,7 +3836,7 @@ class RapidApp(dbus.service.Object):
                             problem = _("%(file_type)s download folder is not writable") % {
                                         'file_type': download_folder_type}
                             details = _("Folder: %s") % path
-                            self.log_error(severity, problem, details)                          
+                            self.log_error(severity, problem, details)
                     else:
                         f = gio.File(temp_dir)
                         f.delete(cancellable=None)
@@ -3811,66 +3844,66 @@ class RapidApp(dbus.service.Object):
         except gio.Error, inst:
             logger.error("Error checking download directory %s", path)
             logger.error(inst)
-            
+
         return valid
-                
-    
-    
+
+
+
     # # #
     #  Process results and management
     # # #
-        
-        
+
+
     def _start_process_managers(self):
         """
         Set up process managers.
-        
+
         A task such as scanning a device or copying files is handled in its
         own process.
         """
-        
+
         self.batch_size = 10
         self.batch_size_MB = 2
-        
+
         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.stored_sequence_value,
                            self.uses_stored_sequence_no_value,
                            self.uses_session_sequece_no_value,
                            self.uses_sequence_letter_value)
-        
-        # daemon process to rename files and create subfolders                   
+
+        # daemon process to rename files and create subfolders
         self.subfolder_file_manager = SubfolderFileManager(
                                         self.subfolder_file_results,
                                         sequence_values)
-        
+
         # process to scan source devices / paths
-        self.scan_manager = ScanManager(self.scan_results, self.batch_size, 
+        self.scan_manager = ScanManager(self.scan_results, self.batch_size,
                                         self.device_collection.add_device)
-                                        
+
         #process to copy files from source to destination
-        self.copy_files_manager = CopyFilesManager(self.copy_files_results, 
+        self.copy_files_manager = CopyFilesManager(self.copy_files_results,
                                                    self.batch_size_MB)
-                                                   
+
         #process to back files up
         self.backup_manager = BackupFilesManager(self.backup_results,
                                                  self.batch_size_MB)
-                                                 
+
         #process to enhance files after they've been copied and before they're
         #renamed
         self.file_modify_manager = FileModifyManager(self.file_modify_results)
-        
-        
+
+
     def scan_results(self, source, condition):
         """
         Receive results from scan processes
         """
         connection = self.scan_manager.get_pipe(source)
-        
+
         conn_type, data = connection.recv()
-        
+
         if conn_type == rpdmp.CONN_COMPLETE:
             connection.close()
             self.scan_manager.no_tasks -= 1
@@ -3883,7 +3916,7 @@ class RapidApp(dbus.service.Object):
             self.device_collection.update_device(scan_pid, size)
             self.device_collection.update_progress(scan_pid, 0.0, results_summary, 0, pulse=False)
             self.set_download_action_sensitivity()
-                        
+
             if (not self.auto_start_is_on and
                 self.prefs.generate_thumbnails):
                 self.download_progressbar.set_text(_("Thumbnails"))
@@ -3897,7 +3930,7 @@ class RapidApp(dbus.service.Object):
             logger.debug("Turning on display of thumbnails")
             self.display_scan_thumbnails()
             self.download_button.grab_focus()
-            
+
             # signal that no more data is coming, finishing io watch for this pipe
             return False
         else:
@@ -3910,20 +3943,20 @@ class RapidApp(dbus.service.Object):
                 scanning_progress = file_type_counter.running_file_count()
                 self.device_collection.update_device(scan_pid, size)
                 self.device_collection.update_progress(scan_pid, 0.0, scanning_progress, 0, pulse=True)
-                
+
                 for rpd_file in rpd_files:
-                    self.thumbnails.add_file(rpd_file=rpd_file, 
+                    self.thumbnails.add_file(rpd_file=rpd_file,
                                         generate_thumbnail = not self.auto_start_is_on)
-        
+
         # must return True for this method to be called again
         return True
-        
+
 
     @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):
@@ -3932,14 +3965,14 @@ class RapidApp(dbus.service.Object):
         else:
             self.running = True
             gtk.main()
-        
+
 def start():
 
     is_beta = config.version.find('~') > 0
-    
+
     parser = OptionParser(version= "%%prog %s" % utilities.human_readable_version(config.version))
     parser.set_defaults(verbose=is_beta,  extensions=False)
-    # Translators: this text is displayed to the user when they request information on the command line options. 
+    # 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.
     parser.add_option("-v",  "--verbose",  action="store_true", dest="verbose",  help=_("display program information on the command line as the program runs (default: %default)"))
     parser.add_option("-d", "--debug", action="store_true", dest="debug", help=_('display debugging information when run from the command line'))
@@ -3951,26 +3984,26 @@ def start():
     parser.add_option("-l", "--device-location", type="string", metavar="PATH", dest="device_location", help=_("manually specify the PATH of the device from which to download, overwriting existing program preferences"))
     parser.add_option("--reset-settings", action="store_true", dest="reset", help=_("reset all program settings and preferences and exit"))
     (options, args) = parser.parse_args()
-    
+
     if options.debug:
         logging_level = logging.DEBUG
     elif options.verbose:
         logging_level = logging.INFO
     else:
         logging_level = logging.ERROR
-    
+
     logger.setLevel(logging_level)
-    
+
     if options.auto_detect and options.device_location:
         logger.info(_("Error: specify device auto-detection or manually specify a device's path from which to download, but do not do both."))
         sys.exit(1)
-        
+
     if options.auto_detect:
         auto_detect=True
         logger.info("Device auto detection set from command line")
     else:
         auto_detect=None
-        
+
     if options.device_location:
         device_location=options.device_location
         if device_location[-1]=='/':
@@ -3987,15 +4020,15 @@ def start():
                 v += '%s, ' % e.upper()
             v = file_type + " " + v[:-1] + ' '+ (_('and %s') % exts[-1].upper())
             print v
-            
+
         sys.exit(0)
-        
+
     if options.reset:
         prefs = prefsrapid.RapidPreferences()
         prefs.reset()
         print _("All settings and preferences have been reset")
         sys.exit(0)
-        
+
     if options.focal_length:
         focal_length = options.focal_length
     else:
@@ -4017,7 +4050,7 @@ def start():
 
     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: 
+    if request != dbus.bus.REQUEST_NAME_REPLY_EXISTS:
         app = RapidApp(bus, '/', config.DBUS_NAME, focal_length=focal_length,
         auto_detect=auto_detect, device_location=device_location)
     else:
@@ -4025,8 +4058,8 @@ def start():
         print "Rapid Photo Downloader is already running"
         object = bus.get_object (config.DBUS_NAME, "/")
         app = dbus.Interface (object, config.DBUS_NAME)
-    
-    app.start()            
+
+    app.start()
 
 if __name__ == "__main__":
     start()