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