Merge branch 'feature/upstream' into develop

1 files changed, 0 insertions, 4177 deletions

diff --git a/rapid/rapid.py b/rapid/rapid.py
deleted file mode 100755
index 303e1f7..0000000
--- a/rapid/rapid.py
+++ /dev/null
@@ -1,4177 +0,0 @@
-#!/usr/bin/python
-# -*- coding: latin1 -*-
-
-### Copyright (C) 2011-2014 Damon Lynch <damonlynch@gmail.com>
-
-### This program is free software; you can redistribute it and/or modify
-### it under the terms of the GNU General Public License as published by
-### the Free Software Foundation; either version 2 of the License, or
-### (at your option) any later version.
-
-### This program is distributed in the hope that it will be useful,
-### but WITHOUT ANY WARRANTY; without even the implied warranty of
-### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-### GNU General Public License for more details.
-
-### You should have received a copy of the GNU General Public License
-### along with this program; if not, write to the Free Software
-### Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
-### USA
-
-use_pynotify = True
-
-import tempfile
-
-import dbus
-import dbus.bus
-import dbus.service
-from dbus.mainloop.glib import DBusGMainLoop
-DBusGMainLoop(set_as_default=True)
-
-from optparse import OptionParser
-
-import gtk
-import gtk.gdk as gdk
-
-from gobject.constants import G_MAXINT
-
-import webbrowser
-
-import sys, time, types, os, datetime
-
-import gobject, pango, cairo, array, pangocairo, gio
-
-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
-
-import logging
-logger = log_to_stderr()
-
-# Rapid Photo Downloader modules
-
-import rpdfile
-
-from misc import get_folder_selection
-
-import problemnotification as pn
-import thumbnail as tn
-import rpdmultiprocessing as rpdmp
-
-import preferencesdialog
-import prefsrapid
-
-import tableplusminus as tpm
-import generatename as gn
-
-import downloadtracker
-
-import filemodify
-
-from metadatavideo import DOWNLOAD_VIDEO, file_types_to_download
-import metadataphoto
-import metadatavideo
-import metadataexiftool
-
-import scan as scan_process
-import copyfiles
-import subfolderfile
-import backupfile
-from backupfile import PHOTO_BACKUP, VIDEO_BACKUP, PHOTO_VIDEO_BACKUP
-
-import errorlog
-
-import device as dv
-import utilities
-
-import config
-__version__ = config.version
-
-import paths
-
-import gettext
-gettext.bindtextdomain(config.APP_NAME)
-gettext.textdomain(config.APP_NAME)
-
-_ = gettext.gettext
-
-
-from utilities import format_size_for_user
-from utilities import register_iconsets
-
-
-from config import  STATUS_CANNOT_DOWNLOAD, STATUS_DOWNLOADED, \
-                    STATUS_DOWNLOADED_WITH_WARNING, \
-                    STATUS_DOWNLOAD_FAILED, \
-                    STATUS_DOWNLOAD_PENDING, \
-                    STATUS_BACKUP_PROBLEM, \
-                    STATUS_NOT_DOWNLOADED, \
-                    STATUS_DOWNLOAD_AND_BACKUP_FAILED, \
-                    STATUS_WARNING
-
-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
-PROGRAM_NAME = _('Rapid Photo Downloader')
-__version__ = config.version
-
-def date_time_human_readable(date, with_line_break=True):
-    if with_line_break:
-        return _("%(date)s\n%(time)s") % {'date':date.strftime("%x"), 'time':date.strftime("%X")}
-    else:
-        return _("%(date)s %(time)s") % {'date':date.strftime("%x"), 'time':date.strftime("%X")}
-
-def date_time_subseconds_human_readable(date, subseconds):
-    return _("%(date)s %(hour)s:%(minute)s:%(second)s:%(subsecond)s") % \
-            {'date':date.strftime("%x"),
-             'hour':date.strftime("%H"),
-             'minute':date.strftime("%M"),
-             'second':date.strftime("%S"),
-             'subsecond': subseconds}
-
-
-class DeviceCollection(gtk.TreeView):
-    """
-    TreeView display of devices and how many files have been copied, shown
-    immediately under the menu in the main application window.
-    """
-    def __init__(self, parent_app):
-
-        self.parent_app = parent_app
-        # 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,
-                                       gtk.gdk.Pixbuf, int, int)
-        self.map_process_to_row = {}
-        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,
-        # external hard drive, Portable Storage Device, etc.
-        column0 = gtk.TreeViewColumn(_("Device"))
-        pixbuf_renderer = gtk.CellRendererPixbuf()
-        pixbuf_renderer.set_padding(2, 0)
-        text_renderer = gtk.CellRendererText()
-        text_renderer.props.ellipsize = pango.ELLIPSIZE_MIDDLE
-        text_renderer.set_fixed_size(160, -1)
-        eject_renderer = gtk.CellRendererPixbuf()
-        column0.pack_start(pixbuf_renderer, expand=False)
-        column0.pack_start(text_renderer, expand=True)
-        column0.pack_end(eject_renderer, expand=False)
-        column0.add_attribute(pixbuf_renderer, 'pixbuf', 0)
-        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"),
-                                    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,
-                                                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,
-                                      progress,
-                                      progress_bar_text,
-                                      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
-        # e.g. when starting with 3 cards, it could be 18, but when adding 2 cards to the already running program
-        # (with one card at startup), it could be 21
-        # must account for header row at the top
-        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
-        """
-        if process_id in self.map_process_to_row:
-            iter = self._get_process_map(process_id)
-            self.liststore.set_value(iter, 2, total_size_files)
-        else:
-            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
-        """
-        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
-        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()
-            iter = self.liststore.get_iter(path)
-            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
-                    self.liststore.set_value(iter, 7, self.liststore.get_value(iter, 7) + 1)
-                else:
-                    # Set to finished state
-                    self.liststore.set_value(iter, 7, G_MAXINT)
-            else:
-                # Reset to allow fraction to be set
-                self.liststore.set_value(iter, 7, -1)
-
-
-
-    def button_clicked(self, widget, event):
-        """
-        Look for left single click on eject button
-        """
-        if event.button == 1:
-            if len (self.liststore):
-                x = int(event.x)
-                y = int(event.y)
-                path, column, cell_x, cell_y = self.get_path_at_pos(x, y)
-                if path is not None:
-                    if column == self.get_column(0):
-                        if cell_x >= column.get_width() - self.eject_pixbuf.get_width():
-                            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()
-
-        try:
-            mount.unmount_finish(result)
-            logger.debug("%s successfully unmounted" % name)
-        except gio.Error, inst:
-            logger.error("%s did not unmount: %s", name, inst)
-
-            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)
-                try:
-                    n.show()
-                except:
-                    logger.error("Unable to display message using notification system")
-
-
-def create_cairo_image_surface(pil_image, image_width, image_height):
-        imgd = pil_image.tobytes("raw","BGRA", 0, 1)
-        data = array.array('B',imgd)
-        stride = image_width * 4
-        image = cairo.ImageSurface.create_for_data(data, cairo.FORMAT_ARGB32,
-                                            image_width, image_height, stride)
-        return image
-
-class ThumbnailCellRenderer(gtk.CellRenderer):
-    __gproperties__ = {
-        "image": (gobject.TYPE_PYOBJECT, "Image",
-        "Image", gobject.PARAM_READWRITE),
-
-        "filename": (gobject.TYPE_STRING, "Filename",
-        "Filename", '', gobject.PARAM_READWRITE),
-
-        "status": (gtk.gdk.Pixbuf, "Status",
-        "Status", gobject.PARAM_READWRITE),
-    }
-
-    def __init__(self, checkbutton_height):
-        gtk.CellRenderer.__init__(self)
-        self.image = None
-
-        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
-        #either side
-        #~ cairo_context.rectangle(x-1, y-1, w+2, h+2)
-        #~ cairo_context.clip()
-
-        #fill in the background with dark grey
-        #this ensures that a selected cell's fill does not make
-        #the text impossible to read
-        #~ cairo_context.rectangle(x, y, w, h)
-        #~ cairo_context.set_source_rgb(0.267, 0.267, 0.267)
-        #~ cairo_context.fill()
-
-        #image width and height
-        image_w = self.image.size[0]
-        image_h = self.image.size[1]
-
-        #center the image horizontally
-        #bottom align vertically
-        #top left and right corners for the image:
-        image_x = x + ((w - image_w) / 2)
-        image_y = y + self.image_area_size - image_h
-
-        #convert PIL image to format suitable for cairo
-        image = create_cairo_image_surface(self.image, image_w, image_h)
-
-        # draw a light grey border of 1px around the image
-        cairo_context.set_source_rgb(0.66, 0.66, 0.66) #light grey, #a9a9a9
-        cairo_context.set_line_width(1)
-        cairo_context.rectangle(image_x-.5, image_y-.5, image_w+1, image_h+1)
-        cairo_context.stroke()
-
-        # draw a thin border around each cell
-        #~ 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()
-
-        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
-        font_family = pango.AttrFamily('sans', 0, -1)
-        attr = pango.AttrList()
-        attr.insert(fg_color)
-        attr.insert(font_size)
-        attr.insert(font_family)
-        layout.set_attributes(attr)
-
-        layout.set_text(self.filename)
-
-        context.move_to(text_x, text_y)
-        context.show_layout(layout)
-
-        #status
-        cairo_context.set_source_pixbuf(self.status, x, y + self.image_area_size + 10)
-        cairo_context.paint()
-
-    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):
-        gtk.IconView.__init__(self)
-        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.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
-        self.FILETYPE_COL = 5
-        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
-        checkbutton.props.xalign = 0.0
-        checkbutton.connect('toggled', self.on_checkbutton_toggled)
-        self.pack_end(checkbutton, expand=False)
-
-        self.add_attribute(checkbutton, "active", 1)
-        self.add_attribute(checkbutton, "visible", 6)
-
-        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)
-        self.add_attribute(image, "filename", 3)
-        self.add_attribute(image, "status", 8)
-
-        #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
-        """
-        self.liststore = gtk.ListStore(
-             gobject.TYPE_PYOBJECT, # 0 PIL thumbnail
-             gobject.TYPE_BOOLEAN,  # 1 selected or not
-             str,                   # 2 unique id
-             str,                   # 3 file name
-             int,                   # 4 timestamp for sorting, converted float
-             int,                   # 5 file type i.e. photo or video
-             gobject.TYPE_BOOLEAN,  # 6 visibility of checkbutton
-             int,                   # 7 status of download
-             gtk.gdk.Pixbuf,        # 8 status icon
-             )
-
-    def _setup_icons(self):
-        # icons to be displayed in status column
-
-        size = 16
-        # standard icons
-        failed = self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU)
-        self.download_failed_icon = failed.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
-        error = self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU)
-        self.error_icon = error.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
-        warning = self.render_icon(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_MENU)
-        self.warning_icon = warning.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
-
-        # Rapid Photo Downloader specific icons
-        self.downloaded_icon = gtk.gdk.pixbuf_new_from_file_at_size(
-               paths.share_dir('glade3/rapid-photo-downloader-downloaded.svg'),
-               size, size)
-        self.download_pending_icon = gtk.gdk.pixbuf_new_from_file_at_size(
-               paths.share_dir('glade3/rapid-photo-downloader-download-pending.png'),
-               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
-        """
-        if status == STATUS_WARNING:
-            status_icon = self.warning_icon
-        elif status == STATUS_CANNOT_DOWNLOAD:
-            status_icon = self.error_icon
-        elif status == STATUS_DOWNLOADED:
-            status_icon =  self.downloaded_icon
-        elif status == STATUS_NOT_DOWNLOADED:
-            status_icon = self.not_downloaded_icon
-        elif status in [STATUS_DOWNLOADED_WITH_WARNING, STATUS_BACKUP_PROBLEM]:
-            status_icon = self.downloaded_with_warning_icon
-        elif status in [STATUS_DOWNLOAD_FAILED, STATUS_DOWNLOAD_AND_BACKUP_FAILED]:
-            status_icon = self.downloaded_with_error_icon
-        elif status == STATUS_DOWNLOAD_PENDING:
-            status_icon = self.download_pending_icon
-        else:
-            logger.critical("FIXME: unknown status: %s", status)
-            status_icon = self.not_downloaded_icon
-        return status_icon
-
-    def sort_by_timestamp(self):
-        self.liststore.set_sort_column_id(self.TIMESTAMP_COL, gtk.SORT_ASCENDING)
-
-    def on_selection_changed(self, iconview):
-        """
-        Allow selections by row (and not GTK default by square) when user is
-        dragging the mouse or using the keyboard to select
-        """
-        selections = self.get_selected_items()
-        if len(selections) > 1:
-            previous_sel = selections[0][0] + 1
-            # seleted items list always starts with the highest selected item
-            for selection in selections:
-                current_sel = selection[0]
-                if current_sel <> (previous_sel-1):
-                    for i in range(previous_sel-1, current_sel, -1):
-                        self.select_path(i)
-                previous_sel = current_sel
-        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)
-        unique_id = rpd_file.unique_id
-        scan_pid = rpd_file.scan_pid
-
-        timestamp = int(rpd_file.modification_time)
-
-        iter = self.liststore.append((thumbnail_icon,
-                                      True,
-                                      unique_id,
-                                      rpd_file.display_name,
-                                      timestamp,
-                                      rpd_file.file_type,
-                                      True,
-                                      STATUS_NOT_DOWNLOADED,
-                                      self.not_downloaded_icon
-                                      ))
-
-        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
-        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):
-        """
-        """
-        iter = self.liststore.get_iter(path)
-        self.show_preview(iter=iter)
-        self.advance_get_preview_image(iter)
-
-
-    def _get_preview(self, unique_id, rpd_file):
-        if unique_id not in self.previews_being_fetched:
-            #check if preview should be from a downloaded file, or the source
-            if rpd_file.status in DOWNLOADED:
-                file_location = rpd_file.download_full_file_name
-                thm_file_name = rpd_file.download_thm_full_name
-            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 len(self.liststore):
-            if unique_id is not None:
-                iter = self.get_iter_from_unique_id(unique_id)
-            elif iter is not None:
-                unique_id = self.get_unique_id_from_iter(iter)
-            else:
-                # neither an iter or a unique_id were passed
-                # use iter from first selected file
-                # if none is selected, choose the first file
-                selected = self.get_selected_items()
-                if selected:
-                    path = selected[0]
-                else:
-                    path = 0
-                iter = self.liststore.get_iter(path)
-                unique_id = self.get_unique_id_from_iter(iter)
-
-
-            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:
-                    preview_image = self.thumbnails[unique_id]
-                else:
-                    preview_image = self.get_stock_icon(rpd_file.file_type)
-
-            checked = self.liststore.get_value(iter, self.SELECTED_COL)
-            include_checkbutton_visible = rpd_file.status == STATUS_NOT_DOWNLOADED
-            self.rapid_app.show_preview_image(unique_id, preview_image,
-                                                include_checkbutton_visible, checked)
-
-    def _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:
-            row = len(self.liststore)-1
-        else:
-            row -= 1
-        iter = self.liststore.get_iter(row)
-        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]:
-                if file_type is not None:
-                    if row[self.FILETYPE_COL] == file_type:
-                        row[self.SELECTED_COL] = check_all
-                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
-        intend to download, else returns False.
-        """
-        for row in self.liststore:
-            if row[self.SELECTED_COL]:
-                rpd_file = self.rpd_files[row[self.UNIQUE_ID_COL]]
-                if rpd_file.status not in DOWNLOADED:
-                    return True
-        return False
-
-    def 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()
-        if scan_pid is None:
-            for row in self.liststore:
-                if row[self.SELECTED_COL]:
-                    rpd_file = self.rpd_files[row[self.UNIQUE_ID_COL]]
-                    if rpd_file.status not in DOWNLOADED:
-                        scan_pid = rpd_file.scan_pid
-                        if scan_pid in files:
-                            files[scan_pid].append(rpd_file)
-                        else:
-                            files[scan_pid] = [rpd_file,]
-        else:
-            files[scan_pid] = []
-            for unique_id in self.process_index[scan_pid]:
-                rpd_file = self.rpd_files[unique_id]
-                if rpd_file.status not in DOWNLOADED:
-                    iter = self.get_iter_from_unique_id(unique_id)
-                    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
-        scan_pid
-        """
-        i = 0
-        for unique_id in self.process_index[scan_pid]:
-            rpd_file = self.rpd_files[unique_id]
-            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
-        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):
-        """
-        Sets status to download pending and updates thumbnails display
-        """
-        for scan_pid in files_by_scan_pid:
-            for rpd_file in files_by_scan_pid[scan_pid]:
-                unique_id = rpd_file.unique_id
-                self.rpd_files[unique_id].status = STATUS_DOWNLOAD_PENDING
-                iter = self.get_iter_from_unique_id(unique_id)
-                if not self.rapid_app.auto_start_is_on:
-                    # don't make the checkbox invisible immediately when on auto start
-                    # otherwise the box can be rendred at the wrong size, as it is
-                    # realized after the checkbox has already been made invisible
-                    self.liststore.set_value(iter, self.CHECKBUTTON_VISIBLE_COL, False)
-                self.liststore.set_value(iter, self.SELECTED_COL, False)
-                self.liststore.set_value(iter, self.DOWNLOAD_STATUS_COL, STATUS_DOWNLOAD_PENDING)
-                icon = self.get_status_icon(STATUS_DOWNLOAD_PENDING)
-                self.liststore.set_value(iter, self.STATUS_ICON_COL, icon)
-
-    def select_image(self, unique_id):
-        iter = self.get_iter_from_unique_id(unique_id)
-        path = self.liststore.get_path(iter)
-        self.select_path(path)
-        self.scroll_to_path(path, use_align=False, row_align=0.5, col_align=0.5)
-
-    def get_stock_icon(self, file_type):
-        if file_type == rpdfile.FILE_TYPE_PHOTO:
-            return self.stock_photo_thumbnails.stock_thumbnail_image_icon
-        else:
-            return self.stock_video_thumbnails.stock_thumbnail_image_icon
-
-    def update_status_post_download(self, rpd_file):
-        iter = self.get_iter_from_unique_id(rpd_file.unique_id)
-        self.liststore.set_value(iter, self.DOWNLOAD_STATUS_COL, rpd_file.status)
-        icon = self.get_status_icon(rpd_file.status)
-        self.liststore.set_value(iter, self.STATUS_ICON_COL, icon)
-        self.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
-        """
-        if scan_pid in self.process_index:
-            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)
-
-    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
-        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:
-                self._reset_thumbnail_tracking_and_display()
-            else:
-                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
-        """
-        self.previews_being_fetched.remove(unique_id)
-        if preview_full_size:
-            preview_image = preview_full_size.get_image()
-            self.previews[unique_id] = preview_image
-            self.rapid_app.update_preview_image(unique_id, preview_image)
-
-            # 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")
-            self.set_model(None)
-            self._create_liststore()
-
-            self.treerow_index = {}
-            self.process_index = {}
-
-            self.rpd_files = {}
-        else:
-            if scan_pid in self.process_index:
-                for unique_id in self.process_index[scan_pid]:
-                    rpd_file = self.rpd_files[unique_id]
-                    if not keep_downloaded_files or not rpd_file.status in DOWNLOADED:
-                        treerowref = self.treerow_index[rpd_file.unique_id]
-                        path = treerowref.get_path()
-                        iter = self.liststore.get_iter(path)
-                        self.liststore.remove(iter)
-                        del self.treerow_index[rpd_file.unique_id]
-                        del self.rpd_files[rpd_file.unique_id]
-                if not keep_downloaded_files or not len(self.process_index[scan_pid]):
-                    del self.process_index[scan_pid]
-
-    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,
-                                   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
-        immediately terminate
-        """
-        for p in self.processes():
-            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
-        """
-        requested = False
-        for p in self.processes():
-            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.
-
-        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,
-                                                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
-        """
-        i = 0
-        for p in self.processes():
-            if p[0].is_alive():
-                i += 1
-        return i
-
-
-class ScanManager(TaskManager):
-
-    def __init__(self, results_callback, batch_size,
-                 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,
-                       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,
-                                task_process_conn, terminate_queue, run_event)
-        scan.start()
-        self._processes.append((scan, terminate_queue, run_event))
-        self.add_device_function(scan.pid, device,
-            # This refers to when a device like a hard drive is having its contents scanned,
-            # looking for photos or videos. It is visible initially in the progress bar for each device
-            # (which normally holds "x photos and videos").
-            # It maybe displayed only briefly if the contents of the device being scanned is small.
-            progress_bar_text=_('scanning...'))
-
-        return scan.pid
-
-class CopyFilesManager(TaskManager):
-
-    def _initiate_task(self, task, task_results_conn,
-                       task_process_conn, terminate_queue, run_event):
-        photo_download_folder = task[0]
-        video_download_folder = task[1]
-        scan_pid = task[2]
-        files = task[3]
-        verify_files = task[4]
-        modify_files_during_download = task[5]
-        modify_pipe = task[6]
-
-        copy_files = copyfiles.CopyFiles(photo_download_folder,
-                                video_download_folder,
-                                files,
-                                verify_files,
-                                modify_files_during_download,
-                                modify_pipe,
-                                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,
-                                          run_event)
-        generator.start()
-        self._processes.append((generator, terminate_queue, run_event))
-        return generator.pid
-
-class FileModifyManager(TaskManager):
-    """Handles the modification or verification of of downloaded files before they are renamed
-    Duplex, multiprocess, similar to BackupFilesManager
-    """
-    def __init__(self, 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,
-                       terminate_queue, run_event):
-        scan_pid = task[0]
-        auto_rotate_jpeg = task[1]
-        focal_length = task[2]
-        verify_file = task[3]
-        refresh_md5_on_file_change = task[4]
-
-        file_modify = filemodify.FileModify(auto_rotate_jpeg, focal_length,
-                                        verify_file, refresh_md5_on_file_change,
-                                        task_process_conn, terminate_queue,
-                                        run_event)
-        file_modify.start()
-        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):
-        TaskManager.__init__(self, results_callback, batch_size)
-        self.backup_devices_by_path = {}
-
-    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, 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,
-                                        run_event)
-        backup_files.start()
-        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,
-                                                verify_file,
-                                                download_count):
-
-        if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
-            logger.debug("Backing up photo %s", rpd_file.download_name)
-        else:
-            logger.debug("Backing up video %s", rpd_file.download_name)
-
-        for path in self.backup_devices_by_path:
-            backup_type = self.backup_devices_by_path[path][2]
-            do_backup = ((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))
-            if do_backup:
-                logger.debug("Backing up to %s", path)
-            else:
-                logger.debug("Not backing up to %s", path)
-            # Even if not going to backup to this device, need to send it anyway so
-            # progress bar can be updated. Not this most efficient but the
-            # code is much more simple
-            task_results_conn = self.backup_devices_by_path[path][0]
-            task_results_conn.send((move_succeeded, do_backup, rpd_file,
-                                path_suffix,
-                                backup_duplicate_overwrite,
-                                verify_file, download_count))
-
-    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):
-        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
-
-class SubfolderFileManager(SingleInstanceTaskManager):
-    """
-    Manages the daemon process that renames files and creates subfolders
-    """
-    def __init__(self, results_callback, sequence_values):
-        SingleInstanceTaskManager.__init__(self, results_callback)
-        self._subfolder_file = subfolderfile.SubfolderFile(self.task_process_conn,
-                                                sequence_values)
-        self._subfolder_file.start()
-        logger.debug("SubfolderFile PID: %s", self._subfolder_file.pid)
-
-    def rename_file_and_move_to_subfolder(self, download_succeeded,
-            download_count, rpd_file):
-
-        logger.debug("Sending file for rename: %s.", download_count)
-        self.task_results_conn.send((download_succeeded, download_count,
-            rpd_file))
-
-
-    def task_results(self, source, condition):
-        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
-        w = event.area.width
-        h = event.area.height
-
-        #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()
-
-        if not self.base_image:
-            return False
-
-        frame_aspect = float(w) / h
-
-        if frame_aspect > self.base_image_aspect:
-            # Frame is wider than image
-            height = h
-            width = int(height * self.base_image_aspect)
-        else:
-            # Frame is taller than image
-            width = w
-            height = int(width / self.base_image_aspect)
-
-        #resize image
-        pil_image = self.base_image.copy()
-        if self.base_image_w < width or self.base_image_h < height:
-            logger.debug("Upsizing image")
-            pil_image = tn.upsize_pil(pil_image, (width, height))
-        else:
-            logger.debug("Downsizing image")
-            tn.downsize_pil(pil_image, (width, height))
-
-        #image width and height
-        image_w = pil_image.size[0]
-        image_h = pil_image.size[1]
-
-        #center the image horizontally and vertically
-        #top left and right corners for the image:
-        image_x = x + ((w - image_w) / 2)
-        image_y = y + ((h - image_h) / 2)
-
-        image = create_cairo_image_surface(pil_image, image_w, image_h)
-        cairo_context.set_source_surface(image, image_x, image_y)
-        cairo_context.paint()
-
-        return False
-
-
-
-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_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,
-                          checked=None):
-        """
-        """
-        self.preview_image.set_image(pil_image)
-        self.unique_id = unique_id
-        if checked is not None:
-            self.download_this_checkbutton.set_active(checked)
-            self.download_this_checkbutton.grab_focus()
-
-        if include_checkbutton_visible is not None:
-            self.download_this_checkbutton.props.visible = include_checkbutton_visible
-
-    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):
-
-        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()
-
-        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,
-                           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)
-
-        # save window and component sizes
-        self.prefs.vpaned_pos = self.main_vpaned.get_position()
-
-        x, y, width, height = self.rapidapp.get_allocation()
-        self.prefs.main_window_size_x = width
-        self.prefs.main_window_size_y = height
-
-        self.prefs.set_downloads_today_from_tracker(self.downloads_today_tracker)
-
-        gtk.main_quit()
-
-    def _terminate_processes(self, terminate_file_copies=False):
-
-        if terminate_file_copies:
-            logger.info("Terminating all processes...")
-
-        scan_termination_requested = self.scan_manager.request_termination()
-        thumbnails_termination_requested = self.thumbnails.thumbnail_manager.request_termination()
-        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
-                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):
-                time.sleep(1)
-                # must try again, just in case a new scan has meanwhile started!
-                self.scan_manager.request_termination()
-                self.thumbnails.thumbnail_manager.terminate_forcefully()
-                self.scan_manager.terminate_forcefully()
-                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
-    # # #
-
-    def on_download_this_checkbutton_toggled(self, checkbutton):
-        value = checkbutton.get_active()
-        self.thumbnails.set_selected(self.preview_image.unique_id, value)
-        self.set_download_action_sensitivity()
-
-    def on_preview_eventbox_button_press_event(self, widget, event):
-
-        if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
-            self.show_thumbnails()
-
-    def on_show_thumbnails_action_activate(self, action):
-        logger.debug("on_show_thumbnails_action_activate")
-        self.show_thumbnails()
-
-    def on_show_image_action_activate(self, action):
-        logger.debug("on_show_image_action_activate")
-        self.thumbnails.show_preview()
-
-    def on_check_all_action_activate(self, action):
-        self.thumbnails.check_all(check_all=True)
-
-    def on_uncheck_all_action_activate(self, action):
-        self.thumbnails.check_all(check_all=False)
-
-    def on_check_all_photos_action_activate(self, action):
-        self.thumbnails.check_all(check_all=True,
-                                  file_type=rpdfile.FILE_TYPE_PHOTO)
-
-    def on_check_all_videos_action_activate(self, action):
-        self.thumbnails.check_all(check_all=True,
-                                  file_type=rpdfile.FILE_TYPE_VIDEO)
-
-    def on_quit_action_activate(self, action):
-        self.on_rapidapp_destroy(widget=self.rapidapp, data=None)
-
-    def on_refresh_action_activate(self, action):
-        self.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")
-            self.main_notebook.set_current_page(1)
-        self.preview_image.set_preview_image(unique_id, image, include_checkbutton_visible, checked)
-        self.next_image_action.set_sensitive(True)
-        self.prev_image_action.set_sensitive(True)
-
-    def update_preview_image(self, unique_id, image):
-        self.preview_image.update_preview_image(unique_id, image)
-
-    def show_thumbnails(self):
-        logger.debug("Switching to thumbnails display")
-        self.main_notebook.set_current_page(0)
-        self.thumbnails.select_image(self.preview_image.unique_id)
-        self.next_image_action.set_sensitive(False)
-        self.prev_image_action.set_sensitive(False)
-
-
-    def on_next_image_action_activate(self, action):
-        if self.preview_image.unique_id is not None:
-            self.thumbnails.show_next_image(self.preview_image.unique_id)
-
-    def on_prev_image_action_activate(self, action):
-        if self.preview_image.unique_id is not None:
-            self.thumbnails.show_prev_image(self.preview_image.unique_id)
-
-    def display_scan_thumbnails(self):
-        """
-        If all the scans are complete, sets the sort order and displays
-        thumbnails in the icon view
-        """
-        if self.scan_manager.no_tasks == 0:
-            self.thumbnails.sort_by_timestamp()
-            self.thumbnails.display_thumbnails()
-
-
-    # # #
-    # Volume management
-    # # #
-
-    def start_volume_monitor(self):
-        if not self.vmonitor:
-            self.vmonitor = gio.volume_monitor_get()
-            self.vmonitor.connect("mount-added", self.on_mount_added)
-            self.vmonitor.connect("mount-removed", self.on_mount_removed)
-
-
-    def _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
-        any paths to ignore while scanning
-        """
-        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
-        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.
-        """
-        l = self.prefs.device_location
-        if l in ['/media', '/run', os.path.expanduser('~'), '/']:
-            logger.info("Prompting whether to download from %s", l)
-            if l == '/':
-                #this location is a human readable explanation for /, and is inserted into Downloading from %(location)s
-                l = _('the root of the file system')
-            c = preferencesdialog.QuestionDialog(parent_window=self.rapidapp,
-                    title=_('Rapid Photo Downloader'),
-                    #message in dialog box which asks the user if they really want to be downloading from this location
-                    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)
-            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,
-        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
-        """
-
-        if self.using_volume_monitor():
-            self.start_volume_monitor()
-
-        self.clear_non_running_downloads()
-        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
-            for mount in self.vmonitor.get_mounts():
-                if not mount.is_shadowed():
-                    path = mount.get_root().get_path()
-                    if path:
-                        if (path in self.prefs.device_blacklist and
-                                    self.search_for_PSD()):
-                            logger.info("blacklisted device %s ignored", mount.get_name())
-                        else:
-                            logger.info("Detected %s", mount.get_name())
-                            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
-                                  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
-            path = self.prefs.device_location
-            if path:
-                logger.info("Using manually specified path %s", path)
-                if utilities.is_directory(path):
-                    mounts.append((path, None))
-                else:
-                    logger.error("Download path does not exist: %s", path)
-
-        if self.prefs.backup_images:
-            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_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 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.
-        Depending on the folder the user has chosen, the paths for photo and
-        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
-        self.backup_devices[self.prefs.backup_location] = (None, PHOTO_BACKUP)
-        if DOWNLOAD_VIDEO:
-            if self.prefs.backup_location <> self.prefs.backup_video_location:
-                self.backup_devices[self.prefs.backup_video_location] = (None, VIDEO_BACKUP)
-                logger.info("Backing up photos to %s", self.prefs.backup_location)
-                logger.info("Backing up videos to %s", self.prefs.backup_video_location)
-            else:
-                # videos and photos are being backed up to the same location
-                self.backup_devices[self.prefs.backup_location] = (None, PHOTO_VIDEO_BACKUP)
-                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
-        """
-        for path in self.backup_devices:
-            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):
-        """ 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,
-                # or the actual preferences will not be updated!!
-                if len(self.prefs.device_whitelist):
-                    self.prefs.device_whitelist = self.prefs.device_whitelist + [path]
-                else:
-                    self.prefs.device_whitelist = [path]
-            scan_pid = self.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]
-
-    def search_for_PSD(self):
-        """
-        Check to see if user preferences are to automatically search for
-        Portable Storage Devices or not
-        """
-        return self.prefs.device_autodetection_psd and self.prefs.device_autodetection
-
-    def check_if_backup_mount(self, path):
-        """
-        Checks to see if backups are enabled and path represents a valid backup
-        location. 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)
-        """
-        if self.prefs.backup_images:
-            if self.prefs.backup_device_autodetection:
-                # 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
-                # determine this.
-                # The directory must be writable.
-                photo_path = os.path.join(path, self.prefs.backup_identifier)
-                p_backup = os.path.isdir(photo_path) and os.access(photo_path, os.W_OK)
-                if DOWNLOAD_VIDEO:
-                    video_path = os.path.join(path, self.prefs.video_backup_identifier)
-                    v_backup = os.path.isdir(video_path) and os.access(video_path, os.W_OK)
-                else:
-                    v_backup = False
-                if p_backup and v_backup:
-                    logger.info("Photos and videos will be backed up to %s", path)
-                    return (True, PHOTO_VIDEO_BACKUP)
-                elif p_backup:
-                    logger.info("Photos will be backed up to %s", path)
-                    return (True, PHOTO_BACKUP)
-                elif v_backup:
-                    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
-                if os.access(self.prefs.backup_location, os.W_OK):
-                    return (True, PHOTO_BACKUP)
-            elif path == self.prefs.backup_video_location:
-                # user manually specified the path
-                if os.access(self.prefs.backup_video_location, os.W_OK):
-                    return (True, VIDEO_BACKUP)
-        return (False, None)
-
-    def update_no_backup_devices(self):
-        self.no_photo_backup_devices = 0
-        self.no_video_backup_devices = 0
-        for path, value in self.backup_devices.iteritems():
-            backup_type = value[1]
-            if backup_type == PHOTO_BACKUP:
-                self.no_photo_backup_devices += 1
-            elif backup_type == VIDEO_BACKUP:
-                self.no_video_backup_devices += 1
-            else:
-                #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",
-                    self.no_photo_backup_devices, self.no_video_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
-        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:
-                self._setup_manual_backup()
-            else:
-                for mount in self.vmonitor.get_mounts():
-                    if not mount.is_shadowed():
-                        path = mount.get_root().get_path()
-                        if path:
-                            is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
-                            if is_backup_mount:
-                                # 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
-                self.prefs.backup_device_autodetection
-                ))
-
-    def on_mount_added(self, vmonitor, mount):
-        """
-        callback run when gio indicates a new volume
-        has been mounted
-        """
-
-
-        if mount.is_shadowed():
-            # ignore this type of mount
-            return
-
-        path = mount.get_root().get_path()
-        if path is not None:
-
-            if path in self.prefs.device_blacklist and self.search_for_PSD():
-                logger.info("Device %(device)s (%(path)s) ignored" % {
-                            'device': mount.get_name(), 'path': path})
-            else:
-                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
-                        name = self._backup_device_name(path)
-                        self.backup_manager.add_device(path, name, backup_file_type)
-                        self.update_no_backup_devices()
-                        self.display_free_space()
-
-                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 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,
-                                      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()
-                else:
-                    self.start_download()
-            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():
-            sensitivity = False
-            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
-        """
-
-        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()
-        self.prompting_for_job_code = False
-
-    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,
-                    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()
-
-        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
-        """
-        # Track download sizes and other values for each device.
-        # (Scan id acts as an index to each device. A device could be scanned
-        #  more than once).
-        self.download_tracker = downloadtracker.DownloadTracker()
-
-        # 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 or verify files during download"""
-        return self.prefs.auto_rotate_jpeg or (self.focal_length is not None) or self.prefs.verify_file
-
-
-    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)
-        self.check_file_types_to_be_downloaded(files_by_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") % {
-                        'folder1': invalid_dirs[0], 'folder2': invalid_dirs[1]}
-            else:
-                msg = _("This download folder is invalid:\n%s") % invalid_dirs[0]
-            self.log_error(config.CRITICAL_ERROR, _("Download cannot proceed"),
-                msg)
-        else:
-            missing_destinations = self.backup_destinations_missing()
-            if missing_destinations is not None:
-                # Warn user that they have specified that they want to backup a file type, but no such folder exists on backup devices
-                if not missing_destinations[0]:
-                    logger.warning("No backup device contains a valid folder for backing up photos")
-                    msg = _("No backup device contains a valid folder for backing up %(filetype)s") % {'filetype': _('photos')}
-                else:
-                    logger.warning("No backup device contains a valid folder for backing up videos")
-                    msg = _("No backup device contains a valid folder for backing up %(filetype)s") % {'filetype': _('videos')}
-
-                self.log_error(config.WARNING, _("Backup problem"), msg)
-
-            # 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()
-
-            # 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):
-        """
-        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,
-                                                    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,
-                                        rpdfile.FILE_TYPE_VIDEO,
-                                        return_file_count=True)
-            if no_videos_to_download:
-                video_download_folder = self.prefs.video_download_folder
-            else:
-                video_download_folder = None
-        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,
-                                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
-
-        verify_file = self.prefs.verify_file
-        if verify_file:
-            # since a file might be modified in the file modify process,
-            # if it will be backed up, need to refresh the md5 once it has
-            # been modified
-            refresh_md5_on_file_change = self.prefs.backup_images
-        else:
-            refresh_md5_on_file_change = False
-        modify_files_during_download = self.modify_files_during_download()
-        if modify_files_during_download:
-            self.file_modify_manager.add_task((scan_pid, self.prefs.auto_rotate_jpeg, self.focal_length, verify_file, refresh_md5_on_file_change))
-            modify_pipe = self.file_modify_manager.get_modify_pipe(scan_pid)
-        else:
-            modify_pipe = None
-
-
-        # Initiate copy files process
-        self.copy_files_manager.add_task((photo_download_folder,
-                              video_download_folder, scan_pid,
-                              files, verify_file,
-                              modify_files_during_download,
-                              modify_pipe))
-
-    def copy_files_results(self, source, condition):
-        """
-        Handle results from copy files process
-        """
-        #FIXME: must handle early termination / pause of copy files process
-        connection = self.copy_files_manager.get_pipe(source)
-        conn_type, msg_data = connection.recv()
-        if conn_type == rpdmp.CONN_PARTIAL:
-            msg_type, data = msg_data
-
-            if msg_type == rpdmp.MSG_TEMP_DIRS:
-                scan_pid, photo_temp_dir, video_temp_dir = data
-                self.temp_dirs_by_scan_pid[scan_pid] = (photo_temp_dir, video_temp_dir)
-
-                # Report which temporary directories are being used for this
-                # download
-                if photo_temp_dir and video_temp_dir:
-                    logger.debug("Using temp dirs %s (photos) & %s (videos)",
-                                photo_temp_dir, video_temp_dir)
-                elif photo_temp_dir:
-                    logger.debug("Using temp dir %s (photos)",
-                                photo_temp_dir)
-                else:
-                    logger.debug("Using temp dir %s (videos)",
-                                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,
-                                                             total_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:
-                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,
-                                              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)
-            rpd_file.strip_characters = self.prefs.strip_characters
-            rpd_file.download_folder = self.prefs.get_download_folder_for_file_type(rpd_file.file_type)
-            rpd_file.download_conflict_resolution = self.prefs.download_conflict_resolution
-            rpd_file.synchronize_raw_jpg = self.prefs.must_synchronize_raw_jpg()
-            rpd_file.job_code = self.job_code
-
-        # Call this even if download did not succeed e.g. file verification error
-        self.subfolder_file_manager.rename_file_and_move_to_subfolder(
-                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.
-
-        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)
-            return True
-        else:
-            # Process is complete, i.e. conn_type == rpdmp.CONN_COMPLETE
-            connection.close()
-            return False
-
-
-    def download_is_occurring(self):
-        """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, 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,
-                           rpd_file.error_msg, rpd_file.error_extra_detail)
-
-        if self.prefs.backup_images:
-            if self.backup_possible(rpd_file.file_type):
-                if self.prefs.backup_device_autodetection:
-                    if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
-                        path_suffix = self.prefs.backup_identifier
-                    else:
-                        path_suffix = self.prefs.video_backup_identifier
-                else:
-                    path_suffix = None
-
-                self.backup_manager.backup_file(move_succeeded, rpd_file,
-                                        path_suffix,
-                                        self.prefs.backup_duplicate_overwrite,
-                                        self.prefs.verify_file,
-                                        download_count)
-            else:
-                if rpd_file.status ==  config.STATUS_DOWNLOAD_FAILED:
-                    rpd_file.status = config.STATUS_DOWNLOAD_AND_BACKUP_FAILED
-                else:
-                    rpd_file.status = config.STATUS_BACKUP_PROBLEM
-
-                self.file_download_finished(move_succeeded, rpd_file)
-        else:
-            self.file_download_finished(move_succeeded, rpd_file)
-
-    def backup_possible(self, file_type):
-        if file_type == rpdfile.FILE_TYPE_PHOTO:
-            return self.no_photo_backup_devices > 0
-        elif file_type == rpdfile.FILE_TYPE_VIDEO:
-            return self.no_video_backup_devices > 0
-        else:
-            logger.critical("Unrecognized file type when determining if backup is possible")
-
-
-    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
-                 self.no_photo_backup_devices > 1) or
-                (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
-        """
-        connection = self.backup_manager.get_pipe(source)
-        conn_type, msg_data = connection.recv()
-        if conn_type == rpdmp.CONN_PARTIAL:
-            msg_type, data = msg_data
-
-            if msg_type == rpdmp.MSG_BYTES:
-                scan_pid, backup_pid, total_downloaded, chunk_downloaded = data
-                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, do_backup, 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 rely 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) and do_backup:
-                    self.log_error(config.SERIOUS_ERROR,
-                        rpd_file.error_title,
-                        rpd_file.error_msg, rpd_file.error_extra_detail)
-
-                if do_backup:
-                    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):
-                        logger.debug("File %s will not be backed up to any more locations", rpd_file.download_name)
-                        self.file_download_finished(backup_succeeded or not do_backup, rpd_file)
-            return True
-        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
-        """
-        scan_pid = rpd_file.scan_pid
-        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,
-                           rpd_file.error_msg, rpd_file.error_extra_detail)
-        elif self.prefs.auto_delete:
-            # 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,
-                                                        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")
-            self._clean_temp_dirs_for_scan_pid(scan_pid)
-            if self.prefs.auto_delete:
-                logger.debug("Auto deleting files")
-                self.auto_delete(scan_pid)
-                self.download_tracker.clear_auto_delete(scan_pid)
-            self.download_active_by_scan_pid.remove(scan_pid)
-            self.time_remaining.remove(scan_pid)
-            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())
-                                                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
-                elif secs == 60:
-                    message = _("About 1 minute remaining")
-                else:
-                    # Translators: in the text '%(minutes)i:%(seconds)02i', only the : should be translated, if needed.
-                    # '%(minutes)i' and '%(seconds)02i' should not be modified or left out. They are used to format and display the amount
-                    # of time the download has remainging, e.g. 'About 5:36 minutes remaining'
-                    message = _("About %(minutes)i:%(seconds)02i minutes remaining") % {'minutes': secs / 60, 'seconds': secs % 60}
-
-                self.rapid_statusbar.pop(self.statusbar_context_id)
-                self.rapid_statusbar.push(self.statusbar_context_id, message)
-
-    def 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):
-            f = gio.File(file)
-            try:
-                f.delete(cancellable=None)
-            except gio.Error, inst:
-                logger.error("Failure deleting file %s", file)
-                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
-        """
-        if (no_videos > 0) and (no_photos > 0):
-            v = _('photos and videos')
-        elif (no_videos == 0) and (no_photos == 0):
-            v = _('photos or videos')
-        elif no_videos > 0:
-            if no_videos > 1:
-                v = _('videos')
-            else:
-                v = _('video')
-        else:
-            if no_photos > 1:
-                v = _('photos')
-            else:
-                v = _('photo')
-        return v
-
-    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(
-                                            scan_pid, rpdfile.FILE_TYPE_VIDEO)
-        no_photos_failed = self.download_tracker.get_no_files_failed(
-                                            scan_pid, rpdfile.FILE_TYPE_PHOTO)
-        no_videos_failed = self.download_tracker.get_no_files_failed(
-                                            scan_pid, rpdfile.FILE_TYPE_VIDEO)
-        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")
-
-        if use_pynotify:
-            n = pynotify.Notification(notification_name, message)
-            n.set_icon_from_pixbuf(icon)
-
-            try:
-                n.show()
-            except:
-                logger.error("Unable to display message using notification system")
-
-    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,
-                            'numberdownloaded': _("%(filetype)s downloaded") % \
-                            {'filetype': filetype}}
-
-            # photo failures
-            photo_failures = self.download_tracker.total_photo_failures
-            if photo_failures:
-                filetype = self.file_types_by_number(photo_failures, 0)
-                message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                            {'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,
-                            'numberdownloaded': _("%(filetype)s downloaded") % \
-                            {'filetype': filetype}}
-
-            # video failures
-            video_failures = self.download_tracker.total_video_failures
-            if video_failures:
-                filetype = self.file_types_by_number(0, video_failures)
-                message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                            {'number': video_failures,
-                            'numberdownloaded': _("%(filetype)s failed to download") % \
-                            {'filetype': filetype}}
-
-            # warnings
-            warnings = self.download_tracker.total_warnings
-            if warnings:
-                message += "\n" + _("%(number)s %(numberdownloaded)s") % \
-                            {'number': warnings,
-                            'numberdownloaded': _("warnings")}
-
-            if use_pynotify:
-                n = pynotify.Notification(PROGRAM_NAME, message)
-                n.set_icon_from_pixbuf(self.application_icon)
-                try:
-                    n.show()
-                except:
-                    logger.error("Unable to display message using notification system")
-            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 self.backup_possible(file_type)):
-            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,
-                                  '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,
-                                  '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,
-                                        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):
-        """
-        Cleans all temp dirs if they exist
-        """
-        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
-        """
-        for temp_dir in self.temp_dirs_by_scan_pid[scan_pid]:
-            self._purge_dir(temp_dir)
-        del self.temp_dirs_by_scan_pid[scan_pid]
-
-    def _purge_dir(self, directory):
-        """
-        Deletes all files in the directory, and the directory itself.
-
-        Does not recursively traverse any subfolders in the directory.
-        """
-
-        if directory:
-            try:
-                path = gio.File(directory)
-                # first delete any files in the temp directory
-                # assume there are no directories in the temp directory
-                file_attributes = "standard::name,standard::type"
-                children = path.enumerate_children(file_attributes)
-                for child in children:
-                    f = path.get_child(child.get_name())
-                    f.delete(cancellable=None)
-                path.delete(cancellable=None)
-                logger.debug("Deleted directory %s", directory)
-            except gio.Error, inst:
-                logger.error("Failure deleting temporary folder %s", directory)
-                logger.error(inst)
-
-
-    # # #
-    # Preferences
-    # # #
-
-
-    def _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:
-            self.prefs.device_autodetection = True
-        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
-        # 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
-        # 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 /
-        # 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")
-
-        self.downloads_today_value = Value(c_int,
-                        self.downloads_today_tracker.get_raw_downloads_today())
-        self.downloads_today_date_value = Array(c_char,
-                        self.downloads_today_tracker.get_raw_downloads_today_date())
-        self.day_start_value = Array(c_char,
-                        self.downloads_today_tracker.get_raw_day_start())
-        self.refresh_downloads_today_value = Value(c_bool, False)
-        self.stored_sequence_value = Value(c_int, self.prefs.stored_sequence_no)
-        self.uses_stored_sequence_no_value = Value(c_bool, self.prefs.any_pref_uses_stored_sequence_no())
-        self.uses_session_sequece_no_value = Value(c_bool, self.prefs.any_pref_uses_session_sequece_no())
-        self.uses_sequence_letter_value = Value(c_bool, self.prefs.any_pref_uses_sequence_letter_value())
-
-        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()
-
-    def check_prefs_upgrade(self, running_version):
-        """
-        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
-                # 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",
-                                    self.prefs.backup_video_location)
-
-    def on_preference_changed(self, key, value):
-        """
-        Called when user changes the program's preferences
-        """
-        logger.debug("Preference change detected: %s", key)
-
-        if key == 'show_log_dialog':
-            self.menu_log_window.set_active(value)
-        elif key in ['device_autodetection', 'device_autodetection_psd',
-                     'device_location', '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',
-                     '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()
-            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.")
-
-        do_not_size_icon = False
-        self.notification_icon_size = 48
-        try:
-            info = pynotify.get_server_info()
-        except:
-            logger.warning("Desktop environment notification server is incorrectly configured.")
-        else:
-            try:
-                if info["name"] == 'notify-osd':
-                    do_not_size_icon = True
-            except:
-                pass
-
-        if do_not_size_icon:
-            self.application_icon = gtk.gdk.pixbuf_new_from_file(
-                        paths.share_dir('glade3/rapid-photo-downloader.svg'))
-        else:
-            self.application_icon = gtk.gdk.pixbuf_new_from_file_at_size(
-                    paths.share_dir('glade3/rapid-photo-downloader.svg'),
-                    self.notification_icon_size, self.notification_icon_size)
-
-    def _init_widgets(self):
-        """
-        Initialize widgets in the main window, and variables that point to them
-        """
-        builder = gtk.Builder()
-        builder.set_translation_domain(config.APP_NAME)
-        self.builder = builder
-        builder.add_from_file(paths.share_dir("glade3/rapid.ui"))
-        self.rapidapp = builder.get_object("rapidapp")
-        self.from_toolbar = builder.get_object("from_toolbar")
-        self.copy_toolbar = builder.get_object("copy_toolbar")
-        self.dest_toolbar = builder.get_object("dest_toolbar")
-        self.menu_toolbar = builder.get_object("menu_toolbar")
-        self.main_vpaned = builder.get_object("main_vpaned")
-        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")
-        self.device_collection_scrolledwindow = builder.get_object("device_collection_scrolledwindow")
-        self.next_image_action = builder.get_object("next_image_action")
-        self.prev_image_action = builder.get_object("prev_image_action")
-        self.menu_log_window = builder.get_object("menu_log_window")
-        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)
-
-        #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()
-        self.from_toolbar_label.add(from_label)
-        self.from_toolbar_label.set_is_important(True)
-        self.from_toolbar.insert(self.from_toolbar_label, 0)
-
-        self.auto_detect_button = gtk.ToggleToolButton()
-        self.auto_detect_button.set_is_important(True)
-        self.auto_detect_button.set_label(_("Auto Detect"))
-        self.from_toolbar.insert(self.auto_detect_button, 1)
-
-        self.from_filechooser_button = gtk.FileChooserButton(
-            _("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.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)
-        self.forward_image2 = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
-        self.forward_image3 = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
-        self.forward_image4 = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
-        self.forward_label = gtk.Label(" ")
-        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)
-
-        self.copy_hbox.pack_start(self.forward_label)
-        self.copy_hbox.pack_start(self.forward_image)
-        self.copy_hbox.pack_start(self.copy_button, expand=False, fill=False)
-        self.copy_hbox.pack_start(self.forward_image2)
-        self.copy_hbox.pack_start(self.forward_label2)
-        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)
-        self.move_hbox.pack_start(self.forward_label3)
-        self.move_hbox.pack_start(self.forward_image3)
-        self.move_hbox.pack_start(self.move_button, expand=False, fill=False)
-        self.move_hbox.pack_start(self.forward_image4)
-        self.move_hbox.pack_start(self.forward_label4)
-        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_toolbar.show_all()
-        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(
-                            gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
-        photo_dest_hbox.pack_start(self.photo_dest_label, expand=False, fill=False, padding=6)
-        photo_dest_hbox.pack_start(self.to_photo_filechooser_button)
-        self.to_photo_filechooser = gtk.ToolItem()
-        self.to_photo_filechooser.set_is_important(True)
-        self.to_photo_filechooser.set_expand(True)
-        self.to_photo_filechooser.add(photo_dest_hbox)
-        self.dest_toolbar.insert(self.to_photo_filechooser, 1)
-
-        video_dest_hbox = gtk.HBox()
-        self.video_dest_label = gtk.Label(_("Videos:"))
-        self.to_video_filechooser_button = gtk.FileChooserButton(
-                _("Select a folder to download videos to"))
-        self.to_video_filechooser_button.set_action(
-                        gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
-        video_dest_hbox.pack_start(self.video_dest_label, expand=False, fill=False, padding=6)
-        video_dest_hbox.pack_start(self.to_video_filechooser_button)
-        self.to_video_filechooser = gtk.ToolItem()
-        self.to_video_filechooser.set_is_important(True)
-        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.on_to_photo_filechooser_button_selection_changed)
-        #~ self.to_photo_filechooser_button.connect("file-set",
-                        #~ self.on_to_photo_filechooser_button_file_set)
-        #~ self.to_photo_filechooser_button.connect("current-folder-changed",
-                        #~ self.on_to_photo_filechooser_button_current_folder_changed)
-        self.to_video_filechooser_button.connect("selection-changed",
-                        self.on_to_video_filechooser_button_selection_changed)
-        self.dest_toolbar.show_all()
-
-    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)
-            self.forward_image2.set_visible(True)
-            self.forward_image3.set_visible(False)
-            self.forward_image4.set_visible(False)
-            self.forward_label.set_visible(False)
-            self.forward_label2.set_visible(False)
-            self.forward_label3.set_visible(True)
-            self.forward_label4.set_visible(True)
-        else:
-            self.forward_image.set_visible(False)
-            self.forward_image2.set_visible(False)
-            self.forward_image3.set_visible(True)
-            self.forward_image4.set_visible(True)
-            self.forward_label.set_visible(True)
-            self.forward_label2.set_visible(True)
-            self.forward_label3.set_visible(False)
-            self.forward_label4.set_visible(False)
-
-    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 = get_folder_selection(filechooserbutton)
-        if path and not self.rerun_setup_available_image_and_video_media:
-            self.prefs.device_location = path
-
-    def on_from_filechooser_button_file_set(self, button):
-        logger.debug("on_from_filechooser_button_file_set")
-
-    def on_to_photo_filechooser_button_file_set(self, filechooserbutton):
-        logger.debug("on_to_filechooser_button_file_set")
-
-    def on_to_photo_filechooser_button_selection_changed(self, filechooserbutton):
-        logger.debug("on_to_filechooser_button_selection_changed")
-        path = get_folder_selection(filechooserbutton)
-        #~ logger.debug("Path: %s", path)
-        if path:
-            self.prefs.download_folder = path
-
-    def on_to_photo_filechooser_button_current_folder_changed(self, filechooserbutton):
-        logger.debug("on_to_photo_filechooser_button_current_folder_changed")
-
-    def on_to_video_filechooser_button_selection_changed(self, filechooserbutton):
-        path = get_folder_selection(filechooserbutton)
-        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)
-
-    def toolbar_event(self, widget, toolbar):
-        pass
-
-
-
-    def _set_window_size(self):
-        """
-        Remember the window size from the last time the program was run, or
-        set a default size
-        """
-
-        if self.prefs.main_window_maximized:
-            self.rapidapp.maximize()
-            self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH,
-                                           config.DEFAULT_WINDOW_HEIGHT)
-        elif self.prefs.main_window_size_x > 0:
-            self.rapidapp.set_default_size(self.prefs.main_window_size_x, self.prefs.main_window_size_y)
-        else:
-            # set a default size
-            self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH,
-                                           config.DEFAULT_WINDOW_HEIGHT)
-
-
-    def _set_device_collection_size(self):
-        """
-        Set the size of the device collection scrolled window widget
-        """
-        if self.device_collection.map_process_to_row:
-            height = max(self.device_collection_viewport.size_request()[1], 24)
-            self.device_collection_scrolledwindow.set_size_request(-1,  height)
-            self.main_vpaned.set_position(height)
-        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]
-        register_iconsets(icon_list)
-
-    def _setup_error_icons(self):
-        """
-        hide display of warning and error symbols in the taskbar until they
-        are needed
-        """
-        self.error_image = self.builder.get_object("error_image")
-        self.warning_image = self.builder.get_object("warning_image")
-        self.warning_vseparator = self.builder.get_object("warning_vseparator")
-        self.error_image.hide()
-        self.warning_image.hide()
-        self.warning_vseparator.hide()
-
-    def enable_prefs_and_refresh(self, enabled):
-        """
-        If enable is true, then the user is able to activate the preferences
-        or refresh command.
-        The intention is to be able to disable this during a download
-        """
-        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
-        mounts will be used
-        """
-        message =  ''
-
-        paths = self.backup_devices.keys()
-        i = 0
-        v = len(paths)
-        prefix = ''
-        for b in paths:
-            if v > 1:
-                if i < (v -1)  and i > 0:
-                    prefix = ', '
-                elif i == (v - 1) :
-                    prefix = " " + _("and")  + " "
-            i += 1
-            message = "%s%s'%s'" % (message,  prefix, self.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
-        downloaded to.
-
-        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)
-        if photo_dir and video_dir:
-            same_file_system = self.same_file_system(self.prefs.download_folder,
-                                            self.prefs.video_download_folder)
-        else:
-            same_file_system = False
-
-        dirs = []
-        if photo_dir:
-            dirs.append((self.prefs.download_folder, _("photos")))
-        if video_dir and not same_file_system:
-            dirs.append((self.prefs.video_download_folder, _("videos")))
-
-        msg = ''
-        if len(dirs) > 1:
-            msg = ' ' + _('Free space:') + ' '
-
-        for i in range(len(dirs)):
-            dir_info = dirs[i]
-            folder = gio.File(dir_info[0])
-            file_info = folder.query_filesystem_info(gio.FILE_ATTRIBUTE_FILESYSTEM_FREE)
-            size = file_info.get_attribute_uint64(gio.FILE_ATTRIBUTE_FILESYSTEM_FREE)
-            free = format_size_for_user(bytes=size)
-            if len(dirs) > 1:
-                #(videos) or (photos) will be appended to the free space message displayed to the
-                #user in the status bar.
-                #you should only translate this if your language does not use parantheses
-                file_type = _("(%(file_type)s)") % {'file_type': dir_info[1]}
-
-                #Freespace available on the filesystem for downloading to
-                #Displayed in status bar message on main window
-                msg += _("%(free)s %(file_type)s") % {'free': free, 'file_type': file_type}
-                if i == 0:
-                    #Inserted in the middle of the statusbar message concerning the amount of freespace
-                    #Used to differentiate between two different file systems
-                    #e.g. Free space: 21.3GB (photos); 14.7GB (videos).
-                    msg += _("; ")
-                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).
-                    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 not self.prefs.backup_device_autodetection:
-                if self.prefs.backup_location == self.prefs.backup_video_location:
-                    if DOWNLOAD_VIDEO:
-                        # user manually specified the same location for photos and video backups
-                        msg2 = _('Backing up photos and videos to %(path)s') % {'path':self.prefs.backup_location}
-                    else:
-                        # user manually specified backup location
-                        msg2 = _('Backing up to %(path)s') % {'path':self.prefs.backup_location}
-                else:
-                    # user manually specified different locations for photo and video backups
-                    msg2 = _('Backing up photos to %(path)s and videos to %(path2)s') % {
-                             'path':self.prefs.backup_location,
-                             'path2': self.prefs.backup_video_location}
-            else:
-                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()
-
-
-    def on_menu_log_window_toggled(self, widget):
-        active = widget.get_active()
-        self.prefs.show_log_dialog = active
-        if active:
-            self.error_log.widget.show()
-        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
-    # # #
-
-    def files_of_type_present(self, files, file_type, return_file_count=False):
-        """
-        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
-        """
-        i = 0
-        for rpd_file in files:
-            if rpd_file.file_type == file_type:
-                if return_file_count:
-                    i += 1
-                else:
-                    return True
-        if not return_file_count:
-            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
-        """
-        photo_size = 0
-        video_size = 0
-        for rpd_file in files:
-            if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
-                photo_size += rpd_file.size
-            else:
-                video_size += rpd_file.size
-
-        return (photo_size, video_size)
-
-    def check_file_types_to_be_downloaded(self, files_by_scan_pid):
-        """Determines what types of files need to be downloaded, setting
-        self.downloading_photos and self.downloading_videos accordingly"""
-        self.downloading_photos = False
-        self.downloading_videos = False
-        while not self.downloading_photos and not self.downloading_videos:
-            for scan_pid in files_by_scan_pid:
-                files = files_by_scan_pid[scan_pid]
-                if not self.downloading_photos:
-                    if self.files_of_type_present(files, rpdfile.FILE_TYPE_PHOTO):
-                        self.downloading_photos = True
-                if not self.downloading_videos:
-                    if self.files_of_type_present(files, rpdfile.FILE_TYPE_VIDEO):
-                        self.downloading_videos = True
-
-
-    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.
-        """
-        valid = True
-        invalid_dirs = []
-
-        if self.downloading_photos:
-            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",
-                        self.prefs.download_folder)
-
-        if self.downloading_videos:
-            if not self.is_valid_download_dir(self.prefs.video_download_folder,
-                                                        is_photo_dir=False):
-                valid = False
-                invalid_dirs.append(self.prefs.video_download_folder)
-            else:
-                logger.debug("Video download folder is valid: %s",
-                        self.prefs.video_download_folder)
-
-
-        return (valid, invalid_dirs)
-
-    def backup_destinations_missing(self):
-        if self.prefs.backup_images and self.prefs.backup_device_autodetection:
-            photo_backup_ok = video_backup_ok = True
-            if self.downloading_photos and not self.backup_possible(rpdfile.FILE_TYPE_PHOTO):
-                photo_backup_ok = False
-            if self.downloading_videos and not self.backup_possible(rpdfile.FILE_TYPE_VIDEO):
-                video_backup_ok = False
-            if photo_backup_ok and video_backup_ok:
-                return None
-            else:
-                return (photo_backup_ok, video_backup_ok)
-        return None
-
-    def same_file_system(self, file1, file2):
-        """Returns True if the files / diretories are on the same file system
-        """
-        f1 = gio.File(file1)
-        f2 = gio.File(file2)
-        f1_info = f1.query_info(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
-        f1_id = f1_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
-        f2_info = f2.query_info(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
-        f2_id = f2_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
-        return f1_id == f2_id
-
-
-    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
-        """
-        valid = False
-        if is_photo_dir:
-            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",
-                             download_folder_type, path)
-                if show_error_in_log:
-                    severity = config.WARNING
-                    problem = _("%(file_type)s download folder does not exist") % {
-                                'file_type': download_folder_type}
-                    details = _("Folder: %s") % path
-                    self.log_error(severity, problem, details)
-            else:
-                file_attributes = "standard::type,access::can-read,access::can-write"
-                file_info = d.query_filesystem_info(file_attributes)
-                file_type = file_info.get_file_type()
-
-                if file_type != gio.FILE_TYPE_DIRECTORY and file_type != gio.FILE_TYPE_UNKNOWN:
-                    logger.error("%s download folder is invalid: %s",
-                                 download_folder_type, path)
-                    if show_error_in_log:
-                        severity = config.WARNING
-                        problem = _("%(file_type)s download folder is invalid") % {
-                                    'file_type': download_folder_type}
-                        details = _("Folder: %s") % path
-                        self.log_error(severity, problem, details)
-                else:
-                    # is the directory writable?
-                    try:
-                        temp_dir = tempfile.mkdtemp(prefix="rpd-tmp", dir=path)
-                        valid = True
-                    except:
-                        logger.error("%s is not writable", path)
-                        if show_error_in_log:
-                            severity = config.WARNING
-                            problem = _("%(file_type)s download folder is not writable") % {
-                                        'file_type': download_folder_type}
-                            details = _("Folder: %s") % path
-                            self.log_error(severity, problem, details)
-                    else:
-                        f = gio.File(temp_dir)
-                        f.delete(cancellable=None)
-
-        except gio.Error, inst:
-            logger.error("Error checking download directory %s", path)
-            logger.error(inst)
-
-        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.uses_stored_sequence_no_value,
-                           self.uses_session_sequece_no_value,
-                           self.uses_sequence_letter_value)
-
-        # 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.device_collection.add_device)
-
-        #process to copy files from source to destination
-        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
-            size, file_type_counter, scan_pid = data
-            size = format_size_for_user(bytes=size)
-            results_summary, file_types_present = file_type_counter.summarize_file_count()
-            self.download_tracker.set_file_types_present(scan_pid, file_types_present)
-            logger.info('Found %s' % results_summary)
-            logger.info('Files total %s' % size)
-            self.device_collection.update_device(scan_pid, size)
-            self.device_collection.update_progress(scan_pid, 0.0, results_summary, 0, 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"))
-                self.thumbnails.generate_thumbnails(scan_pid)
-            elif self.auto_start_is_on:
-                if self.need_job_code_for_naming and not self.job_code:
-                    self.get_job_code()
-                else:
-                    self.start_download(scan_pid=scan_pid)
-
-            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:
-            # partial results
-            if len(data) > self.batch_size:
-                logger.critical("incoming pipe length is unexpectedly long: %s" % len(data))
-            else:
-                size, file_type_counter, scan_pid, rpd_files = data
-                size = format_size_for_user(bytes=size)
-                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,
-                                        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):
-        if self.is_running():
-            self.rapidapp.present()
-        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.
-    # 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'))
-    parser.add_option("-q", "--quiet",  action="store_false", dest="verbose",  help=_("only output errors to the command line"))
-    # image file extensions are recognized RAW files plus TIFF and JPG
-    parser.add_option("-e",  "--extensions", action="store_true", dest="extensions", help=_("list photo and video file extensions the program recognizes and exit"))
-    parser.add_option("--focal-length", type=int, dest="focal_length", help="If an aperture value of 0.0 is encountered, the focal length metadata will be set to the number passed, and its aperture metadata to f/8")
-    parser.add_option("-a", "--auto-detect", action="store_true", dest="auto_detect", help=_("automatically detect devices from which to download, overwriting existing program preferences"))
-    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]=='/':
-            device_location = device_location[:-1]
-        logger.info("Device location set from command line: %s", device_location)
-    else:
-        device_location=None
-
-    if options.extensions:
-        extensions = ((rpdfile.PHOTO_EXTENSIONS, _("Photos:")), (rpdfile.VIDEO_EXTENSIONS, _("Videos:")))
-        for exts, file_type in extensions:
-            v = ''
-            for e in exts[:-1]:
-                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:
-        focal_length = None
-
-    logger.info("Rapid Photo Downloader %s", utilities.human_readable_version(config.version))
-    logger.info("Using pyexiv2 %s", metadataphoto.pyexiv2_version_info())
-    logger.info("Using exiv2 %s", metadataphoto.exiv2_version_info())
-    if metadataexiftool.EXIFTOOL_VERSION is None:
-        logger.info("Exiftool not detected")
-    else:
-        logger.info("Using exiftool %s", metadataexiftool.EXIFTOOL_VERSION)
-    if metadatavideo.HAVE_HACHOIR:
-        logger.info("Using hachoir %s", metadatavideo.version_info())
-
-
-    if focal_length:
-        logger.info("Focal length of %s will be used when an aperture of 0.0 is encountered", focal_length)
-
-    bus = dbus.SessionBus ()
-    request = bus.request_name (config.DBUS_NAME, dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
-    if request != dbus.bus.REQUEST_NAME_REPLY_EXISTS:
-        app = RapidApp(bus, '/', config.DBUS_NAME, focal_length=focal_length,
-        auto_detect=auto_detect, device_location=device_location)
-    else:
-        # this application is already running
-        print "Rapid Photo Downloader is already running"
-        object = bus.get_object (config.DBUS_NAME, "/")
-        app = dbus.Interface (object, config.DBUS_NAME)
-
-    app.start()
-
-if __name__ == "__main__":
-    start()