diff options
Diffstat (limited to 'rapid/rapid.py')
| -rwxr-xr-x | rapid/rapid.py | 3512 |
1 files changed, 3512 insertions, 0 deletions
diff --git a/rapid/rapid.py b/rapid/rapid.py new file mode 100755 index 0000000..e270a6a --- /dev/null +++ b/rapid/rapid.py @@ -0,0 +1,3512 @@ +#!/usr/bin/python +# -*- coding: latin1 -*- + +### Copyright (C) 2007, 2008, 2009 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +#needed for python 2.5, unneeded for python 2.6 +from __future__ import with_statement + +import sys +import os +import shutil +import time +import datetime +import atexit +import tempfile +import webbrowser +import operator + +import dbus +import dbus.bus +import dbus.service +from dbus.mainloop.glib import DBusGMainLoop +DBusGMainLoop(set_as_default=True) + +from threading import Thread, Lock +from thread import error as thread_error +from thread import get_ident + +import gtk.gdk as gdk +import pango + +try: + import gio + using_gio = True +except ImportError: + import gnomevfs + using_gio = False + + +import prefs +import paths +import gnomeglade + +from optparse import OptionParser + +import pynotify + +import ValidatedEntry + +import idletube as tube + +import config +import common +import misc +import higdefaults as hd + +from media import getDefaultPhotoLocation +from media import CardMedia + +import media + +import metadata + +import renamesubfolderprefs as rn + +import tableplusminus as tpm + +__version__ = config.version + +try: + import pygtk + pygtk.require("2.0") +except: + pass +try: + import gtk + import gtk.glade +except: + sys.exit(1) + +from common import Configi18n +global _ +_ = Configi18n._ + +#Translators: if neccessary, for guidance in how to translate this program, you may see http://damonlynch.net/translate.html +PROGRAM_NAME = _('Rapid Photo Downloader') + +def today(): + return datetime.date.today().strftime('%Y-%m-%d') + + + +def cmd_line(msg): + if verbose: + print msg + +exiting = False + +def updateDisplay(display_queue): + + try: + if display_queue.size() != 0: + call, args = display_queue.get() + if not exiting: + call(*args) +# else do not update display + else: + sys.stderr.write("Empty display queue!\n") + return True + + except tube.EOInformation: + for w in workers.getStartedWorkers(): + w.join() + gtk.main_quit() + + return False + + +class Queue(tube.Tube): + def __init__(self, maxSize = config.MAX_NO_READERS): + tube.Tube.__init__(self, maxSize) + + def setMaxSize(self, maxSize): + self.maxsize = maxSize + + +# Module wide values - +# set up thesse variable in global name space, and initialize with proper +# values later +# this is ugly but I don't know a better way :( + +display_queue = Queue() +media_collection_treeview = image_hbox = log_dialog = None + +job_code = None +need_job_code = False + +class ThreadManager: + _workers = [] + + + def append(self, w): + self._workers.append(w) + + def __getitem__(self, i): + return self._workers[i] + + def __len__(self): + return len(self._workers) + + def disableWorker(self, thread_id): + """ + set so a worker will not run, or if it is running, make it quit and therefore complete + """ + + self._workers[thread_id].manuallyDisabled = True + if self._workers[thread_id].hasStarted: + self._workers[thread_id].quit() + + else: + self._workers[thread_id].doNotStart = True + + def _isReadyToStart(self, w): + """ + Returns True if the worker is ready to start + and has not been disabled + """ + return not w.hasStarted and not w.doNotStart and not w.manuallyDisabled + + def _isReadyToDownload(self, w): + return w.scanComplete and not w.downloadStarted and not w.doNotStart and w.isAlive() and not w.manuallyDisabled + + def _isDownloading(self, w): + return w.downloadStarted and w.isAlive() and not w.downloadComplete + + def _isFinished(self, w): + """ + Returns True if the worker has finished running + + It does not signify it finished a download + """ + + return (w.hasStarted and not w.isAlive()) or w.manuallyDisabled + + def completedDownload(self, w): + return w.completedDownload + + def firstWorkerReadyToStart(self): + for w in self._workers: + if self._isReadyToStart(w): + return w + return None + + def firstWorkerReadyToDownload(self): + for w in self._workers: + if self._isReadyToDownload(w): + return w + return None + + def startWorkers(self): + for w in self.getReadyToStartWorkers(): + w.start() + + def startDownloadingWorkers(self): + for w in self.getReadyToDownloadWorkers(): + w.startStop() + + def quitAllWorkers(self): + global exiting + exiting = True + for w in self._workers: + w.quit() + + def getWorkers(self): + for w in self._workers: + yield w + + def getNonFinishedWorkers(self): + for w in self._workers: + if not self._isFinished(w): + yield w + + def getStartedWorkers(self): + for w in self._workers: + if w.hasStarted: + yield w + + def getReadyToStartWorkers(self): + for w in self._workers: + if self._isReadyToStart(w): + yield w + + def getReadyToDownloadWorkers(self): + for w in self._workers: + if self._isReadyToDownload(w): + yield w + + def getNotDownloadingWorkers(self): + for w in self._workers: + if w.hasStarted and not w.downloadStarted: + yield w + + def noReadyToStartWorkers(self): + n = 0 + for w in self._workers: + if self._isReadyToStart(w): + n += 1 + return n + + def noReadyToDownloadWorkers(self): + n = 0 + for w in self._workers: + if self._isReadyToDownload(w): + n += 1 + return n + + def getRunningWorkers(self): + for w in self._workers: + if w.hasStarted and w.isAlive(): + yield w + + def getDownloadingWorkers(self): + for w in self._workers: + if self._isDownloading(w): + yield w + + + def getPausedWorkers(self): + for w in self._workers: + if w.hasStarted and not w.running: + yield w + + def getPausedDownloadingWorkers(self): + for w in self._workers: + if w.downloadStarted and not w.running: + yield w + + def getWaitingForJobCodeWorkers(self): + for w in self._workers: + if w.waitingForJobCode: + yield w + + def getFinishedWorkers(self): + for w in self._workers: + if self._isFinished(w): + yield w + + def noDownloadingWorkers(self): + i = 0 + for w in self._workers: + if self._isDownloading(w): + i += 1 + return i + + def noRunningWorkers(self): + i = 0 + for w in self._workers: + if w.hasStarted and w.isAlive(): + i += 1 + return i + + def getNextThread_id(self): + return len(self._workers) + + def printWorkerStatus(self, worker=None): + if worker: + l = [worker] + else: + l = range(len(self._workers)) + for i in l: + print "\nThread %i\n=======\n" % i + w = self._workers[i] + print "Volume / source:", w.cardMedia.prettyName(limit=0) + print "Do not start:", w.doNotStart + print "Started:", w.hasStarted + print "Running:", w.running + print "Scan completed:", w.scanComplete + print "Download started:", w.downloadStarted + print "Download completed:", w.downloadComplete + print "Finished:", self._isFinished(w) + print "Alive:", w.isAlive() + print "Manually disabled:", w.manuallyDisabled, "\n" + + + +workers = ThreadManager() + +class RapidPreferences(prefs.Preferences): + defaults = { + "program_version": prefs.Value(prefs.STRING, ""), + "download_folder": prefs.Value(prefs.STRING, + getDefaultPhotoLocation()), + "subfolder": prefs.ListValue(prefs.STRING_LIST, rn.DEFAULT_SUBFOLDER_PREFS), + "image_rename": prefs.ListValue(prefs.STRING_LIST, [rn.FILENAME, + rn.NAME_EXTENSION, + rn.ORIGINAL_CASE]), + "device_autodetection": prefs.Value(prefs.BOOL, True), + "device_location": prefs.Value(prefs.STRING, os.path.expanduser('~')), + "device_autodetection_psd": prefs.Value(prefs.BOOL, False), + "device_whitelist": prefs.ListValue(prefs.STRING_LIST, ['']), + "device_blacklist": prefs.ListValue(prefs.STRING_LIST, ['']), + "backup_images": prefs.Value(prefs.BOOL, False), + "backup_device_autodetection": prefs.Value(prefs.BOOL, True), + "backup_identifier": prefs.Value(prefs.STRING, + config.DEFAULT_BACKUP_LOCATION), + "backup_location": prefs.Value(prefs.STRING, os.path.expanduser('~')), + "strip_characters": prefs.Value(prefs.BOOL, True), + "auto_download_at_startup": prefs.Value(prefs.BOOL, False), + "auto_download_upon_device_insertion": prefs.Value(prefs.BOOL, False), + "auto_unmount": prefs.Value(prefs.BOOL, False), + "auto_exit": prefs.Value(prefs.BOOL, False), + "indicate_download_error": prefs.Value(prefs.BOOL, True), + "download_conflict_resolution": prefs.Value(prefs.STRING, + config.SKIP_DOWNLOAD), + "backup_duplicate_overwrite": prefs.Value(prefs.BOOL, False), + "backup_missing": prefs.Value(prefs.STRING, config.IGNORE), + "display_thumbnails": prefs.Value(prefs.BOOL, True), + "show_log_dialog": prefs.Value(prefs.BOOL, False), + "day_start": prefs.Value(prefs.STRING, "03:00"), + "downloads_today": prefs.ListValue(prefs.STRING_LIST, [today(), '0']), + "stored_sequence_no": prefs.Value(prefs.INT, 0), + "job_codes": prefs.ListValue(prefs.STRING_LIST, [_('New York'), + _('Manila'), _('Prague'), _('Helsinki'), _('Wellington'), + _('Tehran'), _('Kampala'), _('Paris'), _('Berlin'), _('Sydney'), + _('Budapest'), _('Rome'), _('Moscow'), _('Delhi'), _('Warsaw'), + _('Jakarta'), _('Madrid'), _('Stockholm')]) + } + + def __init__(self): + prefs.Preferences.__init__(self, config.GCONF_KEY, self.defaults) + + def getAndMaybeResetDownloadsToday(self): + v = self.getDownloadsToday() + if v <= 0: + self.resetDownloadsToday() + return v + + def getDownloadsToday(self): + """Returns the preference value for the number of downloads performed today + + If value is less than zero, that means the date has changed""" + + hour, minute = self.getDayStart() + adjustedToday = datetime.datetime.strptime("%s %s:%s" % (self.downloads_today[0], hour, minute), "%Y-%m-%d %H:%M") + + now = datetime.datetime.today() + + if now < adjustedToday : + try: + return int(self.downloads_today[1]) + except ValueError: + sys.stderr.write(_("Invalid Downloads Today value.\n")) + sys.stderr.write(_("Resetting value to zero.\n")) + self.setDownloadsToday(self.downloads_today[0] , 0) + return 0 + else: + return -1 + + def setDownloadsToday(self, date, value=0): + self.downloads_today = [date, str(value)] + + def incrementDownloadsToday(self): + """ returns true if day changed """ + v = self.getDownloadsToday() + if v >= 0: + self.setDownloadsToday(self.downloads_today[0] , v + 1) + return False + else: + self.resetDownloadsToday(1) + return True + + def resetDownloadsToday(self, value=0): + now = datetime.datetime.today() + hour, minute = self.getDayStart() + t = datetime.time(hour, minute) + if now.time() < t: + date = today() + else: + d = datetime.datetime.today() + datetime.timedelta(days=1) + date = d.strftime(('%Y-%m-%d')) + + self.setDownloadsToday(date, value) + + def setDayStart(self, hour, minute): + self.day_start = "%s:%s" % (hour, minute) + + def getDayStart(self): + try: + t1, t2 = self.day_start.split(":") + return (int(t1), int(t2)) + except ValueError: + sys.stderr.write(_("'Start of day' preference value is corrupted.\n")) + sys.stderr.write(_("Resetting to midnight.\n")) + self.day_start = "0:0" + return 0, 0 + + def getSampleJobCode(self): + if self.job_codes: + return self.job_codes[0] + else: + return '' + +class ImageRenameTable(tpm.TablePlusMinus): + + def __init__(self, parentApp, adjustScrollWindow): + + tpm.TablePlusMinus.__init__(self, 1, 3) + self.parentApp = parentApp + self.adjustScrollWindow = adjustScrollWindow + if adjustScrollWindow: + self.connect("size-request", self.size_adjustment) + self.connect("add", self.size_adjustment) + self.tableWidth = self.allocation.width + # vbar is '1' if there is not vertical scroll bar + # if there is a vertical scroll bar, then it will have a the width of the bar + self.vbar = self.adjustScrollWindow.get_vscrollbar().allocation.width + + self.getParentAppPrefs() + self.getPrefsFactory() + + if not hasattr(self, "errorTitle"): + self.errorTitle = _("Error in Image Rename preferences") + + try: + self.prefsFactory.checkPrefsForValidity() + + except (rn.PrefValueInvalidError, rn.PrefLengthError, + rn.PrefValueKeyComboError, rn.PrefKeyError), e: + + sys.stderr.write(self.errorTitle + "\n") + sys.stderr.write(_("Sorry,these preferences contain an error:\n")) + sys.stderr.write(self.prefsFactory.formatPreferencesForPrettyPrint() + "\n") + + # the preferences were invalid + # reset them to their default + + self.prefList = self.prefsFactory.defaultPrefs + self.getPrefsFactory() + self.updateParentAppPrefs() + + msg = "%s.\n" % e + msg += _("Resetting to default values.") + sys.stderr.write(msg) + + + misc.run_dialog(self.errorTitle, msg, + parentApp, + gtk.MESSAGE_ERROR) + + for row in self.prefsFactory.getWidgetsBasedOnPreferences(): + self.append(row) + + + + + def updatePreferences(self): + prefList = [] + for row in self.pm_rows: + for col in range(self.pm_noColumns): + widget = row[col] + if widget: + name = widget.get_name() + if name == 'GtkComboBox': + value = widget.get_active_text() + elif name == 'GtkEntry': + value = widget.get_text() + else: + sys.stderr.write("Program error: Unknown preference widget!") + value = '' + else: + value = '' + prefList.append(value) + + self.prefList = prefList + self.updateParentAppPrefs() + self.prefsFactory.prefList = prefList + self.updateExample() + + + def size_adjustment(self, arg1, arg2): + """ Adjust scrolledwindow width in preferences dialog to reflect width of image rename table + + The algorithm is complicated by the need to tak into account the presence of a vertical scrollbar""" + + if self.adjustScrollWindow: + if self.adjustScrollWindow.get_vscrollbar().allocation.width > 1: + extra = self.adjustScrollWindow.get_vscrollbar().allocation.width + 10 + else: + extra = 0 + if self.vbar <= 1: + if self.allocation.width > self.tableWidth: + self.adjustScrollWindow.set_size_request(self.allocation.width + extra, -1) + self.tableWidth = self.allocation.width + extra + elif self.allocation.width - extra > self.tableWidth: + self.adjustScrollWindow.set_size_request(self.allocation.width + extra, -1) + self.tableWidth = self.allocation.width + extra + self.vbar = self.adjustScrollWindow.get_vscrollbar().allocation.width + + def getParentAppPrefs(self): + self.prefList = self.parentApp.prefs.image_rename + + + def getPrefsFactory(self): + self.prefsFactory = rn.ImageRenamePreferences(self.prefList, self, + sequences = sequences) + + def updateParentAppPrefs(self): + self.parentApp.prefs.image_rename = self.prefList + + def updateExampleJobCode(self): + job_code = self.parentApp.prefs.getSampleJobCode() + if not job_code: + job_code = _('Job code') + self.prefsFactory.setJobCode(job_code) + + def updateExample(self): + self.parentApp.updateImageRenameExample() + + def getDefaultRow(self): + return self.prefsFactory.getDefaultRow() + + def on_combobox_changed(self, widget, rowPosition): + + for col in range(self.pm_noColumns): + if self.pm_rows[rowPosition][col] == widget: + break + selection = [] + for i in range(col + 1): + # ensure it is a combo box we are getting the value from + w = self.pm_rows[rowPosition][i] + name = w.get_name() + if name == 'GtkComboBox': + selection.append(w.get_active_text()) + else: + selection.append(w.get_text()) + + for i in range(col + 1, self.pm_noColumns): + selection.append('') + + if col <> (self.pm_noColumns - 1): + widgets = self.prefsFactory.getWidgetsBasedOnUserSelection(selection) + + for i in range(col + 1, self.pm_noColumns): + oldWidget = self.pm_rows[rowPosition][i] + if oldWidget: + self.remove(oldWidget) + if oldWidget in self.pm_callbacks: + del self.pm_callbacks[oldWidget] + newWidget = widgets[i] + self.pm_rows[rowPosition][i] = newWidget + if newWidget: + self._createCallback(newWidget, rowPosition) + self.attach(newWidget, i, i+1, rowPosition, rowPosition + 1) + newWidget.show() + self.updatePreferences() + + + def on_entry_changed(self, widget, rowPosition): + self.updatePreferences() + + def on_rowAdded(self, rowPosition): + """ + Update preferences, as a row has been added + """ + self.updatePreferences() + + # if this was the last row or 2nd to last row, and another has just been added, move vertical scrollbar down + if rowPosition in range(self.pm_noRows - 3, self.pm_noRows - 2): + adjustment = self.parentApp.rename_scrolledwindow.get_vadjustment() + adjustment.set_value(adjustment.upper) + + + def on_rowDeleted(self, rowPosition): + """ + Update preferences, as a row has been deleted + """ + self.updatePreferences() + +class SubfolderTable(ImageRenameTable): + def __init__(self, parentApp, adjustScollWindow): + self.errorTitle = _("Error in Download Subfolder preferences") + ImageRenameTable.__init__(self, parentApp, adjustScollWindow) + + def getParentAppPrefs(self): + self.prefList = self.parentApp.prefs.subfolder + + def getPrefsFactory(self): + self.prefsFactory = rn.SubfolderPreferences(self.prefList, self) + + def updateParentAppPrefs(self): + self.parentApp.prefs.subfolder = self.prefList + + def updateExample(self): + self.parentApp.updateDownloadFolderExample() + + +class PreferencesDialog(gnomeglade.Component): + def __init__(self, parentApp): + gnomeglade.Component.__init__(self, + paths.share_dir(config.GLADE_FILE), + "preferencesdialog") + + self.widget.set_transient_for(parentApp.widget) + self.prefs = parentApp.prefs + + self._setupTabSelector() + + self._setupControlSpacing() + + # get example image data + + try: + w = workers.firstWorkerReadyToDownload() + root, self.sampleImageName = w.firstImage() + image = os.path.join(root, self.sampleImageName) + self.sampleImage = metadata.MetaData(image) + self.sampleImage.readMetadata() + except: + self.sampleImage = metadata.DummyMetaData() + self.sampleImageName = 'IMG_0524.CR2' + + # setup tabs + self._setupDownloadFolderTab() + self._setupImageRenameTab() + self._setupRenameOptionsTab() + self._setupJobCodeTab() + self._setupDeviceTab() + self._setupBackupTab() + self._setupAutomationTab() + self._setupErrorTab() + + self.widget.realize() + + #set the width of the left column for selecting values + #note: this must be called after self.widget.realize(), or else the width calculation will fail + width_of_widest_sel_row = self.treeview.get_background_area(1, self.treeview_column)[2] + self.scrolled_window.set_size_request(width_of_widest_sel_row + 2, -1) + + #set the minimum width of the scolled window holding the image rename table + if self.rename_scrolledwindow.get_vscrollbar(): + extra = self.rename_scrolledwindow.get_vscrollbar().allocation.width + 10 + else: + extra = 10 + self.rename_scrolledwindow.set_size_request(self.rename_table.allocation.width + extra, -1) + + self.widget.show() + + def on_preferencesdialog_destroy(self, widget): + """ Delete variables from memory that cause a file descriptor to be created on a mounted media""" + del self.sampleImage, self.rename_table.prefsFactory, self.subfolder_table.prefsFactory + + def _setupTabSelector(self): + self.notebook.set_show_tabs(0) + self.model = gtk.ListStore(type("")) + column = gtk.TreeViewColumn() + rentext = gtk.CellRendererText() + column.pack_start(rentext, expand=0) + column.set_attributes(rentext, text=0) + self.treeview_column = column + self.treeview.append_column(column) + self.treeview.props.model = self.model + for c in self.notebook.get_children(): + label = self.notebook.get_tab_label(c).get_text() + if not label.startswith("_"): + self.model.append( (label,) ) + + + # select the first value in the list store + self.treeview.set_cursor(0,column) + + def on_download_folder_filechooser_button_selection_changed(self, widget): + self.prefs.download_folder = widget.get_current_folder() + self.updateDownloadFolderExample() + + def on_backup_folder_filechooser_button_selection_changed(self, widget): + self.prefs.backup_location = widget.get_current_folder() + self.updateBackupExample() + + def on_device_location_filechooser_button_selection_changed(self, widget): + self.prefs.device_location = widget.get_current_folder() + + def _setupControlSpacing(self): + """ + set spacing of some but not all controls + + not currently used + """ + + self._setupTableSpacing(self.download_folder_table) + self.download_folder_table.set_row_spacing(2, + hd.VERTICAL_CONTROL_SPACE) + self._setupTableSpacing(self.rename_example_table) + self.devices_table.set_col_spacing(0, hd.NESTED_CONTROLS_SPACE) + + self._setupTableSpacing(self.backup_table) + self.backup_table.set_col_spacing(1, hd.NESTED_CONTROLS_SPACE) + self.backup_table.set_col_spacing(2, hd.CONTROL_LABEL_SPACE) + self._setupTableSpacing(self.compatibility_table) + self.compatibility_table.set_row_spacing(0, + hd.VERTICAL_CONTROL_LABEL_SPACE) + self._setupTableSpacing(self.error_table) + self.error_table.set_row_spacing(5, hd.VERTICAL_CONTROL_SPACE / 2) + + + def _setupTableSpacing(self, table): + table.set_col_spacing(0, hd.NESTED_CONTROLS_SPACE) + table.set_col_spacing(1, hd.CONTROL_LABEL_SPACE) + + def _setupSubfolderTable(self): + self.subfolder_table = SubfolderTable(self, None) + self.subfolder_vbox.pack_start(self.subfolder_table) + self.subfolder_table.show_all() + + def _setupDownloadFolderTab(self): + self.download_folder_filechooser_button = gtk.FileChooserButton( + _("Select a folder to download photos to")) + self.download_folder_filechooser_button.set_current_folder( + self.prefs.download_folder) + self.download_folder_filechooser_button.set_action( + gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) + self.download_folder_filechooser_button.connect("selection-changed", + self.on_download_folder_filechooser_button_selection_changed) + + self.download_folder_table.attach( + self.download_folder_filechooser_button, + 2, 3, 2, 3, yoptions = gtk.SHRINK) + self.download_folder_filechooser_button.show() + + self._setupSubfolderTable() + self.updateDownloadFolderExample() + + def _setupImageRenameTab(self): + + self.rename_table = ImageRenameTable(self, self.rename_scrolledwindow) + self.rename_table_vbox.pack_start(self.rename_table) + self.rename_table.show_all() + self.original_name_label.set_markup("<i>%s</i>" % self.sampleImageName) + self.updateImageRenameExample() + + def _setupRenameOptionsTab(self): + + # sequence numbers + self.downloads_today_entry = ValidatedEntry.ValidatedEntry(ValidatedEntry.bounded(ValidatedEntry.v_int, int, 0)) + self.stored_number_entry = ValidatedEntry.ValidatedEntry(ValidatedEntry.bounded(ValidatedEntry.v_int, int, 1)) + self.downloads_today_entry.connect('changed', self.on_downloads_today_entry_changed) + self.stored_number_entry.connect('changed', self.on_stored_number_entry_changed) + v = self.prefs.getAndMaybeResetDownloadsToday() + self.downloads_today_entry.set_text(str(v)) + # make the displayed value of stored sequence no 1 more than actual value + # so as not to confuse the user + self.stored_number_entry.set_text(str(self.prefs.stored_sequence_no+1)) + self.sequence_vbox.pack_start(self.downloads_today_entry, expand=True, fill=True) + self.sequence_vbox.pack_start(self.stored_number_entry, expand=False) + self.downloads_today_entry.show() + self.stored_number_entry.show() + hour, minute = self.prefs.getDayStart() + self.hour_spinbutton.set_value(float(hour)) + self.minute_spinbutton.set_value(float(minute)) + + #compatibility + self.strip_characters_checkbutton.set_active( + self.prefs.strip_characters) + + def _setupJobCodeTab(self): + self.job_code_liststore = gtk.ListStore(str) + column = gtk.TreeViewColumn() + rentext = gtk.CellRendererText() + rentext.connect('edited', self.on_job_code_edited) + rentext .set_property('editable', True) + + column.pack_start(rentext, expand=0) + column.set_attributes(rentext, text=0) + self.job_code_treeview_column = column + self.job_code_treeview.append_column(column) + self.job_code_treeview.props.model = self.job_code_liststore + for code in self.prefs.job_codes: + self.job_code_liststore.append((code, )) + + # set multiple selections + self.job_code_treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE) + + self.clear_job_code_button.set_image(gtk.image_new_from_stock( + gtk.STOCK_CLEAR, + gtk.ICON_SIZE_BUTTON)) + def _setupDeviceTab(self): + self.device_location_filechooser_button = gtk.FileChooserButton( + _("Select an image folder")) + self.device_location_filechooser_button.set_current_folder( + self.prefs.device_location) + self.device_location_filechooser_button.set_action( + gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) + + self.device_location_filechooser_button.connect("selection-changed", + self.on_device_location_filechooser_button_selection_changed) + + self.devices2_table.attach(self.device_location_filechooser_button, + 1, 2, 1, 2, xoptions = gtk.EXPAND|gtk.FILL, yoptions = gtk.SHRINK) + self.device_location_filechooser_button.show() + self.autodetect_device_checkbutton.set_active( + self.prefs.device_autodetection) + self.autodetect_psd_checkbutton.set_active( + self.prefs.device_autodetection_psd) + + self.updateDeviceControls() + + + def _setupBackupTab(self): + self.backup_folder_filechooser_button = gtk.FileChooserButton( + _("Select a folder in which to backup images")) + self.backup_folder_filechooser_button.set_current_folder( + self.prefs.backup_location) + self.backup_folder_filechooser_button.set_action( + gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) + self.backup_folder_filechooser_button.connect("selection-changed", + self.on_backup_folder_filechooser_button_selection_changed) + self.backup_table.attach(self.backup_folder_filechooser_button, + 3, 4, 7, 8, yoptions = gtk.SHRINK) + self.backup_folder_filechooser_button.show() + self.backup_identifier_entry.set_text(self.prefs.backup_identifier) + + #setup controls for manipulating sensitivity + self._backupControls0 = [self.auto_detect_backup_checkbutton, + self.missing_backup_label, + self.backup_error_radiobutton, + self.backup_warning_radiobutton, + self.backup_ignore_radiobutton] + self._backupControls1 = [self.backup_identifier_explanation_label, + self.backup_identifier_label, + self.backup_identifier_entry, + self.example_backup_path_label, + self.backup_example_label,] + self._backupControls2 = [self.backup_location_label, + self.backup_folder_filechooser_button, + self.backup_location_explanation_label] + self._backupControls = self._backupControls0 + self._backupControls1 + \ + self._backupControls2 + + #assign values to checkbuttons only when other controls + #have been setup, because their toggle signal is activated + #when a value is assigned + + self.backup_checkbutton.set_active(self.prefs.backup_images) + self.auto_detect_backup_checkbutton.set_active( + self.prefs.backup_device_autodetection) + self.updateBackupControls() + self.updateBackupExample() + + def _setupAutomationTab(self): + self.auto_startup_checkbutton.set_active( + self.prefs.auto_download_at_startup) + self.auto_insertion_checkbutton.set_active( + self.prefs.auto_download_upon_device_insertion) + self.auto_unmount_checkbutton.set_active( + self.prefs.auto_unmount) + self.auto_exit_checkbutton.set_active( + self.prefs.auto_exit) + + + def _setupErrorTab(self): + self.indicate_download_error_checkbutton.set_active( + self.prefs.indicate_download_error) + + if self.prefs.download_conflict_resolution == config.SKIP_DOWNLOAD: + self.skip_download_radiobutton.set_active(True) + else: + self.add_identifier_radiobutton.set_active(True) + + if self.prefs.backup_missing == config.REPORT_ERROR: + self.backup_error_radiobutton.set_active(True) + elif self.prefs.backup_missing == config.REPORT_WARNING: + self.backup_warning_radiobutton.set_active(True) + else: + self.backup_ignore_radiobutton.set_active(True) + + if self.prefs.backup_duplicate_overwrite: + self.backup_duplicate_overwrite_radiobutton.set_active(True) + else: + self.backup_duplicate_skip_radiobutton.set_active(True) + + def updateImageRenameExample(self): + """ + Displays example image name to the user + """ + + if hasattr(self, 'rename_table'): + self.rename_table.updateExampleJobCode() + name, problem = self.rename_table.prefsFactory.generateNameUsingPreferences( + self.sampleImage, self.sampleImageName, + self.prefs.strip_characters, sequencesPreliminary=False) + else: + name = problem = '' + + # since this is markup, escape it + text = "<i>%s</i>" % common.escape(name) + + if problem: + text += "\n" + # Translators: please do not modify or leave out html formatting tags like <i> and <b>. These are used to format the text the users sees + text += _("<i><b>Warning:</b> There is insufficient image metadata to fully generate the name. Please use other renaming options.</i>") + + self.new_name_label.set_markup(text) + + def updateDownloadFolderExample(self): + """ + Displays example subfolder name(s) to the user + """ + + if hasattr(self, 'subfolder_table'): + self.subfolder_table.updateExampleJobCode() + path, problem = self.subfolder_table.prefsFactory.generateNameUsingPreferences( + self.sampleImage, self.sampleImageName, + self.prefs.strip_characters) + else: + path = problem = '' + + text = os.path.join(self.prefs.download_folder, path) + # since this is markup, escape it + path = common.escape(text) + if problem: + warning = _("<i><b>Warning:</b> There is insufficient image metadata to fully generate subfolders. Please use other subfolder naming options.</i>" ) + else: + warning = "" + # Translators: you should not modify or leave out the %s. This is a code used by the programming language python to insert a value that thes user will see + self.example_download_path_label.set_markup(_("<i>Example: %s</i>") % text) + self.subfolder_warning_label.set_markup(warning) + + def on_hour_spinbutton_value_changed(self, spinbutton): + hour = spinbutton.get_value_as_int() + minute = self.minute_spinbutton.get_value_as_int() + self.prefs.setDayStart(hour, minute) + self.on_downloads_today_entry_changed(self.downloads_today_entry) + + def on_minute_spinbutton_value_changed(self, spinbutton): + hour = self.hour_spinbutton.get_value_as_int() + minute = spinbutton.get_value_as_int() + self.prefs.setDayStart(hour, minute) + self.on_downloads_today_entry_changed(self.downloads_today_entry) + + def on_downloads_today_entry_changed(self, entry): + if workers.noRunningWorkers() == 0: + # do not update value if a download is occurring - it will mess it up! + v = entry.get_text() + try: + v = int(v) + except: + v = 0 + if v < 0: + v = 0 + self.prefs.resetDownloadsToday(v) + sequences.setDownloadsToday(v) + self.updateImageRenameExample() + + def on_stored_number_entry_changed(self, entry): + if workers.noRunningWorkers() == 0: + # do not update value if a download is occurring - it will mess it up! + v = entry.get_text() + try: + # the displayed value of stored sequence no 1 more than actual value + # so as not to confuse the user + v = int(v) - 1 + except: + v = 0 + if v < 0: + v = 0 + self.prefs.stored_sequence_no = v + sequences.setStoredSequenceNo(v) + self.updateImageRenameExample() + + def on_response(self, dialog, arg): + if arg == gtk.RESPONSE_HELP: + webbrowser.open("http://www.damonlynch.net/rapid/documentation") + else: + # arg==gtk.RESPONSE_CLOSE, or the user hit the 'x' to close the window + self.prefs.backup_identifier = self.backup_identifier_entry.get_property("text") + + #check subfolder preferences for bad values + filtered, prefList = rn.filterSubfolderPreferences(self.prefs.subfolder) + if filtered: + cmd_line(_("The subfolder preferences had some unnecessary values removed.")) + if prefList: + self.prefs.subfolder = prefList + else: + #Preferences list is now empty + msg = _("The subfolder preferences entered are invalid and cannot be used.\nThey will be reset to their default values.") + sys.stderr.write(msg + "\n") + misc.run_dialog(PROGRAM_NAME, msg) + self.prefs.subfolder = self.prefs.get_default("subfolder") + + self.widget.destroy() + + + def on_add_job_code_button_clicked(self, button): + j = JobCodeDialog(self.widget, self.prefs.job_codes, None, self.add_job_code, False) + + + def add_job_code(self, dialog, userChoseCode, job_code, autoStart): + dialog.destroy() + if userChoseCode: + if job_code and job_code not in self.prefs.job_codes: + self.job_code_liststore.prepend((job_code, )) + self.update_job_codes() + selection = self.job_code_treeview.get_selection() + selection.unselect_all() + selection.select_path((0, )) + #scroll to the top + adjustment = self.job_code_scrolledwindow.get_vadjustment() + adjustment.set_value(adjustment.lower) + + def on_remove_job_code_button_clicked(self, button): + """ remove selected job codes (can be multiple selection)""" + selection = self.job_code_treeview.get_selection() + model, selected = selection.get_selected_rows() + iters = [model.get_iter(path) for path in selected] + # only delete if a jobe code is selected + if iters: + no = len(iters) + path = None + for i in range(0, no): + iter = iters[i] + if i == no - 1: + path = model.get_path(iter) + model.remove(iter) + + # now that we removed the selection, play nice with + # the user and select the next item + selection.select_path(path) + + # if there was no selection that meant the user + # removed the last entry, so we try to select the + # last item + if not selection.path_is_selected(path): + row = path[0]-1 + # test case for empty lists + if row >= 0: + selection.select_path((row,)) + + self.update_job_codes() + self.updateImageRenameExample() + self.updateDownloadFolderExample() + + def on_clear_job_code_button_clicked(self, button): + self.job_code_liststore.clear() + self.update_job_codes() + self.updateImageRenameExample() + self.updateDownloadFolderExample() + + def on_job_code_edited(self, widget, path, new_text): + iter = self.job_code_liststore.get_iter(path) + self.job_code_liststore.set_value(iter, 0, new_text) + self.update_job_codes() + self.updateImageRenameExample() + self.updateDownloadFolderExample() + + def update_job_codes(self): + """ update preferences with list of job codes""" + job_codes = [] + for row in self.job_code_liststore: + job_codes.append(row[0]) + self.prefs.job_codes = job_codes + + def on_auto_startup_checkbutton_toggled(self, checkbutton): + self.prefs.auto_download_at_startup = checkbutton.get_active() + + def on_auto_insertion_checkbutton_toggled(self, checkbutton): + self.prefs.auto_download_upon_device_insertion = checkbutton.get_active() + + def on_auto_unmount_checkbutton_toggled(self, checkbutton): + self.prefs.auto_unmount = checkbutton.get_active() + + def on_auto_exit_checkbutton_toggled(self, checkbutton): + self.prefs.auto_exit = checkbutton.get_active() + + def on_autodetect_device_checkbutton_toggled(self, checkbutton): + self.prefs.device_autodetection = checkbutton.get_active() + self.updateDeviceControls() + + def on_autodetect_psd_checkbutton_toggled(self, checkbutton): + self.prefs.device_autodetection_psd = checkbutton.get_active() + + def on_backup_duplicate_overwrite_radiobutton_toggled(self, widget): + self.prefs.backup_duplicate_overwrite = widget.get_active() + + def on_backup_duplicate_skip_radiobutton_toggled(self, widget): + self.prefs.backup_duplicate_overwrite = not widget.get_active() + + def on_backup_error_radiobutton_toggled(self, widget): + self.prefs.backup_missing = config.REPORT_ERROR + + def on_backup_warning_radiobutton_toggled(self, widget): + self.prefs.backup_missing = config.REPORT_WARNING + + def on_backup_ignore_radiobutton_toggled(self, widget): + self.prefs.backup_missing = config.IGNORE + + def on_treeview_cursor_changed(self, tree): + path, column = tree.get_cursor() + self.notebook.set_current_page(path[0]) + + + def on_strip_characters_checkbutton_toggled(self, check_button): + self.prefs.strip_characters = check_button.get_active() + self.updateImageRenameExample() + self.updateDownloadFolderExample() + + def on_indicate_download_error_checkbutton_toggled(self, check_button): + self.prefs.indicate_download_error = check_button.get_active() + + def on_add_identifier_radiobutton_toggled(self, widget): + if widget.get_active(): + self.prefs.download_conflict_resolution = config.ADD_UNIQUE_IDENTIFIER + else: + self.prefs.download_conflict_resolution = config.SKIP_DOWNLOAD + + + def updateDeviceControls(self): + """ + Sets sensitivity of image device controls + """ + controls = [self.device_location_explanation_label, + self.device_location_label, + self.device_location_filechooser_button] + + if self.prefs.device_autodetection: + for c in controls: + c.set_sensitive(False) + self.autodetect_psd_checkbutton.set_sensitive(True) + self.autodetect_image_devices_label.set_sensitive(True) + else: + for c in controls: + c.set_sensitive(True) + self.autodetect_psd_checkbutton.set_sensitive(False) + self.autodetect_image_devices_label.set_sensitive(False) + + def updateBackupControls(self): + """ + Sets sensitivity of backup related widgets + """ + + if not self.backup_checkbutton.get_active(): + for c in self._backupControls: + c.set_sensitive(False) + + else: + for c in self._backupControls0: + c.set_sensitive(True) + + self.updateBackupControlsAuto() + + def updateBackupControlsAuto(self): + """ + Sets sensitivity of subset of backup related widgets + """ + + if self.auto_detect_backup_checkbutton.get_active(): + for c in self._backupControls1: + c.set_sensitive(True) + for c in self._backupControls2: + c.set_sensitive(False) + else: + for c in self._backupControls1: + c.set_sensitive(False) + for c in self._backupControls2: + c.set_sensitive(True) + + def on_auto_detect_backup_checkbutton_toggled(self, widget): + self.prefs.backup_device_autodetection = widget.get_active() + self.updateBackupControlsAuto() + + def on_backup_checkbutton_toggled(self, widget): + self.prefs.backup_images = self.backup_checkbutton.get_active() + self.updateBackupControls() + + def on_backup_identifier_entry_changed(self, widget): + self.updateBackupExample() + + def on_backup_scan_folder_on_entry_changed(self, widget): + self.updateBackupExample() + + def updateBackupExample(self): + # Translators: this value is used as an example device when automatic backup device detection is enabled. You should translate this. + path = os.path.join(config.MEDIA_LOCATION, _("externaldrive1")) + # Translators: this value is used as an example device when automatic backup device detection is enabled. You should translate this. + path2 = os.path.join(config.MEDIA_LOCATION, _("externaldrive2")) + + path = os.path.join(path, self.backup_identifier_entry.get_text()) + path2 = os.path.join(path2, self.backup_identifier_entry.get_text()) + path = common.escape(path) + path2 = common.escape(path2) + self.example_backup_path_label.set_markup("<i>%s</i>\n<i>%s</i>" % (path, + path2)) + + + + +class CopyPhotos(Thread): + """Copies photos from source to destination, backing up if needed""" + def __init__(self, thread_id, parentApp, fileRenameLock, fileSequenceLock, statsLock, downloadStats, autoStart = False, cardMedia = None): + self.parentApp = parentApp + self.thread_id = thread_id + self.ctrl = True + self.running = False + self.manuallyDisabled = False + # enable the capacity to block oneself with a lock + # the lock will be first set when the thread begins + # it will then be locked when the thread needs to be paused + # releasing it will cause the code to restart from where it + # left off + self.lock = Lock() + + self.fileRenameLock = fileRenameLock + self.fileSequenceLock = fileSequenceLock + self.statsLock = statsLock + + self.downloadStats = downloadStats + + self.hasStarted = False + self.doNotStart = False + self.waitingForJobCode = False + + self.autoStart = autoStart + self.cardMedia = cardMedia + + self.initializeDisplay(thread_id, self.cardMedia) + + self.noErrors = self.noWarnings = 0 + + self.scanComplete = self.downloadStarted = self.downloadComplete = False + + Thread.__init__(self) + + + def initializeDisplay(self, thread_id, cardMedia = None): + + if self.cardMedia: + media_collection_treeview.addCard(thread_id, self.cardMedia.prettyName(), + '', 0, progress=0.0, + # This refers to when a device like a hard drive is having its contents scanned, + # looking for images. It is visible initially in the progress bar for each device + # (which normally holds "x of y images copied"). + # It maybe displayed only briefly if the contents of the device being scanned is small. + progressBarText=_('scanning...')) + + + def firstImage(self): + """ + returns name, path and size of the first image + """ + name, root, size, modificationTime = self.cardMedia.firstImage() + return root, name + + def handlePreferencesError(self, e, prefsFactory): + sys.stderr.write(_("Sorry,these preferences contain an error:\n")) + sys.stderr.write(prefsFactory.formatPreferencesForPrettyPrint() + "\n") + msg = str(e) + sys.stderr.write(msg + "\n") + + def initializeFromPrefs(self, notifyOnError): + """ + Setup thread so that user preferences are handled + """ + self.prefs = self.parentApp.prefs + + self.imageRenamePrefsFactory = rn.ImageRenamePreferences(self.prefs.image_rename, self, + self.fileSequenceLock, sequences) + try: + self.imageRenamePrefsFactory.checkPrefsForValidity() + except (rn.PrefValueInvalidError, rn.PrefLengthError, + rn.PrefValueKeyComboError, rn.PrefKeyError), e: + if notifyOnError: + self.handlePreferencesError(e, self.imageRenamePrefsFactory) + raise rn.PrefError + + + self.subfolderPrefsFactory = rn.SubfolderPreferences( + self.prefs.subfolder, self) + try: + self.subfolderPrefsFactory.checkPrefsForValidity() + except (rn.PrefValueInvalidError, rn.PrefLengthError, + rn.PrefValueKeyComboError, rn.PrefKeyError), e: + if notifyOnError: + self.handlePreferencesError(e, self.subfolderPrefsFactory) + raise rn.PrefError + + # copy this variable, as it is used heavily in the loop + # and it is perhaps relatively expensive to read + self.stripCharacters = self.prefs.strip_characters + + + def run(self): + """ + Copy photos from device to local drive, and if requested, backup + + 1. Should the image be downloaded? + 1.a generate file name + 1.a.1 generate sequence numbers if needed + 1.a.2 FIFO queue sequence numbers to indicate that they could + potentially be used in a filename + 1.b check to see if a file exists with the same name in the place it will + be downloaded to + 1.c if it exisits, and unique identifiers are not being used: + 1.b.1 if using sequence numbers or letters, then potentially any of the + sequence numbers in the queue could be used to make the filename + 1.b.1.a generate and check each filename using sequence numbers in the queue + 1.b.1.b if one of these filenames is unique, then image needs to be downloaded + 1.b.2 do not do not download + + + 2. Download the image + 2.a copy it to temporary folder (this takes time) + 2.b is the file name still unique? Perhaps a new file was created with this name in the meantime + (either by another thread or another program) + 2.b.1 don't allow any other thread to rename a file + 2.b.2 check file name + 2.b.3 adding suffix if it is not unique, being careful not to overwrite any existing file with a suffix + 2.b.4 rename it to the "real"" name, effectively performing a mv + 2.b.5 allow other threads to rename files + + 3. Backup the image, using the same filename as was used when it was downloaded + 3.a does a file with the same name already exist on the backup medium? + 3.b if so, user preferences determine whether it should be overwritten or not + """ + + def getPrefs(notifyOnError): + try: + self.initializeFromPrefs(notifyOnError) + return True + except rn.PrefError: + if notifyOnError: + display_queue.put((media_collection_treeview.removeCard, (self.thread_id, ))) + msg = _("There is an error in the program preferences.") + msg += _("\nPlease check preferences, restart the program, and try again.") + logError(config.CRITICAL_ERROR, _("Download cannot proceed"), msg) + cmd_line(_("Download cannot proceed")) + cmd_line(msg) + return False + def scanMedia(): + + images = [] + imageSizeSum = 0 + for root, dirs, files in os.walk(self.cardMedia.getPath()): + for name in files: + if not self.running: + self.lock.acquire() + self.running = True + + if not self.ctrl: + self.running = False + display_queue.put((media_collection_treeview.removeCard, (self.thread_id, ))) + display_queue.close("rw") + return + + if media.isImage(name): + image = os.path.join(root, name) + size = os.path.getsize(image) + modificationTime = os.path.getmtime(image) + images.append((name, root, size, modificationTime),) + imageSizeSum += size + images.sort(key=operator.itemgetter(3)) + noImages = len(images) + + self.scanComplete = True + + if noImages: + self.cardMedia.setMedia(images, imageSizeSum, noImages) + # Translators: as already, mentioned the %s value should not be modified or left out. It may be moved if necessary. + # It refers to the actual number of images that can be copied. For example, the user might see the following: + # '0 of 512 images copied'. + # This particular text is displayed to the user before the download has started. + display = _("0 of %s images copied") % noImages + display_queue.put((media_collection_treeview.updateCard, (self.thread_id, self.cardMedia.sizeOfImages(), noImages))) + display_queue.put((media_collection_treeview.updateProgress, (self.thread_id, 0.0, display, 0))) + display_queue.put((self.parentApp.timeRemaining.add, (self.thread_id, imageSizeSum))) + display_queue.put((self.parentApp.setDownloadButtonSensitivity, ())) + + # Translators: as you have already seen, the text can contain values that should not be modified or left out by you, for example %s. + # This text is another example of that, but it is is a little more complex. Here there are two values which will be displayed + # to the user when they run the program, signifying the number of images found, and the device they were found on. + # %(number)s should be left exactly as is: 'number' should not be translated. The same applies to %(device)s: 'device' should + # not be translated. Generally speaking, if translating the sentence requires it, you can move items like '%(xyz)s' around + # in a sentence, but you should never modify them or leave them out. + cmd_line(_("Device scan complete: found %(number)s images on %(device)s") % + {'number': noImages, 'device': self.cardMedia.prettyName(limit=0)}) + return True + else: + # it might be better to display "0 of 0" here + display_queue.put((media_collection_treeview.removeCard, (self.thread_id, ))) + cmd_line(_("Device scan complete: no images found on %s") % self.cardMedia.prettyName(limit=0)) + return False + + def cleanUp(): + """ + Cleanup functions that must be performed whether the thread exits + early or when it has completed its run. + """ + + # possibly delete any lingering files + tf = os.listdir(tempWorkingDir) + if tf: + for f in tf: + os.remove(os.path.join(tempWorkingDir, f)) + + os.rmdir(tempWorkingDir) + + + def logError(severity, problem, details, resolution=None): + display_queue.put((log_dialog.addMessage, (self.thread_id, severity, problem, details, + resolution))) + if severity == config.WARNING: + self.noWarnings += 1 + else: + self.noErrors += 1 + + + def checkProblemWithImageNameGeneration(newName, image, problem): + if not newName: + # a serious problem - a filename should never be blank! + logError(config.SERIOUS_ERROR, + _("Image filename could not be generated"), + # '%(source)s' and '%(problem)s' are two more examples of text that should not be modified or left out + _("Source: %(source)s\nProblem: %(problem)s") % {'source': image, 'problem': problem}, + IMAGE_SKIPPED) + elif problem: + logError(config.WARNING, + _("Image filename could not be properly generated. Check to ensure there is sufficient image metadata."), + _("Source: %(source)s\nDestination: %(destination)s\nProblem: %(problem)s") % + {'source': image, 'destination': newName, 'problem': problem}) + + def generateSubfolderAndFileName(image, name, needMetaDataToCreateUniqueImageName, + needMetaDataToCreateUniqueSubfolderName): + skipImage = False + try: + imageMetadata = metadata.MetaData(image) + except IOError: + logError(config.CRITICAL_ERROR, _("Could not open image"), + _("Source: %s") % image, + IMAGE_SKIPPED) + skipImage = True + imageMetadata = newName = newFile = path = subfolder = None + else: + try: + # this step can fail if the source image is corrupt + imageMetadata.readMetadata() + except: + skipImage = True + + if not skipImage: + if not imageMetadata.exifKeys() and (needMetaDataToCreateUniqueSubfolderName or + (needMetaDataToCreateUniqueImageName and + not addUniqueIdentifier)): + skipImage = True + + if skipImage: + logError(config.SERIOUS_ERROR, _("Image has no metadata"), + _("Metadata is essential for generating subfolders / image names.\nSource: %s") % image, + IMAGE_SKIPPED) + newName = newFile = path = subfolder = None + else: + subfolder, problem = self.subfolderPrefsFactory.generateNameUsingPreferences( + imageMetadata, name, + self.stripCharacters) + + if problem: + logError(config.WARNING, + _("Subfolder name could not be properly generated. Check to ensure there is sufficient image metadata."), + _("Subfolder: %(subfolder)s\nImage: %(image)s\nProblem: %(problem)s") % + {'subfolder': subfolder, 'image': image, 'problem': problem}) + + # pass the subfolder the image will go into, as this is needed to determine subfolder sequence numbers + # indicate that sequences chosen should be queued + + newName, problem = self.imageRenamePrefsFactory.generateNameUsingPreferences( + imageMetadata, name, self.stripCharacters, subfolder, + sequencesPreliminary = True) + + path = os.path.join(baseDownloadDir, subfolder) + newFile = os.path.join(path, newName) + + if not newName: + skipImage = True + checkProblemWithImageNameGeneration(newName, image, problem) + + return (skipImage, imageMetadata, newName, newFile, path, subfolder) + + def downloadImage(path, newFile, newName, originalName, image, imageMetadata, subfolder): + try: + imageDownloaded = False + if not os.path.isdir(path): + os.makedirs(path) + + nameUniqueBeforeCopy = True + downloadNonUniqueFile = True + + + # do a preliminary check to see if a file with the same name already exists + if os.path.exists(newFile): + nameUniqueBeforeCopy = False + if not addUniqueIdentifier: + downloadNonUniqueFile = False + if usesSequenceElements: + # potentially, a unique image name could still be generated + # investigate this possibility + with self.fileSequenceLock: + for possibleName, problem in self.imageRenamePrefsFactory.generateNameSequencePossibilities(imageMetadata, + originalName, self.stripCharacters, subfolder): +# print "checking", possibleName, "using", originalName + if possibleName: + # no need to check for any problems here, it's just a temporary name + possibleFile = os.path.join(path, possibleName) + possibleTempFile = os.path.join(tempWorkingDir, possibleName) + if not os.path.exists(possibleFile) and not os.path.exists(possibleTempFile): + downloadNonUniqueFile = True + break + + + if self.prefs.indicate_download_error and not downloadNonUniqueFile: + logError(config.SERIOUS_ERROR, IMAGE_ALREADY_EXISTS, + _("Source: %(source)s\nDestination: %(destination)s") % + {'source': image, 'destination': newFile}, + IMAGE_SKIPPED) + + if nameUniqueBeforeCopy or downloadNonUniqueFile: + tempWorkingfile = os.path.join(tempWorkingDir, newName) + shutil.copy2(image, tempWorkingfile) + + with self.fileRenameLock: + doRename = True + if usesSequenceElements: + with self.fileSequenceLock: + # get a filename and use this as the "real" filename + newName, problem = self.imageRenamePrefsFactory.generateNameUsingPreferences( + imageMetadata, originalName, self.stripCharacters, subfolder, + sequencesPreliminary = False) + checkProblemWithImageNameGeneration(newName, image, problem) + if not newName: + # there was a serious error generating the filename + doRename = False + else: + newFile = os.path.join(path, newName) + # check if the file exists again + if os.path.exists(newFile): + if not addUniqueIdentifier: + doRename = False + if self.prefs.indicate_download_error: + logError(config.SERIOUS_ERROR, IMAGE_ALREADY_EXISTS, + _("Source: %(source)s\nDestination: %(destination)s") + % {'source': image, 'destination': newFile}, + IMAGE_SKIPPED) + else: + # add basic suffix to make the filename unique + name = os.path.splitext(newName) + suffixAlreadyUsed = True + while suffixAlreadyUsed: + if newFile in duplicate_files: + duplicate_files[newFile] += 1 + else: + duplicate_files[newFile] = 1 + identifier = '_%s' % duplicate_files[newFile] + newName = name[0] + identifier + name[1] + possibleNewFile = os.path.join(path, newName) + suffixAlreadyUsed = os.path.exists(possibleNewFile) + + if self.prefs.indicate_download_error: + logError(config.SERIOUS_ERROR, IMAGE_ALREADY_EXISTS, + _("Source: %(source)s\nDestination: %(destination)s") + % {'source': image, 'destination': newFile}, + _("Unique identifier '%s' added") % identifier) + + newFile = possibleNewFile + + + if doRename: + os.rename(tempWorkingfile, newFile) + imageDownloaded = True + if usesSequenceElements: + with self.fileSequenceLock: + self.imageRenamePrefsFactory.sequences.imageCopySucceeded() + if usesStoredSequenceNo: + self.prefs.stored_sequence_no += 1 + + with self.fileSequenceLock: + if self.prefs.incrementDownloadsToday(): + # A new day, according the user's preferences of what time a day begins, has started + cmd_line(_("New day has started - resetting 'Downloads Today' sequence number")) + + sequences.setDownloadsToday(0) + + except IOError, (errno, strerror): + logError(config.SERIOUS_ERROR, _('Download copying error'), + _("Source: %(source)s\nDestination: %(destination)s\nError: %(errorno)s %(strerror)s") + % {'source': image, 'destination': newFile, 'errorno': errno, 'strerror': strerror}, + _('The image was not copied.')) + + except OSError, (errno, strerror): + logError(config.CRITICAL_ERROR, _('Download copying error'), + "Source: %(source)s\nDestination: %(destination)s\nError: %(errorno)s %(strerror)s" + % {'source': image, 'destination': newFile, 'errorno': errno, 'strerror': strerror}, + ) + + if usesSequenceElements: + if not imageDownloaded: + self.imageRenamePrefsFactory.sequences.imageCopyFailed() + + return (imageDownloaded, newName, newFile) + + + def backupImage(subfolder, newName, imageDownloaded, newFile, image): + """ backup image to path(s) chosen by the user + + there are two scenarios: + (1) image has just been downloaded and should now be backed up + (2) image was already downloaded on some previous occassion and should still be backed up, because it hasn't been yet + (3) image has been backed up already (or at least, a file with the same name already exists) + """ + + try: + for backupDir in self.parentApp.backupVolumes: + backupPath = os.path.join(backupDir, subfolder) + newBackupFile = os.path.join(backupPath, newName) + copyBackup = True + if os.path.exists(newBackupFile): + # again, not thread safe + copyBackup = self.prefs.backup_duplicate_overwrite + if self.prefs.indicate_download_error: + severity = config.SERIOUS_ERROR + problem = _("Backup image already exists") + details = _("Source: %(source)s\nDestination: %(destination)s") \ + % {'source': image, 'destination': newBackupFile} + if copyBackup : + resolution = IMAGE_OVERWRITTEN + else: + resolution = IMAGE_SKIPPED + logError(severity, problem, details, resolution) + + if copyBackup: + if imageDownloaded: + fileToCopy = newFile + else: + fileToCopy = image + if not os.path.isdir(backupPath): + # recreate folder structure in backup location + # cannot do os.makedirs(backupPath) - it gives bad results when using external drives + # we know backupDir exists + # all the components of subfolder may not + folders = subfolder.split(os.path.sep) + folderToMake = backupDir + for f in folders: + if f: + folderToMake = os.path.join(folderToMake, f) + if not os.path.isdir(folderToMake): + try: + os.mkdir(folderToMake) + except (errno, strerror): + logError(config.SERIOUS_ERROR, _('Backing up error'), + _("Destination directory could not be created\n%(directory)s\nError: %(errno)s %(strerror)s") + % {'directory': folderToMake, 'errno': errno, 'strerror': strerror}, + ) + + shutil.copy2(fileToCopy, newBackupFile) + + except IOError, (errno, strerror): + logError(config.SERIOUS_ERROR, _('Backing up error'), + _("Source: %(source)s\nDestination: %(destination)s\nError: %(errno)s %(strerror)s") + % {'source': image, 'destination': newBackupFile, 'errno': errno, 'strerror': strerror}, + _('The image was not copied.')) + + except OSError, (errno, strerror): + logError(config.CRITICAL_ERROR, _('Backing up error'), + _("Source: %(source)s\nDestination: %(destination)s\nError: %(errno)s %(strerror)s") + % {'source': image, 'destination': newBackupFile, 'errno': errno, 'strerror': strerror} + ) + + def notifyAndUnmount(): + if not self.cardMedia.volume: + unmountMessage = "" + notificationName = PROGRAM_NAME + else: + notificationName = self.cardMedia.volume.get_name() + if self.prefs.auto_unmount: + self.cardMedia.volume.unmount(self.on_volume_unmount) + # This message informs the user that the device (e.g. camera, hard drive or memory card) was automatically unmounted and they can now remove it + unmountMessage = _("The device can now be safely removed") + else: + unmountMessage = "" + + message = _("%s images downloaded") % noImagesDownloaded + if noImagesSkipped: + message += "\n" + _("%s images skipped") % noImagesSkipped + + if unmountMessage: + message = "%s\n%s" % (message, unmountMessage) + + if self.noWarnings: + message = "%s\n%s " % (message, self.noWarnings) + _("warnings") + if self.noErrors: + message = "%s\n%s " % (message, self.noErrors) + _("errors") + + n = pynotify.Notification(notificationName, message) + n.show() + + + + + self.hasStarted = True + display_queue.open('w') + + #Do not try to handle any preference errors here + getPrefs(False) + + #check for presence of backup meditum + if self.prefs.backup_images: + if self.prefs.backup_missing <> config.IGNORE: + if not len(self.parentApp.backupVolumes): + if self.prefs.backup_missing == config.REPORT_ERROR: + e = config.SERIOUS_ERROR + else: + e = config.WARNING + logError(e, _("Backup device missing"), _("No backup device was detected.")) + + + if not scanMedia(): + cmd_line(_("This device has no images to download from.")) + display_queue.close("rw") + self.running = False + self.lock.release() + return + elif self.autoStart and need_job_code: + if job_code == None: + self.waitingForJobCode = True + display_queue.put((self.parentApp.getJobCode, ())) + self.running = False + self.lock.acquire() + self.running = True + self.waitingForJobCode = False + elif not self.autoStart: + # halt thread, waiting to be restarted so download proceeds + self.running = False + self.lock.acquire() + + if not self.ctrl: + # thread will restart at this point, when the program is exiting + # so must exit if self.ctrl indicates this + + self.running = False + display_queue.close("rw") + return + + self.running = True + + if not getPrefs(True): + self.running = False + display_queue.close("rw") + return + + + self.downloadStarted = True + cmd_line(_("Download has started from %s") % self.cardMedia.prettyName(limit=0)) + + if need_job_code and job_code == None: + sys.stderr.write(str(self.thread_id ) + ": job code should never be None\n") + self.imageRenamePrefsFactory.setJobCode('unknown-job-code') + self.subfolderPrefsFactory.setJobCode('unknown-job-code') + else: + self.imageRenamePrefsFactory.setJobCode(job_code) + self.subfolderPrefsFactory.setJobCode(job_code) + + # Some images may not have metadata (this + # is unlikely for images straight out of a + # camera, but it is possible for images that have been edited). If + # only non-dynamic components make up the rest of an image name + # (e.g. text specified by the user), then relying on metadata will + # likely produce duplicate names. + + needMetaDataToCreateUniqueImageName = self.imageRenamePrefsFactory.needImageMetaDataToCreateUniqueName() + + # subfolder generation also need to be examined, but here the need is + # not so exacting, since subfolders contain images, and naturally the + # requirement to be unique is far more relaxed. However if subfolder + # generation relies entirely on metadata, that is a problem worth + # looking for + needMetaDataToCreateUniqueSubfolderName = self.subfolderPrefsFactory.needMetaDataToCreateUniqueName() + + i = 0 + sizeDownloaded = noImagesDownloaded = noImagesSkipped = 0 + + sizeImages = self.cardMedia.sizeOfImages(humanReadable = False) + display_queue.put((self.parentApp.addToTotalDownloadSize, (sizeImages, ))) + display_queue.put((self.parentApp.setOverallDownloadMark, ())) + display_queue.put((self.parentApp.postStartDownloadTasks, ())) + + sizeImages = float(sizeImages) + noImages = self.cardMedia.numberOfImages() + + baseDownloadDir = self.prefs.download_folder + #create a temporary directory in which to download the photos to + #don't want to put it in system temp folder, as that is likely + #to be on another partition and hence copying files from it + #to the download folder will be slow! + tempWorkingDir = tempfile.mkdtemp(prefix='rapid-tmp-', + dir=baseDownloadDir) + + IMAGE_SKIPPED = _("Image skipped") + IMAGE_OVERWRITTEN = _("Image overwritten") + IMAGE_ALREADY_EXISTS = _("Image already exists") + + addUniqueIdentifier = self.prefs.download_conflict_resolution == config.ADD_UNIQUE_IDENTIFIER + usesSequenceElements = self.imageRenamePrefsFactory.usesSequenceElements() + usesStoredSequenceNo = self.imageRenamePrefsFactory.usesTheSequenceElement(rn.STORED_SEQ_NUMBER) + sequences. setUseOfSequenceElements( + self.imageRenamePrefsFactory.usesTheSequenceElement(rn.SESSION_SEQ_NUMBER), + self.imageRenamePrefsFactory.usesTheSequenceElement(rn.SEQUENCE_LETTER)) + + + while i < noImages: + if not self.running: + self.lock.acquire() + self.running = True + + if not self.ctrl: + self.running = False + cleanUp() + display_queue.close("rw") + return + + # get information about the image to deduce image name and path + name, root, size, modificationTime = self.cardMedia.images[i] + image = os.path.join(root, name) + + skipImage, imageMetadata, newName, newFile, path, subfolder = generateSubfolderAndFileName( + image, name, needMetaDataToCreateUniqueImageName, + needMetaDataToCreateUniqueSubfolderName) + + if skipImage: + noImagesSkipped += 1 + else: + imageDownloaded, newName, newFile = downloadImage(path, newFile, newName, name, image, + imageMetadata, subfolder) + + if self.prefs.backup_images: + backupImage(subfolder, newName, imageDownloaded, newFile, image) + + if imageDownloaded: + noImagesDownloaded += 1 + else: + noImagesSkipped += 1 + try: + thumbnailType, thumbnail = imageMetadata.getThumbnailData() + except: + logError(config.WARNING, _("Image has no thumbnail"), image) + thumbnail = orientation = None + else: + orientation = imageMetadata.orientation(missing=None) + display_queue.put((image_hbox.addImage, (self.thread_id, thumbnail, orientation, image, imageDownloaded))) + + sizeDownloaded += size + percentComplete = (sizeDownloaded / sizeImages) * 100 + if sizeDownloaded == sizeImages: + self.downloadComplete = True + progressBarText = _("%(number)s of %(total)s images copied") % {'number': i + 1, 'total': noImages} + display_queue.put((media_collection_treeview.updateProgress, (self.thread_id, percentComplete, progressBarText, size))) + + i += 1 + + with self.statsLock: + self.downloadStats.adjust(sizeDownloaded, noImagesDownloaded, noImagesSkipped, self.noWarnings, self.noErrors) + + # must manually delete these variables, or else the media cannot be unmounted (bug in pyexiv or exiv2) + del self.subfolderPrefsFactory, self.imageRenamePrefsFactory + try: + del imageMetadata + except: + pass + + notifyAndUnmount() + cmd_line(_("Download complete from %s") % self.cardMedia.prettyName(limit=0)) + display_queue.put((self.parentApp.notifyUserAllDownloadsComplete,())) + display_queue.put((self.parentApp.resetSequences,())) + + cleanUp() + display_queue.put((self.parentApp.exitOnDownloadComplete, ())) + display_queue.close("rw") + + self.running = False + if noImages: + self.lock.release() + + def startStop(self): + if self.isAlive(): + if self.running: + self.running = False + else: + try: + self.lock.release() + + except thread_error: + sys.stderr.write(str(self.thread_id) + " thread error\n") + + def quit(self): + """ + Quits the thread + + A thread can be in one of four states: + + Not started (not alive, nothing to do) + Started and actively running (alive) + Started and paused (alive) + Completed (not alive, nothing to do) + """ + + if self.hasStarted: + if self.isAlive(): + self.ctrl = False + + if not self.running: + released = False + while not released: + try: + self.lock.release() + released = True + except thread_error: + sys.stderr.write("Could not release lock for thread %s\n" % self.thread_id) + + + + def on_volume_unmount(self, data1, data2): + """ needed for call to unmount volume""" + pass + + +class MediaTreeView(gtk.TreeView): + """ + TreeView display of memory cards and associated copying progress. + + Assumes a threaded environment. + """ + def __init__(self, parentApp): + + self.parentApp = parentApp + # card name, size of images, number of images, copy progress, copy text + self.liststore = gtk.ListStore(str, str, int, float, str) + self.mapThreadToRow = {} + + 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) + + # Device refers to a thing like a camera, memory card in its reader, external hard drive, Portable Storage Device, etc. + column0 = gtk.TreeViewColumn(_("Device"), gtk.CellRendererText(), + text=0) + self.append_column(column0) + + # Size refers to the total size of images on the device, typically in MB or GB + column1 = gtk.TreeViewColumn(_("Size"), gtk.CellRendererText(), text=1) + self.append_column(column1) + + column2 = gtk.TreeViewColumn(_("Download Progress"), + gtk.CellRendererProgress(), value=3, text=4) + self.append_column(column2) + self.show_all() + + def addCard(self, thread_id, cardName, sizeImages, noImages, progress = 0.0, + progressBarText = ''): + if not progressBarText: + progressBarText = _("0 of %s images copied") % (noImages) + + # add the row, and get a temporary pointer to the row + iter = self.liststore.append((cardName, sizeImages, noImages, + progress, progressBarText)) + + self._setThreadMap(thread_id, iter) + + # adjust scrolled window height, based on row height and number of ready to start downloads + if workers.noReadyToStartWorkers() >= 1 or workers.noRunningWorkers() > 0: + # please note, at program startup, self.rowHeight() will be less than it will be when already running + # e.g. when starting with 3 cards, it could be 18, but when adding 2 cards to the already running program + # (with one card at startup), it could be 21 + height = (workers.noReadyToStartWorkers() + workers.noRunningWorkers() + 2) * (self.rowHeight()) + self.parentApp.media_collection_scrolledwindow.set_size_request(-1, height) + + + def updateCard(self, thread_id, sizeImages, noImages): + if thread_id in self.mapThreadToRow: + iter = self._getThreadMap(thread_id) + self.liststore.set_value(iter, 1, sizeImages) + self.liststore.set_value(iter, 2, noImages) + else: + sys.stderr.write("FIXME: this card is unknown") + + def removeCard(self, thread_id): + if thread_id in self.mapThreadToRow: + iter = self._getThreadMap(thread_id) + self.liststore.remove(iter) + del self.mapThreadToRow[thread_id] + + + def _setThreadMap(self, thread_id, iter): + """ + convert the temporary iter into a tree reference, which is + permanent + """ + + path = self.liststore.get_path(iter) + treerowRef = gtk.TreeRowReference(self.liststore, path) + self.mapThreadToRow[thread_id] = treerowRef + + def _getThreadMap(self, thread_id): + """ + return the tree iter for this thread + """ + + treerowRef = self.mapThreadToRow[thread_id] + path = treerowRef.get_path() + iter = self.liststore.get_iter(path) + return iter + + def updateProgress(self, thread_id, percentComplete, progressBarText, imageSize): + + iter = self._getThreadMap(thread_id) + + self.liststore.set_value(iter, 3, percentComplete) + self.liststore.set_value(iter, 4, progressBarText) + if percentComplete or imageSize: + self.parentApp.updateOverallProgress(thread_id, imageSize, percentComplete) + + + def rowHeight(self): + if not self.mapThreadToRow: + return 0 + else: + index = self.mapThreadToRow.keys()[0] + path = self.mapThreadToRow[index].get_path() + col = self.get_column(0) + return self.get_background_area(path, col)[3] + +class ImageHBox(gtk.HBox): + """ + Displays thumbnails of the images being downloaded + """ + + def __init__(self, parentApp): + gtk.HBox.__init__(self) + self.parentApp = parentApp + self.padding = hd.CONTROL_IN_TABLE_SPACE / 2 + + #create image used to lighten thumbnails + self.white = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, width=100, height=100) + #fill with white + self.white.fill(0xffffffff) + + #load missing image + self.missingThumbnail = gtk.gdk.pixbuf_new_from_file_at_size(paths.share_dir('glade3/image-missing.svg'), 100, 100) + + def addImage(self, thread_id, thumbnail, orientation, filename, imageDownloaded): + """ + Add thumbnail + + Orientation indicates if the thumbnail needs to be rotated or not. + """ + + if not thumbnail: + pixbuf = self.missingThumbnail + else: + try: + pbloader = gdk.PixbufLoader() + pbloader.write(thumbnail) + # Get the resulting pixbuf and build an image to be displayed + pixbuf = pbloader.get_pixbuf() + pbloader.close() + + except: + log_dialog.addMessage(thread_id, config.WARNING, + _('Thumbnail cannot be displayed'), filename, + _('It may be corrupted')) + pixbuf = self.missingThumbnail + + if not pixbuf: + log_dialog.addMessage(thread_id, config.WARNING, + _('Thumbnail cannot be displayed'), filename, + _('It may be corrupted')) + pixbuf = self.missingThumbnail + else: + # rotate if necessary + if orientation == 8: + pixbuf = pixbuf.rotate_simple(gdk.PIXBUF_ROTATE_COUNTERCLOCKWISE) + + # scale to size + pixbuf = common.scale2pixbuf(100, 100, pixbuf) + if not imageDownloaded: + # lighten it + self.white.composite(pixbuf, 0, 0, pixbuf.props.width, pixbuf.props.height, 0, 0, 1.0, 1.0, gtk.gdk.INTERP_HYPER, 180) + + image = gtk.Image() + image.set_from_pixbuf(pixbuf) + + self.pack_start(image, expand=False, padding=self.padding) + image.show() + + # move viewport to display the latest image + adjustment = self.parentApp.image_scrolledwindow.get_hadjustment() + adjustment.set_value(adjustment.upper) + + +class UseDeviceDialog(gtk.Dialog): + def __init__(self, parent_window, path, volume, autostart, postChoiceCB): + gtk.Dialog.__init__(self, _('Device Detected'), None, + gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, + (gtk.STOCK_NO, gtk.RESPONSE_CANCEL, + gtk.STOCK_YES, gtk.RESPONSE_OK)) + + self.postChoiceCB = postChoiceCB + + self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader-about.png')) + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt + prompt_label = gtk.Label(_('Should this device or partition be used to download images from?')) + prompt_label.set_line_wrap(True) + device_label = gtk.Label() + device_label.set_markup("<b>%s</b>" % volume.get_name(limit=0)) + device_hbox = gtk.HBox() + device_hbox.pack_start(device_label, False, False) + path_label = gtk.Label() + path_label.set_markup("<i>%s</i>" % path) + path_hbox = gtk.HBox() + path_hbox.pack_start(path_label, False, False) + + icon = volume.get_icon_pixbuf(36) + if icon: + image = gtk.Image() + image.set_from_pixbuf(icon) + + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt + self.always_checkbutton = gtk.CheckButton(_('_Remember this choice'), True) + + if icon: + device_hbox_icon = gtk.HBox(homogeneous=False, spacing=6) + device_hbox_icon.pack_start(image, False, False, padding = 6) + device_vbox = gtk.VBox(homogeneous=True, spacing=6) + device_vbox.pack_start(device_hbox, False, False) + device_vbox.pack_start(path_hbox, False, False) + device_hbox_icon.pack_start(device_vbox, False, False) + self.vbox.pack_start(device_hbox_icon, padding = 6) + else: + self.vbox.pack_start(device_hbox, padding=6) + self.vbox.pack_start(path_hbox, padding = 6) + + self.vbox.pack_start(prompt_label, padding=6) + self.vbox.pack_start(self.always_checkbutton, padding=6) + + self.set_border_width(6) + self.set_has_separator(False) + + self.set_default_response(gtk.RESPONSE_OK) + + + self.set_transient_for(parent_window) + self.show_all() + self.path = path + self.volume = volume + self.autostart = autostart + + self.connect('response', self.on_response) + + def on_response(self, device_dialog, response): + userSelected = False + permanent_choice = self.always_checkbutton.get_active() + if response == gtk.RESPONSE_OK: + userSelected = True + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt + cmd_line(_("%s selected for downloading from" % self.volume.get_name(limit=0))) + if permanent_choice: + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt + cmd_line(_("This device or partition will always be used to download from")) + else: + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt + cmd_line(_("%s rejected as a download device" % self.volume.get_name(limit=0))) + if permanent_choice: + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#usedeviceprompt + cmd_line(_("This device or partition will never be used to download from")) + + self.postChoiceCB(self, userSelected, permanent_choice, self.path, + self.volume, self.autostart) + +class JobCodeDialog(gtk.Dialog): + """ Dialog prompting for a job code""" + + def __init__(self, parent_window, job_codes, default_job_code, postJobCodeEntryCB, autoStart): + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode + gtk.Dialog.__init__(self, _('Enter a Job Code'), None, + gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, + (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, + gtk.STOCK_OK, gtk.RESPONSE_OK)) + + + self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader-about.png')) + self.postJobCodeEntryCB = postJobCodeEntryCB + self.autoStart = autoStart + + self.combobox = gtk.combo_box_entry_new_text() + for text in job_codes: + self.combobox.append_text(text) + + self.job_code_hbox = gtk.HBox(homogeneous = False) + + if len(job_codes): + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode + task_label = gtk.Label(_('Enter a new job code, or select a previous one.')) + else: + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode + task_label = gtk.Label(_('Enter a new job code.')) + task_label.set_line_wrap(True) + task_hbox = gtk.HBox() + task_hbox.pack_start(task_label, False, False, padding=6) + + label = gtk.Label(_('Job Code:')) + self.job_code_hbox.pack_start(label, False, False, padding=6) + self.job_code_hbox.pack_start(self.combobox, True, True, padding=6) + + self.set_border_width(6) + self.set_has_separator(False) + + # make entry box have entry completion + self.entry = self.combobox.child + + completion = gtk.EntryCompletion() + completion.set_match_func(self.match_func) + completion.connect("match-selected", + self.on_completion_match) + completion.set_model(self.combobox.get_model()) + completion.set_text_column(0) + self.entry.set_completion(completion) + + # when user hits enter, close the dialog window + self.set_default_response(gtk.RESPONSE_OK) + self.entry.set_activates_default(True) + + if default_job_code: + self.entry.set_text(default_job_code) + + self.vbox.pack_start(task_hbox, False, False, padding = 6) + self.vbox.pack_start(self.job_code_hbox, False, False, padding=12) + + self.set_transient_for(parent_window) + self.show_all() + self.connect('response', self.on_job_code_resp) + + def match_func(self, completion, key, iter): + model = completion.get_model() + return model[iter][0].startswith(self.entry.get_text()) + + def on_completion_match(self, completion, model, iter): + self.entry.set_text(model[iter][0]) + self.entry.set_position(-1) + + def get_job_code(self): + return self.combobox.child.get_text() + + def on_job_code_resp(self, jc_dialog, response): + userChoseCode = False + if response == gtk.RESPONSE_OK: + userChoseCode = True + cmd_line(_("Job Code entered")) + else: + cmd_line(_("Job Code not entered")) + self.postJobCodeEntryCB(self, userChoseCode, self.get_job_code(), self.autoStart) + + +class LogDialog(gnomeglade.Component): + """ + Displays a log of errors, warnings or other information to the user + """ + + def __init__(self, parentApp): + """ + Initialize values for log dialog, but do not display. + """ + + gnomeglade.Component.__init__(self, + paths.share_dir(config.GLADE_FILE), + "logdialog") + + + self.widget.connect("delete-event", self.hide_window) + + self.parentApp = parentApp + self.log_textview.set_cursor_visible(False) + self.textbuffer = self.log_textview.get_buffer() + + self.problemTag = self.textbuffer.create_tag(weight=pango.WEIGHT_BOLD) + self.resolutionTag = self.textbuffer.create_tag(style=pango.STYLE_ITALIC) + + def addMessage(self, thread_id, severity, problem, details, resolution): + if severity in [config.CRITICAL_ERROR, config.SERIOUS_ERROR]: + self.parentApp.error_image.show() + elif severity == config.WARNING: + self.parentApp.warning_image.show() + self.parentApp.warning_vseparator.show() + + iter = self.textbuffer.get_end_iter() + self.textbuffer.insert_with_tags(iter, problem +"\n", self.problemTag) + if details: + iter = self.textbuffer.get_end_iter() + self.textbuffer.insert(iter, details + "\n") + if resolution: + iter = self.textbuffer.get_end_iter() + self.textbuffer.insert_with_tags(iter, resolution +"\n", self.resolutionTag) + + iter = self.textbuffer.get_end_iter() + self.textbuffer.insert(iter, "\n") + + # move viewport to display the latest message + adjustment = self.log_scrolledwindow.get_vadjustment() + adjustment.set_value(adjustment.upper) + + + def on_logdialog_response(self, dialog, arg): + if arg == gtk.RESPONSE_CLOSE: + pass + self.parentApp.error_image.hide() + self.parentApp.warning_image.hide() + self.parentApp.warning_vseparator.hide() + self.parentApp.prefs.show_log_dialog = False + self.widget.hide() + return True + + def hide_window(self, window, event): + window.hide() + return True + + + +class RapidApp(gnomeglade.GnomeApp, dbus.service.Object): + def __init__(self, bus, path, name): + + dbus.service.Object.__init__ (self, bus, path, name) + self.running = False + + gladefile = paths.share_dir(config.GLADE_FILE) + + gnomeglade.GnomeApp.__init__(self, "rapid", __version__, gladefile, "rapidapp") + + + # notifications + self.displayDownloadSummaryNotification = False + self.initPyNotify() + + self.prefs = RapidPreferences() + self.prefs.notify_add(self.on_preference_changed) + + self.testing = False + if self.testing: + self.setTestingEnv() + +# sys.exit(0) + + self.widget.show() + + displayPreferences = self.checkForUpgrade(__version__) + self.prefs.program_version = __version__ + + self.timeRemaining = TimeRemaining() + self._resetDownloadInfo() + self.statusbar_context_id = self.rapid_statusbar.get_context_id("progress") + + # hide display of warning and error symbols in the taskbar until they are needed + self.error_image.hide() + self.warning_image.hide() + self.warning_vseparator.hide() + + if not displayPreferences: + displayPreferences = not self.checkPreferencesOnStartup() + + # display download information using threads + global media_collection_treeview, image_hbox, log_dialog + global download_queue, image_queue, log_queue + global workers + + #track files that should have a suffix added to them + global duplicate_files + + # control sequence numbers and letters + global sequences + + # whether we need to prompt for a job code + global need_job_code + + duplicate_files = {} + + downloadsToday = self.prefs.getAndMaybeResetDownloadsToday() + sequences = rn.Sequences(downloadsToday, self.prefs.stored_sequence_no) + + self.downloadStats = DownloadStats() + + # set the number of seconds gap with which to measure download time remaing + self.downloadTimeGap = 3 + + #locks for threadsafe file downloading and stats gathering + self.fileRenameLock = Lock() + self.fileSequenceLock = Lock() + self.statsLock = Lock() + + # log window, in dialog format + # used for displaying download information to the user + + log_dialog = LogDialog(self) + + + self.volumeMonitor = None + if self.usingVolumeMonitor(): + self.startVolumeMonitor() + + + # set up tree view display to display image devices and download status + media_collection_treeview = MediaTreeView(self) + + self.media_collection_vbox.pack_start(media_collection_treeview) + + #thumbnail display + image_hbox = ImageHBox(self) + self.image_viewport.add(image_hbox) + self.image_viewport.modify_bg(gtk.STATE_NORMAL, gdk.color_parse("white")) + self.set_display_thumbnails(self.prefs.display_thumbnails) + + self.backupVolumes = {} + + self._setupDownloadbutton() + + #status bar progress bar + self.download_progressbar = gtk.ProgressBar() + self.download_progressbar.set_size_request(150, -1) + self.download_progressbar.show() + self.download_progressbar_hbox.pack_start(self.download_progressbar, expand=False, + fill=0) + + + # menus + + self.menu_display_thumbnails.set_active(self.prefs.display_thumbnails) + self.menu_clear.set_sensitive(False) + + #job code initialization + need_job_code = self.needJobCode() + self.last_chosen_job_code = None + self.prompting_for_job_code = False + + #setup download and backup mediums, initiating scans + self.setupAvailableImageAndBackupMedia(onStartup=True, onPreferenceChange=False, doNotAllowAutoStart = displayPreferences) + + #adjust viewport size for displaying media + #this is important because the code in MediaTreeView.addCard() is inaccurate at program startup + + height = self.media_collection_viewport.size_request()[1] + self.media_collection_scrolledwindow.set_size_request(-1, height) + + self.download_button.grab_default() + # for some reason, the grab focus command is not working... unsure why + self.download_button.grab_focus() + + if displayPreferences: + PreferencesDialog(self) + + + + @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 + self.main() + self.running = False + + def setTestingEnv(self): + self.prefs.program_version = '0.0.8~b7' + r = ['Date time', 'Image date', 'YYYYMMDD', 'Text', '-', '', 'Date time', 'Image date', 'HHMM', 'Text', '-', '', 'Session number', '1', 'Three digits', 'Text', '-iso', '', 'Metadata', 'ISO', '', 'Text', '-f', '', 'Metadata', 'Aperture', '', 'Text', '-', '', 'Metadata', 'Focal length', '', 'Text', 'mm-', '', 'Metadata', 'Exposure time', '', 'Filename', 'Extension', 'lowercase'] + self.prefs.image_rename = r + + + + def checkPreferencesOnStartup(self): + prefsOk = rn.checkPreferencesForValidity(self.prefs.image_rename, self.prefs.subfolder) + if not prefsOk: + title = PROGRAM_NAME + msg = _("There is an error in the program preferences.") + msg += " " + _("Some preferences will be reset.") + sys.stderr.write(msg +'\n') +# misc.run_dialog(title, msg) + return prefsOk + + def needJobCode(self): + return rn.usesJobCode(self.prefs.image_rename) or rn.usesJobCode(self.prefs.subfolder) + + def assignJobCode(self, code): + """ assign job code (which may be empty) to global variable and update user preferences + + Update preferences only if code is not empty. Do not duplicate job code. + """ + global job_code + if code == None: + code = '' + job_code = code + + if job_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 getUseDevice(self, path, volume, autostart): + """ Prompt user whether or not to download from this device """ + + cmd_line(_("Prompting whether to use %s" % volume.get_name(limit=0))) + d = UseDeviceDialog(self.widget, path, volume, autostart, self.gotUseDevice) + + def gotUseDevice(self, dialog, userSelected, permanent_choice, path, volume, autostart): + """ User has chosen whether or not to use a device to download from """ + dialog.destroy() + + if userSelected: + if permanent_choice and path not in self.prefs.device_whitelist: + # do not do a list append operation here without the assignment, or the preferences will not be updated! + if len(self.prefs.device_whitelist): + self.prefs.device_whitelist = self.prefs.device_whitelist + [path] + else: + self.prefs.device_whitelist = [path] + self.initiateScan(path, volume, autostart) + + elif permanent_choice and path not in self.prefs.device_blacklist: + # do not do a list append operation here without the assignment, or the preferences will not be updated! + if len(self.prefs.device_blacklist): + self.prefs.device_blacklist = self.prefs.device_blacklist + [path] + else: + self.prefs.device_blacklist = [path] + + def _getJobCode(self, postJobCodeEntryCB, autoStart): + """ prompt for a job code """ + + + if not self.prompting_for_job_code: + cmd_line(_("Prompting for Job Code")) + self.prompting_for_job_code = True + j = JobCodeDialog(self.widget, self.prefs.job_codes, self.last_chosen_job_code, postJobCodeEntryCB, autoStart) + else: + cmd_line(_("Already prompting for Job Code, do not prompt again")) + + def getJobCode(self, autoStart=True): + """ called from the copyphotos thread""" + + self._getJobCode(self.gotJobCode, autoStart) + + def gotJobCode(self, dialog, userChoseCode, code, autoStart): + dialog.destroy() + self.prompting_for_job_code = False + + if userChoseCode: + self.assignJobCode(code) + self.last_chosen_job_code = code + if autoStart: + cmd_line(_("Starting downloads that have been waiting for a Job Code")) + for w in workers.getWaitingForJobCodeWorkers(): + w.startStop() + else: + cmd_line(_("Starting downloads")) + self.startDownload() + + + # FIXME: what happens to these workers that are waiting? How will the user start their download? + # check if need to add code to start button + + def checkForUpgrade(self, runningVersion): + """ Checks if the running version of the program is different from the version recorded in the preferences. + + If the version is different, then the preferences are checked to see whether they should be upgraded or not. + + returns True if program preferences window should be opened """ + + displayPrefs = upgraded = False + + previousVersion = self.prefs.program_version + if previousVersion: + # the program has been run previously for this user + + pv = common.pythonifyVersion(previousVersion) + rv = common.pythonifyVersion(runningVersion) + + title = PROGRAM_NAME + imageRename = subfolder = None + + if pv != rv: + if pv > rv: + prefsOk = rn.checkPreferencesForValidity(self.prefs.image_rename, self.prefs.subfolder) + + msg = _("A newer version of this program was previously run on this computer.\n\n") + if prefsOk: + msg += _("Program preferences appear to be valid, but please check them to ensure correct operation.") + else: + msg += _("Sorry, some preferences are invalid and will be reset.") + sys.stderr.write(_("Warning:") + " %s\n" % msg) + misc.run_dialog(title, msg) + displayPrefs = True + + else: + cmd_line(_("This version of the program is newer than the previously run version. Checking preferences.")) +# if True: + if rn.checkPreferencesForValidity(self.prefs.image_rename, self.prefs.subfolder, previousVersion): + upgraded, imageRename, subfolder = rn.upgradePreferencesToCurrent(self.prefs.image_rename, self.prefs.subfolder, previousVersion) + if upgraded: + self.prefs.image_rename = imageRename + self.prefs.subfolder = subfolder + cmd_line(_("Preferences were modified.")) + msg = _('This version of the program uses different preferences than the old version. Your preferences have been updated.\n\nPlease check them to ensure correct operation.') + misc.run_dialog(title, msg) + displayPrefs = True + else: + cmd_line(_("No preferences needed to be changed.")) + else: + msg = _('This version of the program uses different preferences than the old version. Some of your previous preferences were invalid, and could not be updated. They will be reset.') + sys.stderr.write(msg + "\n") + misc.run_dialog(title, msg) + displayPrefs = True + + return displayPrefs + + def initPyNotify(self): + if not pynotify.init("TestCaps"): + sys.stderr.write(_("Problem using pynotify.") + "\n") + sys.exit(1) + + capabilities = {'actions': False, + 'body': False, + 'body-hyperlinks': False, + 'body-images': False, + 'body-markup': False, + 'icon-multi': False, + 'icon-static': False, + 'sound': False, + 'image/svg+xml': False, + 'append': False} + + caps = pynotify.get_server_caps () + if caps is None: + sys.stderr.write(_("Failed to receive pynotify server capabilities.") + "\n") + sys.exit (1) + + for cap in caps: + capabilities[cap] = True + + info = pynotify.get_server_info() + + def usingVolumeMonitor(self): + """ + Returns True if programs needs to use gio or gnomevfs volume monitor + """ + + return (self.prefs.device_autodetection or + (self.prefs.backup_images and + self.prefs.backup_device_autodetection + )) + + + def startVolumeMonitor(self): + if not self.volumeMonitor: + self.volumeMonitor = VMonitor(self) + + def displayBackupVolumes(self): + """ + Create a message to be displayed to the user showing which backup volumes will be used + """ + message = '' + + paths = self.backupVolumes.keys() + i = 0 + v = len(paths) + prefix = '' + for b in paths: + if v > 1: + if i < (v -1) and i > 0: + prefix = ', ' + elif i == (v - 1) : + prefix = " " + _("and") + " " + i += 1 + message = "%s%s'%s'" % (message, prefix, self.backupVolumes[b].get_name()) + + if v > 1: + message = _("Using backup devices") + " %s" % message + elif v == 1: + message = _("Using backup device") + " %s" % message + else: + message = _("No backup devices detected") + + return message + + def searchForPsd(self): + """ + Check to see if user preferences are to automatically search for Portable Storage Devices or not + """ + return self.prefs.device_autodetection_psd and self.prefs.device_autodetection + + + def isGProxyShadowMount(self, gvfsVolume): + + """ gvfs GProxyShadowMount are used for camera specific things, not the data in the memory card """ + if using_gio: + #FIXME: this is a hack, but what is the correct function? + return str(type(gvfsVolume)).find('GProxyShadowMount') >= 0 + else: + return False + + def workerHasThisPath(self, path): + havePath= False + for w in workers.getNonFinishedWorkers(): + if w.cardMedia.path == path: + havePath = True + break + return havePath + + def on_volume_mounted(self, monitor, mount): + """ + callback run when gnomevfs indicates a new volume + has been mounted + """ + + if self.usingVolumeMonitor(): + volume = Volume(mount) + path = volume.get_path() + + if path in self.prefs.device_blacklist and self.searchForPsd(): + cmd_line(_("Device %(device)s (%(path)s) ignored") % { + 'device': volume.get_name(limit=0), 'path': path}) + else: + if not self.isGProxyShadowMount(mount): + self._printDetectedDevice(volume.get_name(limit=0), path) + + isBackupVolume = self.checkIfBackupVolume(path) + + if isBackupVolume: + backupPath = os.path.join(path, self.prefs.backup_identifier) + if path not in self.backupVolumes: + self.backupVolumes[backupPath] = volume + self.rapid_statusbar.push(self.statusbar_context_id, self.displayBackupVolumes()) + + elif media.isImageMedia(path) or self.searchForPsd(): + if self.searchForPsd() and path not in self.prefs.device_whitelist: + # prompt user if device should be used or not + self.getUseDevice(path, volume, self.prefs.auto_download_upon_device_insertion) + else: + self._printAutoStart(self.prefs.auto_download_upon_device_insertion) + self.initiateScan(path, volume, self.prefs.auto_download_upon_device_insertion) + + def initiateScan(self, path, volume, autostart): + """ initiates scan of image device""" + cardMedia = CardMedia(path, volume, True) + i = workers.getNextThread_id() + + workers.append(CopyPhotos(i, self, self.fileRenameLock, self.fileSequenceLock, self.statsLock, + self.downloadStats, autostart, + cardMedia)) + + + self.setDownloadButtonSensitivity() + self.startScan() + + + def on_volume_unmounted(self, monitor, volume): + """ + callback run when gnomevfs indicates a volume + has been unmounted + """ + volume = Volume(volume) + path = volume.get_path() + + # four scenarios - + # volume is waiting to be scanned + # the volume has been scanned but downloading has not yet started + # images are being downloaded from volume (it must be a messy unmount) + # images finished downloading from volume + + if path: + # first scenario + for w in workers.getReadyToStartWorkers(): + if w.cardMedia.volume == volume: + media_collection_treeview.removeCard(w.thread_id) + workers.disableWorker(w.thread_id) + # second scenario + for w in workers.getReadyToDownloadWorkers(): + if w.cardMedia.volume == volume: + media_collection_treeview.removeCard(w.thread_id) + workers.disableWorker(w.thread_id) + + # fourth scenario - nothing to do + + # remove backup volumes + backupPath = os.path.join(path, self.prefs.backup_identifier) + if backupPath in self.backupVolumes: + del self.backupVolumes[backupPath] + self.rapid_statusbar.push(self.statusbar_context_id, self.displayBackupVolumes()) + + + + def clearCompletedDownloads(self): + """ + clears the display of completed downloads + """ + + for w in workers.getFinishedWorkers(): + media_collection_treeview.removeCard(w.thread_id) + + + + + def clearNotStartedDownloads(self): + """ + Clears the display of the download and instructs the thread not to run + """ + + for w in workers.getNotDownloadingWorkers(): + media_collection_treeview.removeCard(w.thread_id) + workers.disableWorker(w.thread_id) + + def checkIfBackupVolume(self, path): + """ + Checks to see if backups are enabled and path represents a valid backup location + + Checks against user preferences. + """ + if self.prefs.backup_images: + if self.prefs.backup_device_autodetection: + if media.isBackupMedia(path, self.prefs.backup_identifier): + return True + elif path == self.prefs.backup_location: + # user manually specified the path + return True + return False + + def _printDetectedDevice(self, volume_name, path): + cmd_line (_("Detected %(device)s with path %(path)s") % {'device': volume_name, 'path': path}) + + def _printAutoStart(self, autoStart): + if autoStart: + cmd_line(_("Automatically start download is true") ) + else: + cmd_line(_("Automatically start download is false") ) + + def setupAvailableImageAndBackupMedia(self, onStartup, onPreferenceChange, doNotAllowAutoStart): + """ + Sets up volumes for downloading from and backing up to + + onStartup should be True if the program is still starting, i.e. this is being called from the + program's initialization. + + onPreferenceChange should be True if this is being called as the result of a preference + bring changed + + Removes any image media that are currently not downloaded, + or finished downloading + """ + + self.clearNotStartedDownloads() + + volumeList = [] + self.backupVolumes = {} + + if not workers.noDownloadingWorkers(): + self.downloadStats.clear() + self._resetDownloadInfo() + + if self.usingVolumeMonitor(): + # either using automatically detected backup devices + # or image devices + + for v in self.volumeMonitor.get_mounts(): + volume = Volume(v) + path = volume.get_path(avoid_gnomeVFS_bug = True) + + if path: + if path in self.prefs.device_blacklist and self.searchForPsd(): + cmd_line(_("Device %(device)s (%(path)s) ignored") % { + 'device': volume.get_name(limit=0), + 'path': path}) + else: + if not self.isGProxyShadowMount(v): + self._printDetectedDevice(volume.get_name(limit=0), path) + isBackupVolume = self.checkIfBackupVolume(path) + if isBackupVolume: + backupPath = os.path.join(path, self.prefs.backup_identifier) + self.backupVolumes[backupPath] = volume + elif self.prefs.device_autodetection and (media.isImageMedia(path) or self.searchForPsd()): + volumeList.append((path, volume)) + + + if not self.prefs.device_autodetection: + # user manually specified the path from which to download images + path = self.prefs.device_location + if path: + cmd_line(_("Using manually specified path") + " %s" % path) + volumeList.append((path, None)) + + if self.prefs.backup_images: + if not self.prefs.backup_device_autodetection: + # user manually specified backup location + self.backupVolumes[self.prefs.backup_location] = None + self.rapid_statusbar.push(self.statusbar_context_id, '') + else: + self.rapid_statusbar.push(self.statusbar_context_id, self.displayBackupVolumes()) + + else: + self.rapid_statusbar.push(self.statusbar_context_id, '') + + # add each memory card / other device to the list of threads + + if doNotAllowAutoStart: + autoStart = False + else: + autoStart = (not onPreferenceChange) and ((self.prefs.auto_download_at_startup and onStartup) or (self.prefs.auto_download_upon_device_insertion and not onStartup)) + + self._printAutoStart(autoStart) + + for i in range(len(volumeList)): + path, volume = volumeList[i] + if self.searchForPsd() and path not in self.prefs.device_whitelist: + # prompt user to see if device should be used or not + self.getUseDevice(path, volume, autoStart) + else: + self.initiateScan(path, volume, autoStart) + + def _setupDownloadbutton(self): + + self.download_hbutton_box = gtk.HButtonBox() + self.download_button_is_download = True + self.download_button = gtk.Button() + self.download_button.set_use_underline(True) + self.download_button.set_flags(gtk.CAN_DEFAULT) + self._set_download_button() + self.download_button.connect('clicked', self.on_download_button_clicked) + self.download_hbutton_box.set_layout(gtk.BUTTONBOX_START) + self.download_hbutton_box.pack_start(self.download_button) + self.download_hbutton_box.show_all() + self.buttons_hbox.pack_start(self.download_hbutton_box, + padding=hd.WINDOW_BORDER_SPACE) + + self.setDownloadButtonSensitivity() + + + def set_display_thumbnails(self, value): + if value: + self.image_scrolledwindow.show_all() + else: + self.image_scrolledwindow.hide() + + + def _resetDownloadInfo(self): + self.markSet = False + self.startTime = None + self.totalDownloadSize = self.totalDownloadedSoFar = 0 + self.totalDownloadSizeThisRun = self.totalDownloadedSoFarThisRun = 0 + # there is no need to clear self.timeRemaining, as when each thread is completed, it removes itself + + global job_code + job_code = None + + def addToTotalDownloadSize(self, size): + self.totalDownloadSize += size + + def setOverallDownloadMark(self): + if not self.markSet: + self.markSet = True + self.totalDownloadSizeThisRun = self.totalDownloadSize - self.totalDownloadedSoFar + self.totalDownloadedSoFarThisRun = 0 + + self.startTime = time.time() + self.timeStatusBarUpdated = self.startTime + + self.timeMark = self.startTime + self.sizeMark = 0 + + def startOrResumeWorkers(self): + + # resume any paused workers + for w in workers.getPausedDownloadingWorkers(): + w.startStop() + self.timeRemaining.setTimeMark(w) + + #start any new workers + workers.startDownloadingWorkers() + + if is_beta and verbose: + workers.printWorkerStatus() + + + def updateOverallProgress(self, thread_id, imageSize, percentComplete): + """ + Updates progress bar and status bar text with time remaining + to download images + """ + + self.totalDownloadedSoFar += imageSize + self.totalDownloadedSoFarThisRun += imageSize + + fraction = self.totalDownloadedSoFar / float(self.totalDownloadSize) + + self.download_progressbar.set_fraction(fraction) + + if percentComplete == 100.0: + self.menu_clear.set_sensitive(True) + self.timeRemaining.remove(thread_id) + + if self.downloadComplete(): + # finished all downloads + self.rapid_statusbar.push(self.statusbar_context_id, "") + self.download_button_is_download = True + self._set_download_button() + self.setDownloadButtonSensitivity() + cmd_line(_("All downloads complete")) + if is_beta and verbose: + workers.printWorkerStatus() + + else: + now = time.time() + self.timeRemaining.update(thread_id, imageSize) + + if now > (self.downloadTimeGap + self.timeMark): + amtTime = now - self.timeMark + self.timeMark = now + amtDownloaded = self.totalDownloadedSoFarThisRun - self.sizeMark + self.sizeMark = self.totalDownloadedSoFarThisRun + amtToDownload = float(self.totalDownloadSizeThisRun) - self.totalDownloadedSoFarThisRun + downloadSpeed = "%1.1f" % (amtDownloaded / 1048576 / amtTime) +_("MB/s") + self.speed_label.set_text(downloadSpeed) + + timeRemaining = self.timeRemaining.timeRemaining() + if timeRemaining: + secs = int(timeRemaining) + + if secs == 0: + message = "" + elif secs == 1: + message = _("About 1 second remaining") + elif secs < 60: + message = _("About %i seconds remaining") % secs + elif secs == 60: + message = _("About 1 minute remaining") + else: + # Translators: in the text '%(minutes)i:%(seconds)02i', only the : should be translated, if needed. + # '%(minutes)i' and '%(seconds)02i' should not be modified or left out. They are used to format and display the amount + # of time the download has remainging, e.g. 'About 5:36 minutes remaining' + message = _("About %(minutes)i:%(seconds)02i minutes remaining") % {'minutes': secs / 60, 'seconds': secs % 60} + + self.rapid_statusbar.push(self.statusbar_context_id, message) + + + def resetSequences(self): + if self.downloadComplete(): + sequences.reset(self.prefs.getDownloadsToday(), self.prefs.stored_sequence_no) + + def notifyUserAllDownloadsComplete(self): + """ Possibly notify the user all downloads are complete using libnotify + + Reset progress bar info""" + + if self.downloadComplete(): + if self.displayDownloadSummaryNotification: + message = _("All downloads complete") + message += "\n%s " % self.downloadStats.noImagesDownloaded + _("images downloaded") + if self.downloadStats.noImagesSkipped: + message = "%s\n%s " % (message, self.downloadStats.noImagesSkipped) + _("images skipped") + if self.downloadStats.noWarnings: + message = "%s\n%s " % (message, self.downloadStats.noWarnings) + _("warnings") + if self.downloadStats.noErrors: + message = "%s\n%s " % (message, self.downloadStats.noErrors) +_("errors") + n = pynotify.Notification(PROGRAM_NAME, message) + n.show() + self.displayDownloadSummaryNotification = False # don't show it again unless needed + self.downloadStats.clear() + self._resetDownloadInfo() + self.speed_label.set_text(' ') + + def exitOnDownloadComplete(self): + if self.downloadComplete(): + if self.prefs.auto_exit: + if not (self.downloadStats.noErrors or self.downloadStats.noWarnings): + self.quit() + + def downloadComplete(self): + return self.totalDownloadedSoFar == self.totalDownloadSize + + def setDownloadButtonSensitivity(self): + + isSensitive = workers.noReadyToDownloadWorkers() > 0 or workers.noDownloadingWorkers() > 0 + + if isSensitive: + self.download_button.props.sensitive = True + self.menu_download_pause.props.sensitive = True + else: + self.download_button.props.sensitive = False + self.menu_download_pause.props.sensitive = False + + return isSensitive + + + def on_rapidapp_destroy(self, widget): + """Called when the application is going to quit""" + workers.quitAllWorkers() + + self.flushevents() + + display_queue.close("w") + + + def on_menu_clear_activate(self, widget): + self.clearCompletedDownloads() + widget.set_sensitive(False) + + def on_menu_report_problem_activate(self, widget): + webbrowser.open("https://bugs.launchpad.net/rapid") + + def on_menu_get_help_online_activate(self, widget): + webbrowser.open("http://www.damonlynch.net/rapid/help.html") + + def on_menu_donate_activate(self, widget): + webbrowser.open("http://www.damonlynch.net/rapid/donate.html") + + def on_menu_translate_activate(self, widget): + webbrowser.open("http://www.damonlynch.net/rapid/translate.html") + + def on_menu_preferences_activate(self, widget): + """ Sets preferences for the application using dialog window """ + + PreferencesDialog(self) + + def on_menu_log_window_toggled(self, widget): + active = widget.get_active() + self.prefs.show_log_dialog = active + if active: + log_dialog.widget.show() + else: + log_dialog.widget.hide() + + def on_menu_display_thumbnails_toggled(self, check_button): + self.prefs.display_thumbnails = check_button.get_active() + + def on_menu_about_activate(self, widget): + """ Display about dialog box """ + + about = gtk.glade.XML(paths.share_dir(config.GLADE_FILE), "about").get_widget("about") + about.set_property("name", PROGRAM_NAME) + about.set_property("version", __version__) + about.run() + about.destroy() + + def _set_download_button(self): + """ + Sets download button to appropriate state + """ + if self.download_button_is_download: + # This text will be displayed to the user on the Download / Pause button. + # Please note the space at the end of the label - it is needed to meet the Gnome Human Interface Guidelines + self.download_button.set_label(_("_Download ")) + self.download_button.set_image(gtk.image_new_from_stock( + gtk.STOCK_CONVERT, + gtk.ICON_SIZE_BUTTON)) + else: + # button should indicate paused state + self.download_button.set_image(gtk.image_new_from_stock( + gtk.STOCK_MEDIA_PAUSE, + gtk.ICON_SIZE_BUTTON)) + # This text will be displayed to the user on the Download / Pause button. + self.download_button.set_label(_("_Pause") + " ") + + def on_menu_download_pause_activate(self, widget): + self.on_download_button_clicked(widget) + + def startScan(self): + if workers.noReadyToStartWorkers() > 0: + workers.startWorkers() + + + + def postStartDownloadTasks(self): + if workers.noDownloadingWorkers() > 1: + self.displayDownloadSummaryNotification = True + + # set button to display Pause + self.download_button_is_download = False + self._set_download_button() + + def startDownload(self): + self.startOrResumeWorkers() + self.postStartDownloadTasks() + + def pauseDownload(self): + for w in workers.getDownloadingWorkers(): + w.startStop() + # set button to display Download + if not self.download_button_is_download: + self.download_button_is_download = True + self._set_download_button() + + def on_download_button_clicked(self, widget): + """ + Handle download button click. + + Button is in one of two states: download, or pause. + + If download, a click indicates to start or resume a download run. + If pause, a click indicates to pause all running downloads. + """ + if self.download_button_is_download: + if need_job_code and job_code == None and not self.prompting_for_job_code: + self.getJobCode(autoStart=False) + else: + self.startDownload() + else: + self.pauseDownload() + + def on_preference_changed(self, key, value): + """ + Called when user changes the program's preferences + """ + + if key == 'display_thumbnails': + self.set_display_thumbnails(value) + elif key == 'show_log_dialog': + self.menu_log_window.set_active(value) + elif key in ['device_autodetection', 'device_autodetection_psd', 'backup_images', 'device_location', + 'backup_device_autodetection', 'backup_location' ]: + if self.usingVolumeMonitor(): + self.startVolumeMonitor() + cmd_line("\n" + _("Preferences were changed.")) + + self.setupAvailableImageAndBackupMedia(onStartup = False, onPreferenceChange = True, doNotAllowAutoStart = False) + if is_beta and verbose: + print "Current worker status:" + workers.printWorkerStatus() + elif key in ['subfolder', 'image_rename']: + global need_job_code + need_job_code = self.needJobCode() + + + + def on_error_eventbox_button_press_event(self, widget, event): + self.prefs.show_log_dialog = True + log_dialog.widget.show() + +class VMonitor: + """ Transistion to gvfs from gnomevfs""" + def __init__(self, app): + self.app = app + if using_gio: + self.vmonitor = gio.volume_monitor_get() + self.vmonitor.connect("mount-added", self.app.on_volume_mounted) + self.vmonitor.connect("mount-removed", self.app.on_volume_unmounted) + else: + self.vmonitor = gnomevfs.VolumeMonitor() + self.vmonitor.connect("volume-mounted", self.app.on_volume_mounted) + self.vmonitor.connect("volume-unmounted", self.app.on_volume_unmounted) + + + def get_mounts(self): + if using_gio: + return self.vmonitor.get_mounts() + else: + return self.vmonitor.get_mounted_volumes() + +class Volume: + """ Transistion to gvfs from gnomevfs""" + def __init__(self, volume): + self.volume = volume + + def get_name(self, limit=config.MAX_LENGTH_DEVICE_NAME): + if using_gio: + v = self.volume.get_name() + else: + v = self.volume.get_display_name() + + if limit: + if len(v) > limit: + v = v[:limit] + '...' + return v + + def get_path(self, avoid_gnomeVFS_bug = False): + if using_gio: + path = self.volume.get_root().get_path() + else: + uri = self.volume.get_activation_uri() + path = None + if avoid_gnomeVFS_bug: + # ugly hack to work around bug where gnomevfs.get_local_path_from_uri(uri) causes a crash + mediaLocation = "file://" + config.MEDIA_LOCATION + if uri.find(mediaLocation) == 0: + path = gnomevfs.get_local_path_from_uri(uri) + else: + path = gnomevfs.get_local_path_from_uri(uri) + return path + + + def get_icon_pixbuf(self, size): + """ returns icon for the volume, or None if not available""" + + icontheme = gtk.icon_theme_get_default() + + if using_gio: + gicon = self.volume.get_icon() + f = None + if isinstance(gicon, gio.ThemedIcon): + iconinfo = icontheme.choose_icon(gicon.get_names(), size, gtk.ICON_LOOKUP_USE_BUILTIN) + f = iconinfo.get_filename() + try: + v = gtk.gdk.pixbuf_new_from_file_at_size(f, size, size) + except: + f = None + if not f: + v = icontheme.load_icon('gtk-harddisk', size, gtk.ICON_LOOKUP_USE_BUILTIN) + else: + gicon = self.volume.get_icon() + v = icontheme.load_icon(gicon, size, gtk.ICON_LOOKUP_USE_BUILTIN) + return v + + def unmount(self, callback): + self.volume.unmount(callback) + +class DownloadStats: + def __init__(self): + self.clear() + + def adjust(self, size, noImagesDownloaded, noImagesSkipped, noWarnings, noErrors): + self.downloadSize += size + self.noImagesDownloaded += noImagesDownloaded + self.noImagesSkipped += noImagesSkipped + self.noWarnings += noWarnings + self.noErrors += noErrors + + def clear(self): + self.noImagesDownloaded = self.noImagesSkipped = 0 + self.downloadSize = 0 + self.noWarnings = self.noErrors = 0 + +class TimeForDownload: + pass + +class TimeRemaining: + gap = 2 + def __init__(self): + self.clear() + + def add(self, w, size): + if w not in self.times: + t = TimeForDownload() + t.timeRemaining = None + t.size = size + t.downloaded = 0 + t.sizeMark = 0 + t.timeMark = time.time() + self.times[w] = t + + def update(self, w, size): + if w in self.times: + self.times[w].downloaded += size + now = time.time() + tm = self.times[w].timeMark + amtTime = now - tm + if amtTime > self.gap: + self.times[w].timeMark = now + amtDownloaded = self.times[w].downloaded - self.times[w].sizeMark + self.times[w].sizeMark = self.times[w].downloaded + timefraction = amtDownloaded / amtTime + amtToDownload = float(self.times[w].size) - self.times[w].downloaded + self.times[w].timeRemaining = amtToDownload / timefraction + + def _timeEstimates(self): + for t in self.times: + yield self.times[t].timeRemaining + + def timeRemaining(self): + return max(self._timeEstimates()) + + def setTimeMark(self, w): + if w in self.times: + self.times[w].timeMark = time.time() + + def clear(self): + self.times = {} + + def remove(self, w): + if w in self.times: + del self.times[w] + +def programStatus(): + print _("Goodbye") + + +def start (): + global is_beta + is_beta = config.version.find('~b') > 0 + + parser = OptionParser(version= "%%prog %s" % config.version) + parser.set_defaults(verbose=is_beta, extensions=False) + # Translators: this text is displayed to the user when they request information on the command line options. + # The text %default should not be modified or left out. + 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("-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 image file extensions the program recognizes and exit")) + (options, args) = parser.parse_args() + global verbose + verbose = options.verbose + + if verbose: + atexit.register(programStatus) + + if options.extensions: + exts = config.RAW_FILE_EXTENSIONS + config.NON_RAW_IMAGE_FILE_EXTENSIONS + v = '' + for e in exts[:-1]: + v += '%s, ' % e.upper() + v = v[:-1] + ' '+ (_('and %s') % exts[-1].upper()) + print v + sys.exit(0) + + if using_gio: + cmd_line(_("Using") + " GIO") + else: + # Which volume management code is being used (GIO or GnomeVFS) + cmd_line(_("Using") + " GnomeVFS") + + gdk.threads_init() + display_queue.open("rw") + tube.tube_add_watch(display_queue, updateDisplay) + gdk.threads_enter() + + # run only a single instance of the application + bus = dbus.SessionBus () + request = bus.request_name (config.DBUS_NAME, dbus.bus.NAME_FLAG_DO_NOT_QUEUE) + if request != dbus.bus.REQUEST_NAME_REPLY_EXISTS: + app = RapidApp (bus, '/', config.DBUS_NAME) + else: + # this application is already running + print _("%s is already running") % PROGRAM_NAME + object = bus.get_object (config.DBUS_NAME, "/") + app = dbus.Interface (object, config.DBUS_NAME) + + app.start() + gdk.threads_leave() + +if __name__ == "__main__": + start() |