summaryrefslogtreecommitdiff
path: root/rapid/rapid.py
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2018-01-04 08:57:25 +0100
committerJörg Frings-Fürst <debian@jff-webhosting.net>2018-01-04 08:57:25 +0100
commit8ce494b17065c724187dd3f9faec1e419496f871 (patch)
treefa0c7fb1296f30bfd0cdc241c7556cec8d1e8ba1 /rapid/rapid.py
parent18afe3e2ebdb10bbc542d79280344d9adf923d2f (diff)
parenteba0a9bd6f142cdb299cc070060723d00e81205f (diff)
Merge branch 'feature/upstream' into develop
Diffstat (limited to 'rapid/rapid.py')
-rwxr-xr-xrapid/rapid.py4177
1 files changed, 0 insertions, 4177 deletions
diff --git a/rapid/rapid.py b/rapid/rapid.py
deleted file mode 100755
index 303e1f7..0000000
--- a/rapid/rapid.py
+++ /dev/null
@@ -1,4177 +0,0 @@
-#!/usr/bin/python
-# -*- coding: latin1 -*-
-
-### Copyright (C) 2011-2014 Damon Lynch <damonlynch@gmail.com>
-
-### This program is free software; you can redistribute it and/or modify
-### it under the terms of the GNU General Public License as published by
-### the Free Software Foundation; either version 2 of the License, or
-### (at your option) any later version.
-
-### This program is distributed in the hope that it will be useful,
-### but WITHOUT ANY WARRANTY; without even the implied warranty of
-### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-### GNU General Public License for more details.
-
-### You should have received a copy of the GNU General Public License
-### along with this program; if not, write to the Free Software
-### Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
-### USA
-
-use_pynotify = True
-
-import tempfile
-
-import dbus
-import dbus.bus
-import dbus.service
-from dbus.mainloop.glib import DBusGMainLoop
-DBusGMainLoop(set_as_default=True)
-
-from optparse import OptionParser
-
-import gtk
-import gtk.gdk as gdk
-
-from gobject.constants import G_MAXINT
-
-import webbrowser
-
-import sys, time, types, os, datetime
-
-import gobject, pango, cairo, array, pangocairo, gio
-
-if use_pynotify:
- import pynotify
-
-from multiprocessing import Process, Pipe, Queue, Event, Value, Array, current_process, log_to_stderr
-from ctypes import c_int, c_bool, c_char
-
-import logging
-logger = log_to_stderr()
-
-# Rapid Photo Downloader modules
-
-import rpdfile
-
-from misc import get_folder_selection
-
-import problemnotification as pn
-import thumbnail as tn
-import rpdmultiprocessing as rpdmp
-
-import preferencesdialog
-import prefsrapid
-
-import tableplusminus as tpm
-import generatename as gn
-
-import downloadtracker
-
-import filemodify
-
-from metadatavideo import DOWNLOAD_VIDEO, file_types_to_download
-import metadataphoto
-import metadatavideo
-import metadataexiftool
-
-import scan as scan_process
-import copyfiles
-import subfolderfile
-import backupfile
-from backupfile import PHOTO_BACKUP, VIDEO_BACKUP, PHOTO_VIDEO_BACKUP
-
-import errorlog
-
-import device as dv
-import utilities
-
-import config
-__version__ = config.version
-
-import paths
-
-import gettext
-gettext.bindtextdomain(config.APP_NAME)
-gettext.textdomain(config.APP_NAME)
-
-_ = gettext.gettext
-
-
-from utilities import format_size_for_user
-from utilities import register_iconsets
-
-
-from config import STATUS_CANNOT_DOWNLOAD, STATUS_DOWNLOADED, \
- STATUS_DOWNLOADED_WITH_WARNING, \
- STATUS_DOWNLOAD_FAILED, \
- STATUS_DOWNLOAD_PENDING, \
- STATUS_BACKUP_PROBLEM, \
- STATUS_NOT_DOWNLOADED, \
- STATUS_DOWNLOAD_AND_BACKUP_FAILED, \
- STATUS_WARNING
-
-DOWNLOADED = [STATUS_DOWNLOADED, STATUS_DOWNLOADED_WITH_WARNING, STATUS_BACKUP_PROBLEM]
-
-#Translators: if neccessary, for guidance in how to translate this program, you may see http://damonlynch.net/translate.html
-PROGRAM_NAME = _('Rapid Photo Downloader')
-__version__ = config.version
-
-def date_time_human_readable(date, with_line_break=True):
- if with_line_break:
- return _("%(date)s\n%(time)s") % {'date':date.strftime("%x"), 'time':date.strftime("%X")}
- else:
- return _("%(date)s %(time)s") % {'date':date.strftime("%x"), 'time':date.strftime("%X")}
-
-def date_time_subseconds_human_readable(date, subseconds):
- return _("%(date)s %(hour)s:%(minute)s:%(second)s:%(subsecond)s") % \
- {'date':date.strftime("%x"),
- 'hour':date.strftime("%H"),
- 'minute':date.strftime("%M"),
- 'second':date.strftime("%S"),
- 'subsecond': subseconds}
-
-
-class DeviceCollection(gtk.TreeView):
- """
- TreeView display of devices and how many files have been copied, shown
- immediately under the menu in the main application window.
- """
- def __init__(self, parent_app):
-
- self.parent_app = parent_app
- # device icon & name, size of images on the device (human readable),
- # copy progress (%), copy text, eject button (None if irrelevant),
- # process id, pulse
- self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, str, float, str,
- gtk.gdk.Pixbuf, int, int)
- self.map_process_to_row = {}
- self.devices_by_scan_pid = {}
-
- gtk.TreeView.__init__(self, self.liststore)
-
- self.props.enable_search = False
- # make it impossible to select a row
- selection = self.get_selection()
- selection.set_mode(gtk.SELECTION_NONE)
- self.set_headers_visible(False)
-
-
- # Device refers to a thing like a camera, memory card in its reader,
- # external hard drive, Portable Storage Device, etc.
- column0 = gtk.TreeViewColumn(_("Device"))
- pixbuf_renderer = gtk.CellRendererPixbuf()
- pixbuf_renderer.set_padding(2, 0)
- text_renderer = gtk.CellRendererText()
- text_renderer.props.ellipsize = pango.ELLIPSIZE_MIDDLE
- text_renderer.set_fixed_size(160, -1)
- eject_renderer = gtk.CellRendererPixbuf()
- column0.pack_start(pixbuf_renderer, expand=False)
- column0.pack_start(text_renderer, expand=True)
- column0.pack_end(eject_renderer, expand=False)
- column0.add_attribute(pixbuf_renderer, 'pixbuf', 0)
- column0.add_attribute(text_renderer, 'text', 1)
- column0.add_attribute(eject_renderer, 'pixbuf', 5)
- self.append_column(column0)
-
-
- # Size refers to the total size of images on the device, typically in
- # MB or GB
- column1 = gtk.TreeViewColumn(_("Size"), gtk.CellRendererText(), text=2)
- self.append_column(column1)
-
- column2 = gtk.TreeViewColumn(_("Download Progress"),
- gtk.CellRendererProgress(),
- value=3,
- text=4,
- pulse=7)
- self.append_column(column2)
- self.show_all()
-
- icontheme = gtk.icon_theme_get_default()
- try:
- self.eject_pixbuf = icontheme.load_icon('media-eject', 16,
- gtk.ICON_LOOKUP_USE_BUILTIN)
- except:
- self.eject_pixbuf = gtk.gdk.pixbuf_new_from_file(
- paths.share_dir('glade3/media-eject.png'))
-
- self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
- self.connect('button-press-event', self.button_clicked)
-
-
- def add_device(self, process_id, device, progress_bar_text = ''):
-
- # add the row, and get a temporary pointer to the row
- size_files = ''
- progress = 0.0
-
- if device.mount is None:
- eject = None
- else:
- eject = self.eject_pixbuf
-
- self.devices_by_scan_pid[process_id] = device
-
- iter = self.liststore.append((device.get_icon(),
- device.get_name(),
- size_files,
- progress,
- progress_bar_text,
- eject,
- process_id,
- -1))
-
- self._set_process_map(process_id, iter)
-
- # adjust scrolled window height, based on row height and number of ready to start downloads
-
- # please note, at program startup, self.row_height() will be less than it will be when already running
- # e.g. when starting with 3 cards, it could be 18, but when adding 2 cards to the already running program
- # (with one card at startup), it could be 21
- # must account for header row at the top
- row_height = self.get_background_area(0, self.get_column(0))[3] + 1
- height = max(((len(self.map_process_to_row) + 1) * row_height), 24)
- self.parent_app.device_collection_scrolledwindow.set_size_request(-1, height)
-
-
- def update_device(self, process_id, total_size_files):
- """
- Updates the size of the photos and videos on the device, displayed to the user
- """
- if process_id in self.map_process_to_row:
- iter = self._get_process_map(process_id)
- self.liststore.set_value(iter, 2, total_size_files)
- else:
- logger.critical("This device is unknown")
-
- def get_device(self, process_id):
- return self.devices_by_scan_pid.get(process_id)
-
- def remove_device(self, process_id):
- if process_id in self.map_process_to_row:
- iter = self._get_process_map(process_id)
- self.liststore.remove(iter)
- del self.map_process_to_row[process_id]
- del self.devices_by_scan_pid[process_id]
-
- def get_all_displayed_processes(self):
- """
- returns a list of the processes currently being displayed to the user
- """
- return self.map_process_to_row.keys()
-
-
- def _set_process_map(self, process_id, iter):
- """
- convert the temporary iter into a tree reference, which is
- permanent
- """
-
- path = self.liststore.get_path(iter)
- treerowref = gtk.TreeRowReference(self.liststore, path)
- self.map_process_to_row[process_id] = treerowref
-
- def _get_process_map(self, process_id):
- """
- return the tree iter for this process
- """
-
- if process_id in self.map_process_to_row:
- treerowref = self.map_process_to_row[process_id]
- path = treerowref.get_path()
- iter = self.liststore.get_iter(path)
- return iter
- else:
- return None
-
- def update_progress(self, scan_pid, percent_complete, progress_bar_text, bytes_downloaded, pulse=None):
-
- iter = self._get_process_map(scan_pid)
- if iter:
- if percent_complete:
- self.liststore.set_value(iter, 3, percent_complete)
- if progress_bar_text:
- self.liststore.set_value(iter, 4, progress_bar_text)
-
- if pulse is not None:
- if pulse:
- # Make the bar pulse
- self.liststore.set_value(iter, 7, self.liststore.get_value(iter, 7) + 1)
- else:
- # Set to finished state
- self.liststore.set_value(iter, 7, G_MAXINT)
- else:
- # Reset to allow fraction to be set
- self.liststore.set_value(iter, 7, -1)
-
-
-
- def button_clicked(self, widget, event):
- """
- Look for left single click on eject button
- """
- if event.button == 1:
- if len (self.liststore):
- x = int(event.x)
- y = int(event.y)
- path, column, cell_x, cell_y = self.get_path_at_pos(x, y)
- if path is not None:
- if column == self.get_column(0):
- if cell_x >= column.get_width() - self.eject_pixbuf.get_width():
- iter = self.liststore.get_iter(path)
- if self.liststore.get_value(iter, 5) is not None:
- self.unmount(process_id = self.liststore.get_value(iter, 6))
-
- def unmount(self, process_id):
- device = self.devices_by_scan_pid[process_id]
- if device.mount is not None:
- logger.debug("Unmounting device with scan pid %s", process_id)
- device.mount.unmount(self.unmount_callback)
-
-
- def unmount_callback(self, mount, result):
- name = mount.get_name()
-
- try:
- mount.unmount_finish(result)
- logger.debug("%s successfully unmounted" % name)
- except gio.Error, inst:
- logger.error("%s did not unmount: %s", name, inst)
-
- if use_pynotify:
- title = _("%(device)s did not unmount") % {'device': name}
- message = '%s' % inst
-
- n = pynotify.Notification(title, message)
- n.set_icon_from_pixbuf(self.parent_app.application_icon)
- try:
- n.show()
- except:
- logger.error("Unable to display message using notification system")
-
-
-def create_cairo_image_surface(pil_image, image_width, image_height):
- imgd = pil_image.tobytes("raw","BGRA", 0, 1)
- data = array.array('B',imgd)
- stride = image_width * 4
- image = cairo.ImageSurface.create_for_data(data, cairo.FORMAT_ARGB32,
- image_width, image_height, stride)
- return image
-
-class ThumbnailCellRenderer(gtk.CellRenderer):
- __gproperties__ = {
- "image": (gobject.TYPE_PYOBJECT, "Image",
- "Image", gobject.PARAM_READWRITE),
-
- "filename": (gobject.TYPE_STRING, "Filename",
- "Filename", '', gobject.PARAM_READWRITE),
-
- "status": (gtk.gdk.Pixbuf, "Status",
- "Status", gobject.PARAM_READWRITE),
- }
-
- def __init__(self, checkbutton_height):
- gtk.CellRenderer.__init__(self)
- self.image = None
-
- self.image_area_size = 100
- self.text_area_size = 30
- self.padding = 6
- self.checkbutton_height = checkbutton_height
- self.icon_width = 20
-
- def do_set_property(self, pspec, value):
- setattr(self, pspec.name, value)
-
- def do_get_property(self, pspec):
- return getattr(self, pspec.name)
-
- def do_render(self, window, widget, background_area, cell_area, expose_area, flags):
-
- cairo_context = window.cairo_create()
-
- x = cell_area.x
- y = cell_area.y + self.checkbutton_height - 8
- w = cell_area.width
- h = cell_area.height
-
- #constrain operations to cell area, allowing for a 1 pixel border
- #either side
- #~ cairo_context.rectangle(x-1, y-1, w+2, h+2)
- #~ cairo_context.clip()
-
- #fill in the background with dark grey
- #this ensures that a selected cell's fill does not make
- #the text impossible to read
- #~ cairo_context.rectangle(x, y, w, h)
- #~ cairo_context.set_source_rgb(0.267, 0.267, 0.267)
- #~ cairo_context.fill()
-
- #image width and height
- image_w = self.image.size[0]
- image_h = self.image.size[1]
-
- #center the image horizontally
- #bottom align vertically
- #top left and right corners for the image:
- image_x = x + ((w - image_w) / 2)
- image_y = y + self.image_area_size - image_h
-
- #convert PIL image to format suitable for cairo
- image = create_cairo_image_surface(self.image, image_w, image_h)
-
- # draw a light grey border of 1px around the image
- cairo_context.set_source_rgb(0.66, 0.66, 0.66) #light grey, #a9a9a9
- cairo_context.set_line_width(1)
- cairo_context.rectangle(image_x-.5, image_y-.5, image_w+1, image_h+1)
- cairo_context.stroke()
-
- # draw a thin border around each cell
- #~ cairo_context.set_source_rgb(0.33,0.33,0.33)
- #~ cairo_context.rectangle(x, y, w, h)
- #~ cairo_context.stroke()
-
- #place the image
- cairo_context.set_source_surface(image, image_x, image_y)
- cairo_context.paint()
-
- #text
- context = pangocairo.CairoContext(cairo_context)
-
- text_y = y + self.image_area_size + 10
- text_w = w - self.icon_width
- text_x = x + self.icon_width
- #~ context.rectangle(text_x, text_y, text_w, 15)
- #~ context.clip()
-
- layout = context.create_layout()
-
- width = text_w * pango.SCALE
- layout.set_width(width)
-
- layout.set_alignment(pango.ALIGN_CENTER)
- layout.set_ellipsize(pango.ELLIPSIZE_END)
-
- #font color and size
- fg_color = pango.AttrForeground(65535, 65535, 65535, 0, -1)
- font_size = pango.AttrSize(8192, 0, -1) # 8 * 1024 = 8192
- font_family = pango.AttrFamily('sans', 0, -1)
- attr = pango.AttrList()
- attr.insert(fg_color)
- attr.insert(font_size)
- attr.insert(font_family)
- layout.set_attributes(attr)
-
- layout.set_text(self.filename)
-
- context.move_to(text_x, text_y)
- context.show_layout(layout)
-
- #status
- cairo_context.set_source_pixbuf(self.status, x, y + self.image_area_size + 10)
- cairo_context.paint()
-
- def do_get_size(self, widget, cell_area):
- return (0, 0, self.image_area_size, self.image_area_size + self.text_area_size - self.checkbutton_height + 4)
-
-
-gobject.type_register(ThumbnailCellRenderer)
-
-
-class ThumbnailDisplay(gtk.IconView):
- def __init__(self, parent_app):
- gtk.IconView.__init__(self)
- self.set_spacing(0)
- self.set_row_spacing(5)
- self.set_margin(25)
-
- self.set_selection_mode(gtk.SELECTION_MULTIPLE)
- self.connect('selection-changed', self.on_selection_changed)
- self._selected_items = []
-
- self.rapid_app = parent_app
-
- self.batch_size = 10
-
- self.thumbnail_manager = ThumbnailManager(self.thumbnail_results, self.batch_size)
- self.preview_manager = PreviewManager(self.preview_results)
-
- self.treerow_index = {}
- self.process_index = {}
-
- self.rpd_files = {}
-
- self.total_thumbs_to_generate = 0
- self.thumbnails_generated = 0
-
- # dict of scan_pids that are having thumbnails generated
- # value is the thumbnail process id
- # this is needed when terminating thumbnailing early such as when
- # user clicks download before the thumbnailing is finished
- self.generating_thumbnails = {}
-
- self.thumbnails = {}
- self.previews = {}
- self.previews_being_fetched = set()
-
- self.stock_photo_thumbnails = tn.PhotoIcons()
- self.stock_video_thumbnails = tn.VideoIcons()
-
- self.SELECTED_COL = 1
- self.UNIQUE_ID_COL = 2
- self.TIMESTAMP_COL = 4
- self.FILETYPE_COL = 5
- self.CHECKBUTTON_VISIBLE_COL = 6
- self.DOWNLOAD_STATUS_COL = 7
- self.STATUS_ICON_COL = 8
-
- self._create_liststore()
-
- self.clear()
-
- checkbutton = gtk.CellRendererToggle()
- checkbutton.set_radio(False)
- checkbutton.props.activatable = True
- checkbutton.props.xalign = 0.0
- checkbutton.connect('toggled', self.on_checkbutton_toggled)
- self.pack_end(checkbutton, expand=False)
-
- self.add_attribute(checkbutton, "active", 1)
- self.add_attribute(checkbutton, "visible", 6)
-
- checkbutton_size = checkbutton.get_size(self, None)
- checkbutton_height = checkbutton_size[3]
- checkbutton_width = checkbutton_size[2]
-
- image = ThumbnailCellRenderer(checkbutton_height)
- self.pack_start(image, expand=True)
- self.add_attribute(image, "image", 0)
- self.add_attribute(image, "filename", 3)
- self.add_attribute(image, "status", 8)
-
- #set the background color to a darkish grey
- self.modify_base(gtk.STATE_NORMAL, gtk.gdk.Color('#444444'))
-
- self.show_all()
- self._setup_icons()
-
- self.connect('item-activated', self.on_item_activated)
-
- def _create_liststore(self):
- """
- Creates the default list store to hold the icons
- """
- self.liststore = gtk.ListStore(
- gobject.TYPE_PYOBJECT, # 0 PIL thumbnail
- gobject.TYPE_BOOLEAN, # 1 selected or not
- str, # 2 unique id
- str, # 3 file name
- int, # 4 timestamp for sorting, converted float
- int, # 5 file type i.e. photo or video
- gobject.TYPE_BOOLEAN, # 6 visibility of checkbutton
- int, # 7 status of download
- gtk.gdk.Pixbuf, # 8 status icon
- )
-
- def _setup_icons(self):
- # icons to be displayed in status column
-
- size = 16
- # standard icons
- failed = self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU)
- self.download_failed_icon = failed.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
- error = self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_MENU)
- self.error_icon = error.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
- warning = self.render_icon(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_MENU)
- self.warning_icon = warning.scale_simple(size, size, gtk.gdk.INTERP_HYPER)
-
- # Rapid Photo Downloader specific icons
- self.downloaded_icon = gtk.gdk.pixbuf_new_from_file_at_size(
- paths.share_dir('glade3/rapid-photo-downloader-downloaded.svg'),
- size, size)
- self.download_pending_icon = gtk.gdk.pixbuf_new_from_file_at_size(
- paths.share_dir('glade3/rapid-photo-downloader-download-pending.png'),
- size, size)
- self.downloaded_with_warning_icon = gtk.gdk.pixbuf_new_from_file_at_size(
- paths.share_dir('glade3/rapid-photo-downloader-downloaded-with-warning.svg'),
- size, size)
- self.downloaded_with_error_icon = gtk.gdk.pixbuf_new_from_file_at_size(
- paths.share_dir('glade3/rapid-photo-downloader-downloaded-with-error.svg'),
- size, size)
-
- # make the not yet downloaded icon a transparent square
- self.not_downloaded_icon = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 16, 16)
- self.not_downloaded_icon.fill(0xffffffff)
- self.not_downloaded_icon = self.not_downloaded_icon.add_alpha(True, chr(255), chr(255), chr(255))
-
- def get_status_icon(self, status):
- """
- Returns the correct icon, based on the status
- """
- if status == STATUS_WARNING:
- status_icon = self.warning_icon
- elif status == STATUS_CANNOT_DOWNLOAD:
- status_icon = self.error_icon
- elif status == STATUS_DOWNLOADED:
- status_icon = self.downloaded_icon
- elif status == STATUS_NOT_DOWNLOADED:
- status_icon = self.not_downloaded_icon
- elif status in [STATUS_DOWNLOADED_WITH_WARNING, STATUS_BACKUP_PROBLEM]:
- status_icon = self.downloaded_with_warning_icon
- elif status in [STATUS_DOWNLOAD_FAILED, STATUS_DOWNLOAD_AND_BACKUP_FAILED]:
- status_icon = self.downloaded_with_error_icon
- elif status == STATUS_DOWNLOAD_PENDING:
- status_icon = self.download_pending_icon
- else:
- logger.critical("FIXME: unknown status: %s", status)
- status_icon = self.not_downloaded_icon
- return status_icon
-
- def sort_by_timestamp(self):
- self.liststore.set_sort_column_id(self.TIMESTAMP_COL, gtk.SORT_ASCENDING)
-
- def on_selection_changed(self, iconview):
- """
- Allow selections by row (and not GTK default by square) when user is
- dragging the mouse or using the keyboard to select
- """
- selections = self.get_selected_items()
- if len(selections) > 1:
- previous_sel = selections[0][0] + 1
- # seleted items list always starts with the highest selected item
- for selection in selections:
- current_sel = selection[0]
- if current_sel <> (previous_sel-1):
- for i in range(previous_sel-1, current_sel, -1):
- self.select_path(i)
- previous_sel = current_sel
- self._selected_items = self.get_selected_items()
-
- def on_checkbutton_toggled(self, cellrenderertoggle, path):
- paths = [p[0] for p in self._selected_items]
- if int(path) not in paths:
- self._selected_items = [path,]
-
- for path in self._selected_items:
- iter = self.liststore.get_iter(path)
- status = self.liststore.get_value(iter, self.DOWNLOAD_STATUS_COL)
- if status == STATUS_NOT_DOWNLOADED:
- self.liststore.set_value(iter, self.SELECTED_COL, not cellrenderertoggle.get_active())
- self.select_path(path)
-
- self.rapid_app.set_download_action_sensitivity()
-
-
- def set_selected(self, unique_id, value):
- iter = self.get_iter_from_unique_id(unique_id)
- self.liststore.set_value(iter, self.SELECTED_COL, value)
-
- def add_file(self, rpd_file, generate_thumbnail):
-
- thumbnail_icon = self.get_stock_icon(rpd_file.file_type)
- unique_id = rpd_file.unique_id
- scan_pid = rpd_file.scan_pid
-
- timestamp = int(rpd_file.modification_time)
-
- iter = self.liststore.append((thumbnail_icon,
- True,
- unique_id,
- rpd_file.display_name,
- timestamp,
- rpd_file.file_type,
- True,
- STATUS_NOT_DOWNLOADED,
- self.not_downloaded_icon
- ))
-
- path = self.liststore.get_path(iter)
- treerowref = gtk.TreeRowReference(self.liststore, path)
-
- if scan_pid in self.process_index:
- self.process_index[scan_pid].append(unique_id)
- else:
- self.process_index[scan_pid] = [unique_id,]
-
- self.treerow_index[unique_id] = treerowref
- self.rpd_files[unique_id] = rpd_file
-
- if generate_thumbnail:
- self.total_thumbs_to_generate += 1
-
- def get_sample_file(self, file_type):
- """Returns an rpd_file for of a given file type, or None if it does
- not exist"""
- for unique_id, rpd_file in self.rpd_files.iteritems():
- if rpd_file.file_type == file_type:
- if rpd_file.status <> STATUS_CANNOT_DOWNLOAD:
- return rpd_file
-
- return None
-
- def get_unique_id_from_iter(self, iter):
- return self.liststore.get_value(iter, 2)
-
- def get_iter_from_unique_id(self, unique_id):
- treerowref = self.treerow_index[unique_id]
- path = treerowref.get_path()
- return self.liststore.get_iter(path)
-
- def on_item_activated(self, iconview, path):
- """
- """
- iter = self.liststore.get_iter(path)
- self.show_preview(iter=iter)
- self.advance_get_preview_image(iter)
-
-
- def _get_preview(self, unique_id, rpd_file):
- if unique_id not in self.previews_being_fetched:
- #check if preview should be from a downloaded file, or the source
- if rpd_file.status in DOWNLOADED:
- file_location = rpd_file.download_full_file_name
- thm_file_name = rpd_file.download_thm_full_name
- else:
- file_location = rpd_file.full_file_name
- thm_file_name = rpd_file.thm_full_name
-
- self.preview_manager.get_preview(unique_id, file_location,
- thm_file_name,
- rpd_file.file_type, size_max=None,)
-
- self.previews_being_fetched.add(unique_id)
-
- def show_preview(self, unique_id=None, iter=None):
- if len(self.liststore):
- if unique_id is not None:
- iter = self.get_iter_from_unique_id(unique_id)
- elif iter is not None:
- unique_id = self.get_unique_id_from_iter(iter)
- else:
- # neither an iter or a unique_id were passed
- # use iter from first selected file
- # if none is selected, choose the first file
- selected = self.get_selected_items()
- if selected:
- path = selected[0]
- else:
- path = 0
- iter = self.liststore.get_iter(path)
- unique_id = self.get_unique_id_from_iter(iter)
-
-
- rpd_file = self.rpd_files[unique_id]
-
- if unique_id in self.previews:
- preview_image = self.previews[unique_id]
- else:
- # request daemon process to get a full size thumbnail
- self._get_preview(unique_id, rpd_file)
- if unique_id in self.thumbnails:
- preview_image = self.thumbnails[unique_id]
- else:
- preview_image = self.get_stock_icon(rpd_file.file_type)
-
- checked = self.liststore.get_value(iter, self.SELECTED_COL)
- include_checkbutton_visible = rpd_file.status == STATUS_NOT_DOWNLOADED
- self.rapid_app.show_preview_image(unique_id, preview_image,
- include_checkbutton_visible, checked)
-
- def _get_next_iter(self, iter):
- iter = self.liststore.iter_next(iter)
- if iter is None:
- iter = self.liststore.get_iter_first()
- return iter
-
- def _get_prev_iter(self, iter):
- row = self.liststore.get_path(iter)[0]
- if row == 0:
- row = len(self.liststore)-1
- else:
- row -= 1
- iter = self.liststore.get_iter(row)
- return iter
-
- def show_next_image(self, unique_id):
- iter = self.get_iter_from_unique_id(unique_id)
- iter = self._get_next_iter(iter)
-
- if iter is not None:
- self.show_preview(iter=iter)
-
- # cache next image
- self.advance_get_preview_image(iter, prev=False, next=True)
-
- def show_prev_image(self, unique_id):
- iter = self.get_iter_from_unique_id(unique_id)
- iter = self._get_prev_iter(iter)
-
- if iter is not None:
- self.show_preview(iter=iter)
-
- # cache next image
- self.advance_get_preview_image(iter, prev=True, next=False)
-
-
- def advance_get_preview_image(self, iter, prev=True, next=True):
- unique_ids = []
- if next:
- next_iter = self._get_next_iter(iter)
- unique_ids.append(self.get_unique_id_from_iter(next_iter))
-
- if prev:
- prev_iter = self._get_prev_iter(iter)
- unique_ids.append(self.get_unique_id_from_iter(prev_iter))
-
- for unique_id in unique_ids:
- if not unique_id in self.previews:
- rpd_file = self.rpd_files[unique_id]
- self._get_preview(unique_id, rpd_file)
-
- def check_all(self, check_all, file_type=None):
- for row in self.liststore:
- if row[self.CHECKBUTTON_VISIBLE_COL]:
- if file_type is not None:
- if row[self.FILETYPE_COL] == file_type:
- row[self.SELECTED_COL] = check_all
- else:
- row[self.SELECTED_COL] = check_all
- self.rapid_app.set_download_action_sensitivity()
-
- def files_are_checked_to_download(self):
- """
- Returns True if there is any file that the user has indicated they
- intend to download, else returns False.
- """
- for row in self.liststore:
- if row[self.SELECTED_COL]:
- rpd_file = self.rpd_files[row[self.UNIQUE_ID_COL]]
- if rpd_file.status not in DOWNLOADED:
- return True
- return False
-
- def get_files_checked_for_download(self, scan_pid):
- """
- Returns a dict of scan ids and associated files the user has indicated
- they want to download
-
- If scan_pid is not None, then returns only those files from that scan_pid
- """
- files = dict()
- if scan_pid is None:
- for row in self.liststore:
- if row[self.SELECTED_COL]:
- rpd_file = self.rpd_files[row[self.UNIQUE_ID_COL]]
- if rpd_file.status not in DOWNLOADED:
- scan_pid = rpd_file.scan_pid
- if scan_pid in files:
- files[scan_pid].append(rpd_file)
- else:
- files[scan_pid] = [rpd_file,]
- else:
- files[scan_pid] = []
- for unique_id in self.process_index[scan_pid]:
- rpd_file = self.rpd_files[unique_id]
- if rpd_file.status not in DOWNLOADED:
- iter = self.get_iter_from_unique_id(unique_id)
- if self.liststore.get_value(iter, self.SELECTED_COL):
- files[scan_pid].append(rpd_file)
- return files
-
- def get_no_files_remaining(self, scan_pid):
- """
- Returns the number of files that have not yet been downloaded for the
- scan_pid
- """
- i = 0
- for unique_id in self.process_index[scan_pid]:
- rpd_file = self.rpd_files[unique_id]
- if rpd_file.status == STATUS_NOT_DOWNLOADED:
- i += 1
- return i
-
- def files_remain_to_download(self):
- """
- Returns True if any files remain that are not downloaded, else returns
- False
- """
- for row in self.liststore:
- if row[self.DOWNLOAD_STATUS_COL] == STATUS_NOT_DOWNLOADED:
- return True
- return False
-
-
- def mark_download_pending(self, files_by_scan_pid):
- """
- Sets status to download pending and updates thumbnails display
- """
- for scan_pid in files_by_scan_pid:
- for rpd_file in files_by_scan_pid[scan_pid]:
- unique_id = rpd_file.unique_id
- self.rpd_files[unique_id].status = STATUS_DOWNLOAD_PENDING
- iter = self.get_iter_from_unique_id(unique_id)
- if not self.rapid_app.auto_start_is_on:
- # don't make the checkbox invisible immediately when on auto start
- # otherwise the box can be rendred at the wrong size, as it is
- # realized after the checkbox has already been made invisible
- self.liststore.set_value(iter, self.CHECKBUTTON_VISIBLE_COL, False)
- self.liststore.set_value(iter, self.SELECTED_COL, False)
- self.liststore.set_value(iter, self.DOWNLOAD_STATUS_COL, STATUS_DOWNLOAD_PENDING)
- icon = self.get_status_icon(STATUS_DOWNLOAD_PENDING)
- self.liststore.set_value(iter, self.STATUS_ICON_COL, icon)
-
- def select_image(self, unique_id):
- iter = self.get_iter_from_unique_id(unique_id)
- path = self.liststore.get_path(iter)
- self.select_path(path)
- self.scroll_to_path(path, use_align=False, row_align=0.5, col_align=0.5)
-
- def get_stock_icon(self, file_type):
- if file_type == rpdfile.FILE_TYPE_PHOTO:
- return self.stock_photo_thumbnails.stock_thumbnail_image_icon
- else:
- return self.stock_video_thumbnails.stock_thumbnail_image_icon
-
- def update_status_post_download(self, rpd_file):
- iter = self.get_iter_from_unique_id(rpd_file.unique_id)
- self.liststore.set_value(iter, self.DOWNLOAD_STATUS_COL, rpd_file.status)
- icon = self.get_status_icon(rpd_file.status)
- self.liststore.set_value(iter, self.STATUS_ICON_COL, icon)
- self.liststore.set_value(iter, self.CHECKBUTTON_VISIBLE_COL, False)
- self.rpd_files[rpd_file.unique_id] = rpd_file
-
- def generate_thumbnails(self, scan_pid):
- """Initiate thumbnail generation for files scanned in one process
- """
- if scan_pid in self.process_index:
- rpd_files = [self.rpd_files[unique_id] for unique_id in self.process_index[scan_pid]]
- thumbnail_pid = self.thumbnail_manager.add_task((scan_pid, rpd_files))
- self.generating_thumbnails[scan_pid] = thumbnail_pid
-
- def _set_thumbnail(self, unique_id, icon):
- treerowref = self.treerow_index[unique_id]
- path = treerowref.get_path()
- iter = self.liststore.get_iter(path)
- self.liststore.set(iter, 0, icon)
-
- def update_thumbnail(self, thumbnail_data):
- """
- Takes the generated thumbnail and updates the display
-
- If the thumbnail_data includes a second image, that is used to
- update the thumbnail list using the unique_id
- """
- unique_id = thumbnail_data[0]
- thumbnail_icon = thumbnail_data[1]
-
- if thumbnail_icon is not None:
- # get the thumbnail icon in PIL format
- thumbnail_icon = thumbnail_icon.get_image()
-
- if thumbnail_icon:
- self._set_thumbnail(unique_id, thumbnail_icon)
-
- if len(thumbnail_data) > 2:
- # get the 2nd image in PIL format
- self.thumbnails[unique_id] = thumbnail_data[2].get_image()
-
- def terminate_thumbnail_generation(self, scan_pid):
- """
- Terminates thumbnail generation if thumbnails are currently
- being generated for this scan_pid
- """
-
- if scan_pid in self.generating_thumbnails:
- terminated = True
- self.thumbnail_manager.terminate_process(
- self.generating_thumbnails[scan_pid])
- del self.generating_thumbnails[scan_pid]
-
- if len(self.generating_thumbnails) == 0:
- self._reset_thumbnail_tracking_and_display()
- else:
- terminated = False
-
- return terminated
-
- def mark_thumbnails_needed(self, rpd_files):
- for rpd_file in rpd_files:
- if rpd_file.unique_id not in self.thumbnails:
- rpd_file.generate_thumbnail = True
-
- def _reset_thumbnail_tracking_and_display(self):
- self.rapid_app.download_progressbar.set_fraction(0.0)
- self.rapid_app.download_progressbar.set_text('')
- self.thumbnails_generated = 0
- self.total_thumbs_to_generate = 0
-
- def thumbnail_results(self, source, condition):
- connection = self.thumbnail_manager.get_pipe(source)
-
- conn_type, data = connection.recv()
-
- if conn_type == rpdmp.CONN_COMPLETE:
- scan_pid = data
- del self.generating_thumbnails[scan_pid]
- connection.close()
- return False
- else:
-
- for thumbnail_data in data:
- self.update_thumbnail(thumbnail_data)
-
- self.thumbnails_generated += len(data)
-
- # clear progress bar information if all thumbnails have been
- # extracted
- if self.thumbnails_generated == self.total_thumbs_to_generate:
- self._reset_thumbnail_tracking_and_display()
- else:
- if self.total_thumbs_to_generate:
- self.rapid_app.download_progressbar.set_fraction(
- float(self.thumbnails_generated) / self.total_thumbs_to_generate)
-
-
- return True
-
- def preview_results(self, unique_id, preview_full_size, preview_small):
- """
- Receive a full size preview image and update
- """
- self.previews_being_fetched.remove(unique_id)
- if preview_full_size:
- preview_image = preview_full_size.get_image()
- self.previews[unique_id] = preview_image
- self.rapid_app.update_preview_image(unique_id, preview_image)
-
- # user can turn off option for thumbnail generation after a scan
- if unique_id not in self.thumbnails and preview_small is not None:
- self._set_thumbnail(unique_id, preview_small.get_image())
-
-
- def clear_all(self, scan_pid=None, keep_downloaded_files=False):
- """
- Removes files from display and internal tracking.
-
- If scan_pid is not None, then only files matching that scan_pid will
- be removed. Otherwise, everything will be removed.
-
- If keep_downloaded_files is True, files will not be removed if they
- have been downloaded.
- """
- if scan_pid is None and not keep_downloaded_files:
-
- # Here it is critically important to create a brand new liststore,
- # because the old one is set to be sorted, which is extremely slow.
- logger.debug("Creating new thumbnails model")
- self.set_model(None)
- self._create_liststore()
-
- self.treerow_index = {}
- self.process_index = {}
-
- self.rpd_files = {}
- else:
- if scan_pid in self.process_index:
- for unique_id in self.process_index[scan_pid]:
- rpd_file = self.rpd_files[unique_id]
- if not keep_downloaded_files or not rpd_file.status in DOWNLOADED:
- treerowref = self.treerow_index[rpd_file.unique_id]
- path = treerowref.get_path()
- iter = self.liststore.get_iter(path)
- self.liststore.remove(iter)
- del self.treerow_index[rpd_file.unique_id]
- del self.rpd_files[rpd_file.unique_id]
- if not keep_downloaded_files or not len(self.process_index[scan_pid]):
- del self.process_index[scan_pid]
-
- def display_thumbnails(self):
- self.set_model(self.liststore)
-
-class TaskManager:
- def __init__(self, results_callback, batch_size):
- self.results_callback = results_callback
-
- # List of actual process, it's terminate_queue, and it's run_event
- self._processes = []
-
- self._pipes = {}
- self.batch_size = batch_size
-
- self.paused = False
- self.no_tasks = 0
-
-
- def add_task(self, task):
- pid = self._setup_task(task)
- logger.debug("TaskManager PID: %s", pid)
- self.no_tasks += 1
- return pid
-
-
- def _setup_task(self, task):
- task_results_conn, task_process_conn = self._setup_pipe()
-
- source = task_results_conn.fileno()
- self._pipes[source] = task_results_conn
- gobject.io_add_watch(source, gobject.IO_IN, self.results_callback)
-
- terminate_queue = Queue()
- run_event = Event()
- run_event.set()
-
- return self._initiate_task(task, task_results_conn, task_process_conn,
- terminate_queue, run_event)
-
- def _setup_pipe(self):
- return Pipe(duplex=False)
-
- def _initiate_task(self, task, task_process_conn, terminate_queue, run_event):
- logger.error("Implement child class method!")
-
-
- def processes(self):
- for i in range(len(self._processes)):
- yield self._processes[i]
-
- def start(self):
- self.paused = False
- for scan in self.processes():
- run_event = scan[2]
- if not run_event.is_set():
- run_event.set()
-
- def pause(self):
- self.paused = True
- for scan in self.processes():
- run_event = scan[2]
- if run_event.is_set():
- run_event.clear()
-
- def _terminate_process(self, p):
- self._send_termination_msg(p)
- # The process might be paused: let it run
- run_event = p[2]
- if not run_event.is_set():
- run_event.set()
-
- def _send_termination_msg(self, p):
- p[1].put(None)
-
- def terminate_process(self, process_id):
- """
- Send a signal to process with matching process_id that it should
- immediately terminate
- """
- for p in self.processes():
- if p[0].pid == process_id:
- if p[0].is_alive():
- self._terminate_process(p)
-
- def request_termination(self):
- """
- Send a signal to processes that they should immediately terminate
- """
- requested = False
- for p in self.processes():
- if p[0].is_alive():
- requested = True
- self._terminate_process(p)
-
- return requested
-
- def terminate_forcefully(self):
- """
- Forcefully terminates any running processes. Use with great caution.
- No cleanup action is performed.
-
- As python essential reference (4th edition) says, if the process
- 'holds a lock or is involved with interprocess communication,
- terminating it might cause a deadlock or corrupted I/O.'
- """
-
- for p in self.processes():
- if p[0].is_alive():
- logger.info("Forcefully terminating %s in %s" , p[0].name,
- self.__class__.__name__)
- p[0].terminate()
-
-
- def get_pipe(self, source):
- return self._pipes[source]
-
- def get_no_active_processes(self):
- """
- Returns how many processes are currently active, i.e. running
- """
- i = 0
- for p in self.processes():
- if p[0].is_alive():
- i += 1
- return i
-
-
-class ScanManager(TaskManager):
-
- def __init__(self, results_callback, batch_size,
- add_device_function):
- TaskManager.__init__(self, results_callback, batch_size)
- self.add_device_function = add_device_function
-
- def _initiate_task(self, task, task_results_conn, task_process_conn,
- terminate_queue, run_event):
-
- device = task[0]
- ignored_paths = task[1]
- use_re_ignored_paths = task[2]
-
- scan = scan_process.Scan(device.get_path(),
- ignored_paths,
- use_re_ignored_paths,
- self.batch_size,
- task_process_conn, terminate_queue, run_event)
- scan.start()
- self._processes.append((scan, terminate_queue, run_event))
- self.add_device_function(scan.pid, device,
- # This refers to when a device like a hard drive is having its contents scanned,
- # looking for photos or videos. It is visible initially in the progress bar for each device
- # (which normally holds "x photos and videos").
- # It maybe displayed only briefly if the contents of the device being scanned is small.
- progress_bar_text=_('scanning...'))
-
- return scan.pid
-
-class CopyFilesManager(TaskManager):
-
- def _initiate_task(self, task, task_results_conn,
- task_process_conn, terminate_queue, run_event):
- photo_download_folder = task[0]
- video_download_folder = task[1]
- scan_pid = task[2]
- files = task[3]
- verify_files = task[4]
- modify_files_during_download = task[5]
- modify_pipe = task[6]
-
- copy_files = copyfiles.CopyFiles(photo_download_folder,
- video_download_folder,
- files,
- verify_files,
- modify_files_during_download,
- modify_pipe,
- scan_pid, self.batch_size,
- task_process_conn, terminate_queue, run_event)
- copy_files.start()
- self._processes.append((copy_files, terminate_queue, run_event))
- return copy_files.pid
-
-class ThumbnailManager(TaskManager):
- def _initiate_task(self, task, task_results_conn,
- task_process_conn, terminate_queue, run_event):
- scan_pid = task[0]
- files = task[1]
- generator = tn.GenerateThumbnails(scan_pid, files, self.batch_size,
- task_process_conn, terminate_queue,
- run_event)
- generator.start()
- self._processes.append((generator, terminate_queue, run_event))
- return generator.pid
-
-class FileModifyManager(TaskManager):
- """Handles the modification or verification of of downloaded files before they are renamed
- Duplex, multiprocess, similar to BackupFilesManager
- """
- def __init__(self, results_callback):
- TaskManager.__init__(self, results_callback=results_callback,
- batch_size=0)
- self.file_modify_by_scan_pid = {}
-
- def _initiate_task(self, task, task_results_conn, task_process_conn,
- terminate_queue, run_event):
- scan_pid = task[0]
- auto_rotate_jpeg = task[1]
- focal_length = task[2]
- verify_file = task[3]
- refresh_md5_on_file_change = task[4]
-
- file_modify = filemodify.FileModify(auto_rotate_jpeg, focal_length,
- verify_file, refresh_md5_on_file_change,
- task_process_conn, terminate_queue,
- run_event)
- file_modify.start()
- self._processes.append((file_modify, terminate_queue, run_event,
- task_results_conn))
-
- self.file_modify_by_scan_pid[scan_pid] = (task_results_conn, file_modify.pid)
-
- return file_modify.pid
-
- def _setup_pipe(self):
- return Pipe(duplex=True)
-
- def _send_termination_msg(self, p):
- p[1].put(None)
- p[3].send((None, None))
-
- def get_modify_pipe(self, scan_pid):
- return self.file_modify_by_scan_pid[scan_pid][0]
-
-
-class BackupFilesManager(TaskManager):
- """
- Handles backup processes. This is a little different from some other Task
- Manager classes in that its pipe is Duplex, and the work done by it
- is not pre-assigned when the process is started.
-
- Duplex, multiprocess.
- """
- def __init__(self, results_callback, batch_size):
- TaskManager.__init__(self, results_callback, batch_size)
- self.backup_devices_by_path = {}
-
- def _setup_pipe(self):
- return Pipe(duplex=True)
-
- def _send_termination_msg(self, p):
- p[1].put(None)
- p[3].send((None, None, None, None, None, None, None))
-
- def _initiate_task(self, task, task_results_conn, task_process_conn,
- terminate_queue, run_event):
- path = task[0]
- name = task[1]
- backup_type = task[2]
- backup_files = backupfile.BackupFiles(path, name, self.batch_size,
- task_process_conn, terminate_queue,
- run_event)
- backup_files.start()
- self._processes.append((backup_files, terminate_queue, run_event,
- task_results_conn))
-
- self.backup_devices_by_path[path] = (task_results_conn, backup_files.pid,
- backup_type)
-
- return backup_files.pid
-
- def backup_file(self, move_succeeded, rpd_file, path_suffix,
- backup_duplicate_overwrite,
- verify_file,
- download_count):
-
- if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
- logger.debug("Backing up photo %s", rpd_file.download_name)
- else:
- logger.debug("Backing up video %s", rpd_file.download_name)
-
- for path in self.backup_devices_by_path:
- backup_type = self.backup_devices_by_path[path][2]
- do_backup = ((backup_type == PHOTO_VIDEO_BACKUP) or
- (rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO and backup_type == PHOTO_BACKUP) or
- (rpd_file.file_type == rpdfile.FILE_TYPE_VIDEO and backup_type == VIDEO_BACKUP))
- if do_backup:
- logger.debug("Backing up to %s", path)
- else:
- logger.debug("Not backing up to %s", path)
- # Even if not going to backup to this device, need to send it anyway so
- # progress bar can be updated. Not this most efficient but the
- # code is much more simple
- task_results_conn = self.backup_devices_by_path[path][0]
- task_results_conn.send((move_succeeded, do_backup, rpd_file,
- path_suffix,
- backup_duplicate_overwrite,
- verify_file, download_count))
-
- def add_device(self, path, name, backup_type):
- """
- Convenience function to setup adding a backup device
- """
- return self.add_task((path, name, backup_type))
-
- def remove_device(self, path):
- pid = self.backup_devices_by_path[path][1]
- self.terminate_process(pid)
- del self.backup_devices_by_path[path]
-
-
-class SingleInstanceTaskManager:
- """
- Base class to manage single instance processes. Examples are daemon
- processes, but also a non-daemon process that has one simple task.
-
- Core (infrastructure) functionality is implemented in this class.
- Derived classes should implemented functionality to actually implement
- specific tasks.
- """
- def __init__(self, results_callback):
- self.results_callback = results_callback
-
- self.task_results_conn, self.task_process_conn = Pipe(duplex=True)
-
- source = self.task_results_conn.fileno()
- gobject.io_add_watch(source, gobject.IO_IN, self.task_results)
-
-
-class PreviewManager(SingleInstanceTaskManager):
- def __init__(self, results_callback):
- SingleInstanceTaskManager.__init__(self, results_callback)
- self._get_preview = tn.GetPreviewImage(self.task_process_conn)
- self._get_preview.start()
-
- def get_preview(self, unique_id, full_file_name, thm_file_name, file_type, size_max):
- self.task_results_conn.send((unique_id, full_file_name, thm_file_name, file_type, size_max))
-
- def task_results(self, source, condition):
- unique_id, preview_full_size, preview_small = self.task_results_conn.recv()
- self.results_callback(unique_id, preview_full_size, preview_small)
- return True
-
-class SubfolderFileManager(SingleInstanceTaskManager):
- """
- Manages the daemon process that renames files and creates subfolders
- """
- def __init__(self, results_callback, sequence_values):
- SingleInstanceTaskManager.__init__(self, results_callback)
- self._subfolder_file = subfolderfile.SubfolderFile(self.task_process_conn,
- sequence_values)
- self._subfolder_file.start()
- logger.debug("SubfolderFile PID: %s", self._subfolder_file.pid)
-
- def rename_file_and_move_to_subfolder(self, download_succeeded,
- download_count, rpd_file):
-
- logger.debug("Sending file for rename: %s.", download_count)
- self.task_results_conn.send((download_succeeded, download_count,
- rpd_file))
-
-
- def task_results(self, source, condition):
- move_succeeded, rpd_file, download_count = self.task_results_conn.recv()
- self.results_callback(move_succeeded, rpd_file, download_count)
- return True
-
-class ResizblePilImage(gtk.DrawingArea):
- def __init__(self, bg_color=None):
- gtk.DrawingArea.__init__(self)
- self.base_image = None
- self.bg_color = bg_color
- self.connect('expose_event', self.expose)
-
- def set_image(self, image):
- self.base_image = image
-
- #set up sizes and ratio used for drawing the derived image
- self.base_image_w = self.base_image.size[0]
- self.base_image_h = self.base_image.size[1]
- self.base_image_aspect = float(self.base_image_w) / self.base_image_h
-
- self.queue_draw()
-
- def expose(self, widget, event):
-
- cairo_context = self.window.cairo_create()
-
- x = event.area.x
- y = event.area.y
- w = event.area.width
- h = event.area.height
-
- #constrain operations to event area
- cairo_context.rectangle(x, y, w, h)
- cairo_context.clip_preserve()
-
- #set background color, if needed
- if self.bg_color:
- cairo_context.set_source_rgb(*self.bg_color)
- cairo_context.fill_preserve()
-
- if not self.base_image:
- return False
-
- frame_aspect = float(w) / h
-
- if frame_aspect > self.base_image_aspect:
- # Frame is wider than image
- height = h
- width = int(height * self.base_image_aspect)
- else:
- # Frame is taller than image
- width = w
- height = int(width / self.base_image_aspect)
-
- #resize image
- pil_image = self.base_image.copy()
- if self.base_image_w < width or self.base_image_h < height:
- logger.debug("Upsizing image")
- pil_image = tn.upsize_pil(pil_image, (width, height))
- else:
- logger.debug("Downsizing image")
- tn.downsize_pil(pil_image, (width, height))
-
- #image width and height
- image_w = pil_image.size[0]
- image_h = pil_image.size[1]
-
- #center the image horizontally and vertically
- #top left and right corners for the image:
- image_x = x + ((w - image_w) / 2)
- image_y = y + ((h - image_h) / 2)
-
- image = create_cairo_image_surface(pil_image, image_w, image_h)
- cairo_context.set_source_surface(image, image_x, image_y)
- cairo_context.paint()
-
- return False
-
-
-
-class PreviewImage:
-
- def __init__(self, parent_app, builder):
- #set background color to equivalent of '#444444
- self.preview_image = ResizblePilImage(bg_color=(0.267, 0.267, 0.267))
- self.preview_image_eventbox = builder.get_object("preview_eventbox")
- self.preview_image_eventbox.add(self.preview_image)
- self.preview_image.show()
- self.download_this_checkbutton = builder.get_object("download_this_checkbutton")
- self.rapid_app = parent_app
-
- self.base_preview_image = None # large size image used to scale down from
- self.current_preview_size = (0,0)
- self.preview_image_size_limit = (0,0)
-
- self.unique_id = None
-
- def set_preview_image(self, unique_id, pil_image, include_checkbutton_visible=None,
- checked=None):
- """
- """
- self.preview_image.set_image(pil_image)
- self.unique_id = unique_id
- if checked is not None:
- self.download_this_checkbutton.set_active(checked)
- self.download_this_checkbutton.grab_focus()
-
- if include_checkbutton_visible is not None:
- self.download_this_checkbutton.props.visible = include_checkbutton_visible
-
- def update_preview_image(self, unique_id, pil_image):
- if unique_id == self.unique_id:
- self.set_preview_image(unique_id, pil_image)
-
-
-class RapidApp(dbus.service.Object):
- """
- The main Rapid Photo Downloader application class.
-
- Contains functionality for main program window, and directs all other
- processes.
- """
-
- def __init__(self, bus, path, name, taskserver=None, focal_length=None,
- auto_detect=None, device_location=None):
-
- dbus.service.Object.__init__ (self, bus, path, name)
- self.running = False
-
- self.taskserver = taskserver
-
- self.focal_length = focal_length
-
- # Setup program preferences, and set callback for when they change
- self._init_prefs(auto_detect, device_location)
-
- # Initialize widgets in the main window, and variables that point to them
- self._init_widgets()
-
- if use_pynotify:
- self._init_pynotify()
-
- # Initialize job code handling
- self._init_job_code()
-
- # Remember the window size from the last time the program was run, or
- # set a default size
- self._set_window_size()
-
- # Setup various widgets
- self._setup_buttons()
- self._setup_error_icons()
- self._setup_icons()
-
- # Show the main window
- self.rapidapp.show()
-
- # Check program preferences - don't allow auto start if there is a problem
- prefs_valid, msg = prefsrapid.check_prefs_for_validity(self.prefs)
- if not prefs_valid:
- self.notify_prefs_are_invalid(details=msg)
-
- # Initialize variables with which to track important downloads results
- self._init_download_tracking()
-
- # Set up process managers.
- # A task such as scanning a device or copying files is handled in its
- # own process.
- self._start_process_managers()
-
- # Setup devices from which to download from and backup to
- self.setup_devices(on_startup=True, on_preference_change=False,
- block_auto_start=not prefs_valid)
-
- # Ensure the device collection scrolled window is not too small
- self._set_device_collection_size()
-
- def on_rapidapp_destroy(self, widget, data=None):
-
- self._terminate_processes(terminate_file_copies = True)
-
- # save window and component sizes
- self.prefs.vpaned_pos = self.main_vpaned.get_position()
-
- x, y, width, height = self.rapidapp.get_allocation()
- self.prefs.main_window_size_x = width
- self.prefs.main_window_size_y = height
-
- self.prefs.set_downloads_today_from_tracker(self.downloads_today_tracker)
-
- gtk.main_quit()
-
- def _terminate_processes(self, terminate_file_copies=False):
-
- if terminate_file_copies:
- logger.info("Terminating all processes...")
-
- scan_termination_requested = self.scan_manager.request_termination()
- thumbnails_termination_requested = self.thumbnails.thumbnail_manager.request_termination()
- backup_termination_requested = self.backup_manager.request_termination()
- file_modify_termination_requested = self.file_modify_manager.request_termination()
-
- if terminate_file_copies:
- copy_files_termination_requested = self.copy_files_manager.request_termination()
- else:
- copy_files_termination_requested = False
-
- if (scan_termination_requested or thumbnails_termination_requested or
- backup_termination_requested or file_modify_termination_requested):
- time.sleep(1)
- if (self.scan_manager.get_no_active_processes() > 0 or
- self.thumbnails.thumbnail_manager.get_no_active_processes() > 0 or
- self.backup_manager.get_no_active_processes() > 0 or
- self.file_modify_manager.get_no_active_processes() > 0):
- time.sleep(1)
- # must try again, just in case a new scan has meanwhile started!
- self.scan_manager.request_termination()
- self.thumbnails.thumbnail_manager.terminate_forcefully()
- self.scan_manager.terminate_forcefully()
- self.backup_manager.terminate_forcefully()
- self.file_modify_manager.terminate_forcefully()
-
- if terminate_file_copies and copy_files_termination_requested:
- time.sleep(1)
- self.copy_files_manager.terminate_forcefully()
-
- if terminate_file_copies:
- self._clean_all_temp_dirs()
-
- # # #
- # Events and tasks related to displaying preview images and thumbnails
- # # #
-
- def on_download_this_checkbutton_toggled(self, checkbutton):
- value = checkbutton.get_active()
- self.thumbnails.set_selected(self.preview_image.unique_id, value)
- self.set_download_action_sensitivity()
-
- def on_preview_eventbox_button_press_event(self, widget, event):
-
- if event.type == gtk.gdk._2BUTTON_PRESS and event.button == 1:
- self.show_thumbnails()
-
- def on_show_thumbnails_action_activate(self, action):
- logger.debug("on_show_thumbnails_action_activate")
- self.show_thumbnails()
-
- def on_show_image_action_activate(self, action):
- logger.debug("on_show_image_action_activate")
- self.thumbnails.show_preview()
-
- def on_check_all_action_activate(self, action):
- self.thumbnails.check_all(check_all=True)
-
- def on_uncheck_all_action_activate(self, action):
- self.thumbnails.check_all(check_all=False)
-
- def on_check_all_photos_action_activate(self, action):
- self.thumbnails.check_all(check_all=True,
- file_type=rpdfile.FILE_TYPE_PHOTO)
-
- def on_check_all_videos_action_activate(self, action):
- self.thumbnails.check_all(check_all=True,
- file_type=rpdfile.FILE_TYPE_VIDEO)
-
- def on_quit_action_activate(self, action):
- self.on_rapidapp_destroy(widget=self.rapidapp, data=None)
-
- def on_refresh_action_activate(self, action):
- self.thumbnails.clear_all()
- self.setup_devices(on_startup=False, on_preference_change=False,
- block_auto_start=True)
-
- def on_get_help_action_activate(self, action):
- webbrowser.open("http://www.damonlynch.net/rapid/help.html")
-
- def on_about_action_activate(self, action):
- self.about.set_property("name", PROGRAM_NAME)
- self.about.set_property("version", utilities.human_readable_version(
- __version__))
- self.about.run()
- self.about.hide()
-
- def on_report_problem_action_activate(self, action):
- webbrowser.open("https://bugs.launchpad.net/rapid")
-
- def on_translate_action_activate(self, action):
- webbrowser.open("http://www.damonlynch.net/rapid/translate.html")
-
- def on_donate_action_activate(self, action):
- webbrowser.open("http://www.damonlynch.net/rapid/donate.html")
-
- def show_preview_image(self, unique_id, image, include_checkbutton_visible, checked):
- if self.main_notebook.get_current_page() == 0: # thumbnails
- logger.debug("Switching to preview image display")
- self.main_notebook.set_current_page(1)
- self.preview_image.set_preview_image(unique_id, image, include_checkbutton_visible, checked)
- self.next_image_action.set_sensitive(True)
- self.prev_image_action.set_sensitive(True)
-
- def update_preview_image(self, unique_id, image):
- self.preview_image.update_preview_image(unique_id, image)
-
- def show_thumbnails(self):
- logger.debug("Switching to thumbnails display")
- self.main_notebook.set_current_page(0)
- self.thumbnails.select_image(self.preview_image.unique_id)
- self.next_image_action.set_sensitive(False)
- self.prev_image_action.set_sensitive(False)
-
-
- def on_next_image_action_activate(self, action):
- if self.preview_image.unique_id is not None:
- self.thumbnails.show_next_image(self.preview_image.unique_id)
-
- def on_prev_image_action_activate(self, action):
- if self.preview_image.unique_id is not None:
- self.thumbnails.show_prev_image(self.preview_image.unique_id)
-
- def display_scan_thumbnails(self):
- """
- If all the scans are complete, sets the sort order and displays
- thumbnails in the icon view
- """
- if self.scan_manager.no_tasks == 0:
- self.thumbnails.sort_by_timestamp()
- self.thumbnails.display_thumbnails()
-
-
- # # #
- # Volume management
- # # #
-
- def start_volume_monitor(self):
- if not self.vmonitor:
- self.vmonitor = gio.volume_monitor_get()
- self.vmonitor.connect("mount-added", self.on_mount_added)
- self.vmonitor.connect("mount-removed", self.on_mount_removed)
-
-
- def _backup_device_name(self, path):
- if self.backup_devices[path][0] is None:
- name = path
- else:
- name = self.backup_devices[path][0].get_name()
- return name
-
- def start_device_scan(self, device):
- """
- Commences the scanning of a device using the preference values for
- any paths to ignore while scanning
- """
- logger.debug("Starting a device scan for device %s", device.get_name())
- return self.scan_manager.add_task([device,
- self.prefs.ignored_paths,
- self.prefs.use_re_ignored_paths])
-
- def confirm_manual_location(self):
- """
- Queries the user to ask if they really want to download from locations
- that could take a very long time to scan. They can choose yes or no.
-
- Returns True if yes or there was no need to ask the user, False if the
- user said no.
- """
- l = self.prefs.device_location
- if l in ['/media', '/run', os.path.expanduser('~'), '/']:
- logger.info("Prompting whether to download from %s", l)
- if l == '/':
- #this location is a human readable explanation for /, and is inserted into Downloading from %(location)s
- l = _('the root of the file system')
- c = preferencesdialog.QuestionDialog(parent_window=self.rapidapp,
- title=_('Rapid Photo Downloader'),
- #message in dialog box which asks the user if they really want to be downloading from this location
- question="<b>" + _("Downloading from %(location)s.") % {'location': l} + "</b>\n\n" +
- _("Do you really want to download from here? On some systems, scanning this location can take a very long time."),
- default_to_yes=False,
- use_markup=True)
- response = c.run()
- user_confirmed = response == gtk.RESPONSE_OK
- c.destroy()
- if not user_confirmed:
- return False
- return True
-
- def setup_devices(self, on_startup, on_preference_change, block_auto_start):
- """
-
- Setup devices from which to download from and backup to
-
- Sets up volumes for downloading from and backing up to
-
- on_startup should be True if the program is still starting,
- i.e. this is being called from the program's initialization.
-
- on_preference_change should be True if this is being called as the
- result of a preference being changed
-
- block_auto_start should be True if automation options to automatically
- start a download should be ignored
-
- Removes any image media that are currently not downloaded,
- or finished downloading
- """
-
- if self.using_volume_monitor():
- self.start_volume_monitor()
-
- self.clear_non_running_downloads()
- if not self.prefs.device_autodetection:
- if not self.confirm_manual_location():
- return
-
- mounts = []
- self.backup_devices = {}
-
- if self.using_volume_monitor():
- # either using automatically detected backup devices
- # or download devices
- for mount in self.vmonitor.get_mounts():
- if not mount.is_shadowed():
- path = mount.get_root().get_path()
- if path:
- if (path in self.prefs.device_blacklist and
- self.search_for_PSD()):
- logger.info("blacklisted device %s ignored", mount.get_name())
- else:
- logger.info("Detected %s", mount.get_name())
- is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
- if is_backup_mount:
- self.backup_devices[path] = (mount, backup_file_type)
- elif (self.prefs.device_autodetection and
- (dv.is_DCIM_device(path) or
- self.search_for_PSD())):
- logger.debug("Appending %s", mount.get_name())
- mounts.append((path, mount))
- else:
- logger.debug("Ignoring %s", mount.get_name())
-
-
- if not self.prefs.device_autodetection:
- # user manually specified the path from which to download
- path = self.prefs.device_location
- if path:
- logger.info("Using manually specified path %s", path)
- if utilities.is_directory(path):
- mounts.append((path, None))
- else:
- logger.error("Download path does not exist: %s", path)
-
- if self.prefs.backup_images:
- if not self.prefs.backup_device_autodetection:
- self._setup_manual_backup()
- self._add_backup_devices()
-
- self.update_no_backup_devices()
-
- # Display amount of free space in a status bar message
- self.display_free_space()
-
- if block_auto_start:
- self.auto_start_is_on = False
- else:
- self.auto_start_is_on = ((not on_preference_change) and
- ((self.prefs.auto_download_at_startup and
- on_startup) or
- (self.prefs.auto_download_upon_device_insertion and
- not on_startup)))
-
- logger.debug("Working with %s devices", len(mounts))
- for m in mounts:
- path, mount = m
- device = dv.Device(path=path, mount=mount)
-
-
- if not self._device_already_detected(device):
- if (self.search_for_PSD() and
- path not in self.prefs.device_whitelist):
- # prompt user to see if device should be used or not
- self.get_use_device(device)
- else:
- scan_pid = self.start_device_scan(device)
- if mount is not None:
- self.mounts_by_path[path] = scan_pid
- if not mounts:
- self.set_download_action_sensitivity()
-
- def _device_already_detected(self, device):
- path = device.get_path()
- if path in self.mounts_by_path:
- logger.debug("Ignoring device %s as already have path %s", device.get_name(), path)
- return True
- else:
- return False
-
- def _setup_manual_backup(self):
- """
- Setup backup devices that the user has manually specified.
- Depending on the folder the user has chosen, the paths for photo and
- video backup will either be the same or they will differ.
- """
- # user manually specified backup locations
- # will backup to these paths, but don't need any volume info
- # associated with them
- self.backup_devices[self.prefs.backup_location] = (None, PHOTO_BACKUP)
- if DOWNLOAD_VIDEO:
- if self.prefs.backup_location <> self.prefs.backup_video_location:
- self.backup_devices[self.prefs.backup_video_location] = (None, VIDEO_BACKUP)
- logger.info("Backing up photos to %s", self.prefs.backup_location)
- logger.info("Backing up videos to %s", self.prefs.backup_video_location)
- else:
- # videos and photos are being backed up to the same location
- self.backup_devices[self.prefs.backup_location] = (None, PHOTO_VIDEO_BACKUP)
- logger.info("Backing up photos and videos to %s", self.prefs.backup_location)
- else:
- logger.info("Backing up photos to %s", self.prefs.backup_location)
-
- def _add_backup_devices(self):
- """
- Add each backup devices / path to backup manager
- """
- for path in self.backup_devices:
- name = self._backup_device_name(path)
- backup_type = self.backup_devices[path][1]
- self.backup_manager.add_device(path, name, backup_type)
-
-
- def get_use_device(self, device):
- """ Prompt user whether or not to download from this device """
-
- logger.info("Prompting whether to use %s", device.get_name())
-
- # On some systems, e.g. Ubuntu 12.10, the GTK/Gnome environment
- # unexpectedly results in a device being added twice and not once.
- # The hack on the next line ensures the user is not prompted twice
- # for the same device.
-
- self.mounts_by_path[device.get_path()] = "PROMPTING"
-
- d = dv.UseDeviceDialog(self.rapidapp, device, self.got_use_device)
-
- def got_use_device(self, dialog, user_selected, permanent_choice, device):
- """ User has chosen whether or not to use a device to download from """
- dialog.destroy()
-
- path = device.get_path()
-
- if user_selected:
- if permanent_choice and path not in self.prefs.device_whitelist:
- # do NOT do a list append operation here without the assignment,
- # or the actual preferences will not be updated!!
- if len(self.prefs.device_whitelist):
- self.prefs.device_whitelist = self.prefs.device_whitelist + [path]
- else:
- self.prefs.device_whitelist = [path]
- scan_pid = self.start_device_scan(device)
- self.mounts_by_path[path] = scan_pid
-
- elif permanent_choice and path not in self.prefs.device_blacklist:
- # do not do a list append operation here without the assignment, or the preferences will not be updated!
- if len(self.prefs.device_blacklist):
- self.prefs.device_blacklist = self.prefs.device_blacklist + [path]
- else:
- self.prefs.device_blacklist = [path]
-
- def search_for_PSD(self):
- """
- Check to see if user preferences are to automatically search for
- Portable Storage Devices or not
- """
- return self.prefs.device_autodetection_psd and self.prefs.device_autodetection
-
- def check_if_backup_mount(self, path):
- """
- Checks to see if backups are enabled and path represents a valid backup
- location. It must be writeable.
-
- Checks against user preferences.
-
- Returns a tuple:
- (True, <backup-type> (one of PHOTO_VIDEO_BACKUP, PHOTO_BACKUP, or VIDEO_BACKUP)) or
- (False, None)
- """
- if self.prefs.backup_images:
- if self.prefs.backup_device_autodetection:
- # Determine if the auto-detected backup device is
- # to be used to backup only photos, or videos, or both.
- # Use the presence of a corresponding directory to
- # determine this.
- # The directory must be writable.
- photo_path = os.path.join(path, self.prefs.backup_identifier)
- p_backup = os.path.isdir(photo_path) and os.access(photo_path, os.W_OK)
- if DOWNLOAD_VIDEO:
- video_path = os.path.join(path, self.prefs.video_backup_identifier)
- v_backup = os.path.isdir(video_path) and os.access(video_path, os.W_OK)
- else:
- v_backup = False
- if p_backup and v_backup:
- logger.info("Photos and videos will be backed up to %s", path)
- return (True, PHOTO_VIDEO_BACKUP)
- elif p_backup:
- logger.info("Photos will be backed up to %s", path)
- return (True, PHOTO_BACKUP)
- elif v_backup:
- logger.info("Videos will be backed up to %s", path)
- return (True, VIDEO_BACKUP)
- elif path == self.prefs.backup_location:
- # user manually specified the path
- if os.access(self.prefs.backup_location, os.W_OK):
- return (True, PHOTO_BACKUP)
- elif path == self.prefs.backup_video_location:
- # user manually specified the path
- if os.access(self.prefs.backup_video_location, os.W_OK):
- return (True, VIDEO_BACKUP)
- return (False, None)
-
- def update_no_backup_devices(self):
- self.no_photo_backup_devices = 0
- self.no_video_backup_devices = 0
- for path, value in self.backup_devices.iteritems():
- backup_type = value[1]
- if backup_type == PHOTO_BACKUP:
- self.no_photo_backup_devices += 1
- elif backup_type == VIDEO_BACKUP:
- self.no_video_backup_devices += 1
- else:
- #both videos and photos are backed up to this device / path
- self.no_photo_backup_devices += 1
- self.no_video_backup_devices += 1
- logger.info("# photo backup devices: %s; # video backup devices: %s",
- self.no_photo_backup_devices, self.no_video_backup_devices)
- self.download_tracker.set_no_backup_devices(self.no_photo_backup_devices,
- self.no_video_backup_devices)
-
- def refresh_backup_media(self):
- """
- Setup the backup media
-
- Assumptions: this is being called after the user has changed their
- preferences AND download media has already been setup
- """
-
- # terminate any running backup processes
- self.backup_manager.request_termination()
-
- self.backup_devices = {}
- if self.prefs.backup_images:
- if not self.prefs.backup_device_autodetection:
- self._setup_manual_backup()
- else:
- for mount in self.vmonitor.get_mounts():
- if not mount.is_shadowed():
- path = mount.get_root().get_path()
- if path:
- is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
- if is_backup_mount:
- # is a backup volume
- if path not in self.backup_devices:
- self.backup_devices[path] = (mount, backup_file_type)
-
- self._add_backup_devices()
-
- self.update_no_backup_devices()
- self.display_free_space()
-
- def using_volume_monitor(self):
- """
- Returns True if programs needs to use gio volume monitor
- """
-
- return (self.prefs.device_autodetection or
- (self.prefs.backup_images and
- self.prefs.backup_device_autodetection
- ))
-
- def on_mount_added(self, vmonitor, mount):
- """
- callback run when gio indicates a new volume
- has been mounted
- """
-
-
- if mount.is_shadowed():
- # ignore this type of mount
- return
-
- path = mount.get_root().get_path()
- if path is not None:
-
- if path in self.prefs.device_blacklist and self.search_for_PSD():
- logger.info("Device %(device)s (%(path)s) ignored" % {
- 'device': mount.get_name(), 'path': path})
- else:
- is_backup_mount, backup_file_type = self.check_if_backup_mount(path)
-
- if is_backup_mount:
- if path not in self.backup_devices:
- self.backup_devices[path] = mount
- name = self._backup_device_name(path)
- self.backup_manager.add_device(path, name, backup_file_type)
- self.update_no_backup_devices()
- self.display_free_space()
-
- elif self.prefs.device_autodetection and (dv.is_DCIM_device(path) or
- self.search_for_PSD()):
-
- self.auto_start_is_on = self.prefs.auto_download_upon_device_insertion
- device = dv.Device(path=path, mount=mount)
-
- if not self._device_already_detected(device):
- if self.search_for_PSD() and path not in self.prefs.device_whitelist:
- # prompt user if device should be used or not
- self.get_use_device(device)
- else:
- scan_pid = self.start_device_scan(device)
- self.mounts_by_path[path] = scan_pid
-
- def on_mount_removed(self, vmonitor, mount):
- """
- callback run when gio indicates a new volume
- has been mounted
- """
-
- path = mount.get_root().get_path()
-
- # three scenarios -
- # the mount has been scanned but downloading has not yet started
- # files are being downloaded from mount (it must be a messy unmount)
- # files have finished downloading from mount
-
- if path in self.mounts_by_path:
- scan_pid = self.mounts_by_path[path]
- del self.mounts_by_path[path]
- # temp directory should be cleaned by finishing of process
-
- self.thumbnails.clear_all(scan_pid = scan_pid,
- keep_downloaded_files = True)
- self.device_collection.remove_device(scan_pid)
-
-
-
- # remove backup volumes
- elif path in self.backup_devices:
- del self.backup_devices[path]
- self.display_free_space()
- self.backup_manager.remove_device(path)
- self.update_no_backup_devices()
-
- # may need to disable download button and menu
- self.set_download_action_sensitivity()
-
- def clear_non_running_downloads(self):
- """
- Clears the display of downloads that are currently not running
- """
-
- # Stop any processes currently scanning or creating thumbnails
- self._terminate_processes(terminate_file_copies=False)
-
- # Remove them from the user interface
- for scan_pid in self.device_collection.get_all_displayed_processes():
- if scan_pid not in self.download_active_by_scan_pid:
- self.device_collection.remove_device(scan_pid)
- self.thumbnails.clear_all(scan_pid=scan_pid)
-
-
-
-
- # # #
- # Download and help buttons, and menu items
- # # #
-
- def on_download_action_activate(self, action):
- """
- Called when a download is activated
- """
-
- if self.copy_files_manager.paused:
- logger.debug("Download resumed")
- self.resume_download()
- else:
- logger.debug("Download activated")
-
- if self.download_action_is_download:
- if self.need_job_code_for_naming and not self.prompting_for_job_code:
- self.get_job_code()
- else:
- self.start_download()
- else:
- self.pause_download()
-
-
- def on_help_action_activate(self, action):
- webbrowser.open("http://www.damonlynch.net/rapid/documentation")
-
- def on_preferences_action_activate(self, action):
-
- preferencesdialog.PreferencesDialog(self)
-
- def set_download_action_sensitivity(self):
- """
- Sets sensitivity of Download action to enable or disable it
-
- Affects download button and menu item
- """
- if not self.download_is_occurring():
- sensitivity = False
- if self.scan_manager.no_tasks == 0:
- if self.thumbnails.files_are_checked_to_download():
- sensitivity = True
-
- self.download_action.set_sensitive(sensitivity)
-
- def set_download_action_label(self, is_download):
- """
- Toggles label betwen pause and download
- """
-
- if is_download:
- self.download_action.set_label(_("Download"))
- self.download_action_is_download = True
- else:
- self.download_action.set_label(_("Pause"))
- self.download_action_is_download = False
-
- # # #
- # Job codes
- # # #
-
-
- def _init_job_code(self):
- self.job_code = self.last_chosen_job_code = ''
- self.need_job_code_for_naming = self.prefs.any_pref_uses_job_code()
- self.prompting_for_job_code = False
-
- def assign_job_code(self, code):
- """ assign job code (which may be empty) to member variable and update user preferences
-
- Update preferences only if code is not empty. Do not duplicate job code.
- """
-
- self.job_code = code
-
- if code:
- #add this value to job codes preferences
- #delete any existing value which is the same
- #(this way it comes to the front, which is where it should be)
- #never modify self.prefs.job_codes in place! (or prefs become screwed up)
-
- jcs = self.prefs.job_codes
- while code in jcs:
- jcs.remove(code)
-
- self.prefs.job_codes = [code] + jcs
-
- def _get_job_code(self, post_job_code_entry_callback):
- """ prompt for a job code """
-
- if not self.prompting_for_job_code:
- logger.debug("Prompting for Job Code")
- self.prompting_for_job_code = True
- j = preferencesdialog.JobCodeDialog(parent_window = self.rapidapp,
- job_codes = self.prefs.job_codes,
- default_job_code = self.last_chosen_job_code,
- post_job_code_entry_callback=post_job_code_entry_callback,
- entry_only = False)
- else:
- logger.debug("Already prompting for Job Code, do not prompt again")
-
- def get_job_code(self):
- self._get_job_code(self.got_job_code)
-
- def got_job_code(self, dialog, user_chose_code, code):
- dialog.destroy()
- self.prompting_for_job_code = False
-
- if user_chose_code:
- if code is None:
- code = ''
- self.assign_job_code(code)
- self.last_chosen_job_code = code
- logger.debug("Job Code %s entered", self.job_code)
- self.start_download()
-
- else:
- # user cancelled
- logger.debug("No Job Code entered")
- self.job_code = ''
- self.auto_start_is_on = False
-
-
- # # #
- # Download
- # # #
-
- def _init_download_tracking(self):
- """
- Initialize variables to track downloads
- """
- # Track download sizes and other values for each device.
- # (Scan id acts as an index to each device. A device could be scanned
- # more than once).
- self.download_tracker = downloadtracker.DownloadTracker()
-
- # Track which temporary directories are created when downloading files
- self.temp_dirs_by_scan_pid = dict()
-
- # Track which downloads are running
- self.download_active_by_scan_pid = []
-
- def modify_files_during_download(self):
- """ Returns True if there is a need to modify or verify files during download"""
- return self.prefs.auto_rotate_jpeg or (self.focal_length is not None) or self.prefs.verify_file
-
-
- def start_download(self, scan_pid=None):
- """
- Start download, renaming and backup of files.
-
- If scan_pid is specified, only files matching it will be downloaded
- """
-
- files_by_scan_pid = self.thumbnails.get_files_checked_for_download(scan_pid)
- self.check_file_types_to_be_downloaded(files_by_scan_pid)
- folders_valid, invalid_dirs = self.check_download_folder_validity(files_by_scan_pid)
-
- if not folders_valid:
- if len(invalid_dirs) > 1:
- msg = _("These download folders are invalid:\n%(folder1)s\n%(folder2)s") % {
- 'folder1': invalid_dirs[0], 'folder2': invalid_dirs[1]}
- else:
- msg = _("This download folder is invalid:\n%s") % invalid_dirs[0]
- self.log_error(config.CRITICAL_ERROR, _("Download cannot proceed"),
- msg)
- else:
- missing_destinations = self.backup_destinations_missing()
- if missing_destinations is not None:
- # Warn user that they have specified that they want to backup a file type, but no such folder exists on backup devices
- if not missing_destinations[0]:
- logger.warning("No backup device contains a valid folder for backing up photos")
- msg = _("No backup device contains a valid folder for backing up %(filetype)s") % {'filetype': _('photos')}
- else:
- logger.warning("No backup device contains a valid folder for backing up videos")
- msg = _("No backup device contains a valid folder for backing up %(filetype)s") % {'filetype': _('videos')}
-
- self.log_error(config.WARNING, _("Backup problem"), msg)
-
- # set time download is starting if it is not already set
- # it is unset when all downloads are completed
- if self.download_start_time is None:
- self.download_start_time = datetime.datetime.now()
-
- # Set status to download pending
- self.thumbnails.mark_download_pending(files_by_scan_pid)
-
- # disable refresh and preferences change while download is occurring
- self.enable_prefs_and_refresh(enabled=False)
-
- for scan_pid in files_by_scan_pid:
- files = files_by_scan_pid[scan_pid]
- # if generating thumbnails for this scan_pid, stop it
- if self.thumbnails.terminate_thumbnail_generation(scan_pid):
- self.thumbnails.mark_thumbnails_needed(files)
-
- self.download_files(files, scan_pid)
-
- self.set_download_action_label(is_download = False)
-
- def pause_download(self):
-
- self.copy_files_manager.pause()
-
- # set action to display Download
- if not self.download_action_is_download:
- self.set_download_action_label(is_download = True)
-
- self.time_check.pause()
-
- def resume_download(self):
- for scan_pid in self.download_active_by_scan_pid:
- self.time_remaining.set_time_mark(scan_pid)
-
- self.time_check.set_download_mark()
-
- self.copy_files_manager.start()
-
- def download_files(self, files, scan_pid):
- """
- Initiate downloading and renaming of files
- """
- # Check which file types will be downloaded for this particular process
- no_photos_to_download = self.files_of_type_present(files,
- rpdfile.FILE_TYPE_PHOTO,
- return_file_count=True)
- if no_photos_to_download:
- photo_download_folder = self.prefs.download_folder
- else:
- photo_download_folder = None
-
- if DOWNLOAD_VIDEO:
- no_videos_to_download = self.files_of_type_present(files,
- rpdfile.FILE_TYPE_VIDEO,
- return_file_count=True)
- if no_videos_to_download:
- video_download_folder = self.prefs.video_download_folder
- else:
- video_download_folder = None
- else:
- video_download_folder = None
- no_videos_to_download = 0
-
- photo_download_size, video_download_size = self.size_files_to_be_downloaded(files)
- self.download_tracker.init_stats(scan_pid=scan_pid,
- photo_size_in_bytes=photo_download_size,
- video_size_in_bytes=video_download_size,
- no_photos_to_download=no_photos_to_download,
- no_videos_to_download=no_videos_to_download)
-
-
- download_size = photo_download_size + video_download_size
-
- if self.prefs.backup_images:
- download_size = download_size + ((self.no_photo_backup_devices * photo_download_size) +
- (self.no_video_backup_devices * video_download_size))
-
- self.time_remaining.set(scan_pid, download_size)
- self.time_check.set_download_mark()
-
- self.download_active_by_scan_pid.append(scan_pid)
-
-
- if len(self.download_active_by_scan_pid) > 1:
- self.display_summary_notification = True
-
- if self.auto_start_is_on and self.prefs.generate_thumbnails:
- for rpd_file in files:
- rpd_file.generate_thumbnail = True
-
- verify_file = self.prefs.verify_file
- if verify_file:
- # since a file might be modified in the file modify process,
- # if it will be backed up, need to refresh the md5 once it has
- # been modified
- refresh_md5_on_file_change = self.prefs.backup_images
- else:
- refresh_md5_on_file_change = False
- modify_files_during_download = self.modify_files_during_download()
- if modify_files_during_download:
- self.file_modify_manager.add_task((scan_pid, self.prefs.auto_rotate_jpeg, self.focal_length, verify_file, refresh_md5_on_file_change))
- modify_pipe = self.file_modify_manager.get_modify_pipe(scan_pid)
- else:
- modify_pipe = None
-
-
- # Initiate copy files process
- self.copy_files_manager.add_task((photo_download_folder,
- video_download_folder, scan_pid,
- files, verify_file,
- modify_files_during_download,
- modify_pipe))
-
- def copy_files_results(self, source, condition):
- """
- Handle results from copy files process
- """
- #FIXME: must handle early termination / pause of copy files process
- connection = self.copy_files_manager.get_pipe(source)
- conn_type, msg_data = connection.recv()
- if conn_type == rpdmp.CONN_PARTIAL:
- msg_type, data = msg_data
-
- if msg_type == rpdmp.MSG_TEMP_DIRS:
- scan_pid, photo_temp_dir, video_temp_dir = data
- self.temp_dirs_by_scan_pid[scan_pid] = (photo_temp_dir, video_temp_dir)
-
- # Report which temporary directories are being used for this
- # download
- if photo_temp_dir and video_temp_dir:
- logger.debug("Using temp dirs %s (photos) & %s (videos)",
- photo_temp_dir, video_temp_dir)
- elif photo_temp_dir:
- logger.debug("Using temp dir %s (photos)",
- photo_temp_dir)
- else:
- logger.debug("Using temp dir %s (videos)",
- video_temp_dir)
- elif msg_type == rpdmp.MSG_BYTES:
- scan_pid, total_downloaded, chunk_downloaded = data
- self.download_tracker.set_total_bytes_copied(scan_pid,
- total_downloaded)
- self.time_check.increment(bytes_downloaded=chunk_downloaded)
- percent_complete = self.download_tracker.get_percent_complete(scan_pid)
- self.device_collection.update_progress(scan_pid, percent_complete,
- None, None)
- self.time_remaining.update(scan_pid, bytes_downloaded=chunk_downloaded)
- elif msg_type == rpdmp.MSG_FILE:
- self.copy_file_results_single_file(data)
-
- return True
- else:
- # Process is complete, i.e. conn_type == rpdmp.CONN_COMPLETE
- connection.close()
- return False
-
-
- def copy_file_results_single_file(self, data):
- """
- Handles results from one of two processes:
- 1. copy_files
- 2. file_modify
-
- Operates after a single file has been copied from the download device
- to the local folder.
-
- Calls the process to rename files and create subfolders (subfolderfile)
- """
-
- download_succeeded, rpd_file, download_count, temp_full_file_name, thumbnail_icon, thumbnail = data
-
- if thumbnail is not None or thumbnail_icon is not None:
- self.thumbnails.update_thumbnail((rpd_file.unique_id,
- thumbnail_icon,
- thumbnail))
-
- self.download_tracker.set_download_count_for_file(
- rpd_file.unique_id, download_count)
- self.download_tracker.set_download_count(
- rpd_file.scan_pid, download_count)
- rpd_file.download_start_time = self.download_start_time
-
- if download_succeeded:
- # Insert preference values needed for name generation
- rpd_file = prefsrapid.insert_pref_lists(self.prefs, rpd_file)
- rpd_file.strip_characters = self.prefs.strip_characters
- rpd_file.download_folder = self.prefs.get_download_folder_for_file_type(rpd_file.file_type)
- rpd_file.download_conflict_resolution = self.prefs.download_conflict_resolution
- rpd_file.synchronize_raw_jpg = self.prefs.must_synchronize_raw_jpg()
- rpd_file.job_code = self.job_code
-
- # Call this even if download did not succeed e.g. file verification error
- self.subfolder_file_manager.rename_file_and_move_to_subfolder(
- download_succeeded,
- download_count,
- rpd_file
- )
-
- def file_modify_results(self, source, condition):
- """
- 'file modify' is a process that runs immediately after 'copy files',
- meaning there can be more than one at one time.
-
- It runs before the renaming process.
- """
- connection = self.file_modify_manager.get_pipe(source)
-
- conn_type, data = connection.recv()
- if conn_type == rpdmp.CONN_PARTIAL:
- self.copy_file_results_single_file(data)
- return True
- else:
- # Process is complete, i.e. conn_type == rpdmp.CONN_COMPLETE
- connection.close()
- return False
-
-
- def download_is_occurring(self):
- """Returns True if a file is currently being downloaded, renamed or
- backed up
- """
- return not len(self.download_active_by_scan_pid) == 0
-
- # # #
- # Create folder and file names for downloaded files
- # # #
-
- def subfolder_file_results(self, move_succeeded, rpd_file, download_count):
- """
- Handle results of subfolder creation and file renaming
- """
-
- scan_pid = rpd_file.scan_pid
- unique_id = rpd_file.unique_id
-
- if rpd_file.status == config.STATUS_DOWNLOADED_WITH_WARNING:
- self.log_error(config.WARNING, rpd_file.error_title,
- rpd_file.error_msg, rpd_file.error_extra_detail)
-
- if self.prefs.backup_images:
- if self.backup_possible(rpd_file.file_type):
- if self.prefs.backup_device_autodetection:
- if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
- path_suffix = self.prefs.backup_identifier
- else:
- path_suffix = self.prefs.video_backup_identifier
- else:
- path_suffix = None
-
- self.backup_manager.backup_file(move_succeeded, rpd_file,
- path_suffix,
- self.prefs.backup_duplicate_overwrite,
- self.prefs.verify_file,
- download_count)
- else:
- if rpd_file.status == config.STATUS_DOWNLOAD_FAILED:
- rpd_file.status = config.STATUS_DOWNLOAD_AND_BACKUP_FAILED
- else:
- rpd_file.status = config.STATUS_BACKUP_PROBLEM
-
- self.file_download_finished(move_succeeded, rpd_file)
- else:
- self.file_download_finished(move_succeeded, rpd_file)
-
- def backup_possible(self, file_type):
- if file_type == rpdfile.FILE_TYPE_PHOTO:
- return self.no_photo_backup_devices > 0
- elif file_type == rpdfile.FILE_TYPE_VIDEO:
- return self.no_video_backup_devices > 0
- else:
- logger.critical("Unrecognized file type when determining if backup is possible")
-
-
- def multiple_backup_devices(self, file_type):
- """Returns true if more than one backup device is being used for that
- file type
- """
- return ((file_type == rpdfile.FILE_TYPE_PHOTO and
- self.no_photo_backup_devices > 1) or
- (file_type == rpdfile.FILE_TYPE_VIDEO and
- self.no_video_backup_devices > 1))
-
- def backup_results(self, source, condition):
- """
- Handle results sent from backup processes
- """
- connection = self.backup_manager.get_pipe(source)
- conn_type, msg_data = connection.recv()
- if conn_type == rpdmp.CONN_PARTIAL:
- msg_type, data = msg_data
-
- if msg_type == rpdmp.MSG_BYTES:
- scan_pid, backup_pid, total_downloaded, chunk_downloaded = data
- self.download_tracker.increment_bytes_backed_up(scan_pid,
- chunk_downloaded)
- self.time_check.increment(bytes_downloaded=chunk_downloaded)
- percent_complete = self.download_tracker.get_percent_complete(scan_pid)
- self.device_collection.update_progress(scan_pid, percent_complete,
- None, None)
- self.time_remaining.update(scan_pid, bytes_downloaded=chunk_downloaded)
-
- elif msg_type == rpdmp.MSG_FILE:
- backup_succeeded, do_backup, rpd_file = data
-
- # Only show an error message if there is more than one device
- # backing up files of this type - if that is the case,
- # do not want to rely on showing an error message in the
- # function file_download_finished, as it is only called once,
- # when all files have been backed up
- if not backup_succeeded and self.multiple_backup_devices(rpd_file.file_type) and do_backup:
- self.log_error(config.SERIOUS_ERROR,
- rpd_file.error_title,
- rpd_file.error_msg, rpd_file.error_extra_detail)
-
- if do_backup:
- self.download_tracker.file_backed_up(rpd_file.unique_id)
- if self.download_tracker.all_files_backed_up(rpd_file.unique_id,
- rpd_file.file_type):
- logger.debug("File %s will not be backed up to any more locations", rpd_file.download_name)
- self.file_download_finished(backup_succeeded or not do_backup, rpd_file)
- return True
- else:
- return False
-
-
- def file_download_finished(self, succeeded, rpd_file):
- """
- Called when a file has been downloaded i.e. copied, renamed, and backed up
- """
- scan_pid = rpd_file.scan_pid
- unique_id = rpd_file.unique_id
- # Update error log window if neccessary
- if not succeeded and not self.multiple_backup_devices(rpd_file.file_type):
- self.log_error(config.SERIOUS_ERROR, rpd_file.error_title,
- rpd_file.error_msg, rpd_file.error_extra_detail)
- elif self.prefs.auto_delete:
- # record which files to automatically delete when download
- # completes
- self.download_tracker.add_to_auto_delete(rpd_file)
-
- self.thumbnails.update_status_post_download(rpd_file)
- self.download_tracker.file_downloaded_increment(scan_pid,
- rpd_file.file_type,
- rpd_file.status)
-
- completed, files_remaining = self._update_file_download_device_progress(scan_pid, unique_id, rpd_file.file_type)
-
- if self.download_is_occurring():
- self.update_time_remaining()
-
- if completed:
- # Last file for this scan pid has been downloaded, so clean temp directory
- logger.debug("Purging temp directories")
- self._clean_temp_dirs_for_scan_pid(scan_pid)
- if self.prefs.auto_delete:
- logger.debug("Auto deleting files")
- self.auto_delete(scan_pid)
- self.download_tracker.clear_auto_delete(scan_pid)
- self.download_active_by_scan_pid.remove(scan_pid)
- self.time_remaining.remove(scan_pid)
- self.notify_downloaded_from_device(scan_pid)
- if files_remaining == 0 and self.prefs.auto_unmount:
- self.device_collection.unmount(scan_pid)
-
-
- if not self.download_is_occurring():
- logger.debug("Download completed")
- self.enable_prefs_and_refresh(enabled=True)
- self.notify_download_complete()
- self.download_progressbar.set_fraction(0.0)
-
- self.prefs.stored_sequence_no = self.stored_sequence_value.value
- self.downloads_today_tracker.set_raw_downloads_today_from_int(self.downloads_today_value.value)
- self.downloads_today_tracker.set_raw_downloads_today_date(self.downloads_today_date_value.value)
- self.prefs.set_downloads_today_from_tracker(self.downloads_today_tracker)
-
- if ((self.prefs.auto_exit and self.download_tracker.no_errors_or_warnings())
- or self.prefs.auto_exit_force):
- if not self.thumbnails.files_remain_to_download():
- self._terminate_processes()
- gtk.main_quit()
-
- self.download_tracker.purge_all()
- self.speed_label.set_label(" ")
-
- self.display_free_space()
-
- self.set_download_action_label(is_download=True)
- self.set_download_action_sensitivity()
-
- self.job_code = ''
- self.download_start_time = None
-
-
- def update_time_remaining(self):
- update, download_speed = self.time_check.check_for_update()
- if update:
- self.speed_label.set_text(download_speed)
-
- time_remaining = self.time_remaining.time_remaining()
- if time_remaining:
- secs = int(time_remaining)
-
- if secs == 0:
- message = ""
- elif secs == 1:
- message = _("About 1 second remaining")
- elif secs < 60:
- message = _("About %i seconds remaining") % secs
- elif secs == 60:
- message = _("About 1 minute remaining")
- else:
- # Translators: in the text '%(minutes)i:%(seconds)02i', only the : should be translated, if needed.
- # '%(minutes)i' and '%(seconds)02i' should not be modified or left out. They are used to format and display the amount
- # of time the download has remainging, e.g. 'About 5:36 minutes remaining'
- message = _("About %(minutes)i:%(seconds)02i minutes remaining") % {'minutes': secs / 60, 'seconds': secs % 60}
-
- self.rapid_statusbar.pop(self.statusbar_context_id)
- self.rapid_statusbar.push(self.statusbar_context_id, message)
-
- def auto_delete(self, scan_pid):
- """Delete files from download device at completion of download"""
- for file in self.download_tracker.get_files_to_auto_delete(scan_pid):
- f = gio.File(file)
- try:
- f.delete(cancellable=None)
- except gio.Error, inst:
- logger.error("Failure deleting file %s", file)
- logger.error(inst)
-
- def file_types_by_number(self, no_photos, no_videos):
- """
- returns a string to be displayed to the user that can be used
- to show if a value refers to photos or videos or both, or just one
- of each
- """
- if (no_videos > 0) and (no_photos > 0):
- v = _('photos and videos')
- elif (no_videos == 0) and (no_photos == 0):
- v = _('photos or videos')
- elif no_videos > 0:
- if no_videos > 1:
- v = _('videos')
- else:
- v = _('video')
- else:
- if no_photos > 1:
- v = _('photos')
- else:
- v = _('photo')
- return v
-
- def notify_downloaded_from_device(self, scan_pid):
- device = self.device_collection.get_device(scan_pid)
-
- if device.mount is None:
- notification_name = PROGRAM_NAME
- icon = self.application_icon
- else:
- notification_name = device.get_name()
- icon = device.get_icon(self.notification_icon_size)
-
- no_photos_downloaded = self.download_tracker.get_no_files_downloaded(
- scan_pid, rpdfile.FILE_TYPE_PHOTO)
- no_videos_downloaded = self.download_tracker.get_no_files_downloaded(
- scan_pid, rpdfile.FILE_TYPE_VIDEO)
- no_photos_failed = self.download_tracker.get_no_files_failed(
- scan_pid, rpdfile.FILE_TYPE_PHOTO)
- no_videos_failed = self.download_tracker.get_no_files_failed(
- scan_pid, rpdfile.FILE_TYPE_VIDEO)
- no_files_downloaded = no_photos_downloaded + no_videos_downloaded
- no_files_failed = no_photos_failed + no_videos_failed
- no_warnings = self.download_tracker.get_no_warnings(scan_pid)
-
- file_types = self.file_types_by_number(no_photos_downloaded, no_videos_downloaded)
- file_types_failed = self.file_types_by_number(no_photos_failed, no_videos_failed)
- message = _("%(noFiles)s %(filetypes)s downloaded") % \
- {'noFiles':no_files_downloaded, 'filetypes': file_types}
-
- if no_files_failed:
- message += "\n" + _("%(noFiles)s %(filetypes)s failed to download") % {'noFiles':no_files_failed, 'filetypes':file_types_failed}
-
- if no_warnings:
- message = "%s\n%s " % (message, no_warnings) + _("warnings")
-
- if use_pynotify:
- n = pynotify.Notification(notification_name, message)
- n.set_icon_from_pixbuf(icon)
-
- try:
- n.show()
- except:
- logger.error("Unable to display message using notification system")
-
- def notify_download_complete(self):
- if self.display_summary_notification:
- message = _("All downloads complete")
-
- # photo downloads
- photo_downloads = self.download_tracker.total_photos_downloaded
- if photo_downloads:
- filetype = self.file_types_by_number(photo_downloads, 0)
- message += "\n" + _("%(number)s %(numberdownloaded)s") % \
- {'number': photo_downloads,
- 'numberdownloaded': _("%(filetype)s downloaded") % \
- {'filetype': filetype}}
-
- # photo failures
- photo_failures = self.download_tracker.total_photo_failures
- if photo_failures:
- filetype = self.file_types_by_number(photo_failures, 0)
- message += "\n" + _("%(number)s %(numberdownloaded)s") % \
- {'number': photo_failures,
- 'numberdownloaded': _("%(filetype)s failed to download") % \
- {'filetype': filetype}}
-
- # video downloads
- video_downloads = self.download_tracker.total_videos_downloaded
- if video_downloads:
- filetype = self.file_types_by_number(0, video_downloads)
- message += "\n" + _("%(number)s %(numberdownloaded)s") % \
- {'number': video_downloads,
- 'numberdownloaded': _("%(filetype)s downloaded") % \
- {'filetype': filetype}}
-
- # video failures
- video_failures = self.download_tracker.total_video_failures
- if video_failures:
- filetype = self.file_types_by_number(0, video_failures)
- message += "\n" + _("%(number)s %(numberdownloaded)s") % \
- {'number': video_failures,
- 'numberdownloaded': _("%(filetype)s failed to download") % \
- {'filetype': filetype}}
-
- # warnings
- warnings = self.download_tracker.total_warnings
- if warnings:
- message += "\n" + _("%(number)s %(numberdownloaded)s") % \
- {'number': warnings,
- 'numberdownloaded': _("warnings")}
-
- if use_pynotify:
- n = pynotify.Notification(PROGRAM_NAME, message)
- n.set_icon_from_pixbuf(self.application_icon)
- try:
- n.show()
- except:
- logger.error("Unable to display message using notification system")
- self.display_summary_notification = False # don't show it again unless needed
-
-
- def _update_file_download_device_progress(self, scan_pid, unique_id, file_type):
- """
- Increments the progress bar for an individual device
-
- Returns if the download is completed for that scan_pid
- It also returns the number of files remaining for the scan_pid, BUT
- this value is valid ONLY if the download is completed
- """
-
- files_downloaded = self.download_tracker.get_download_count_for_file(unique_id)
- files_to_download = self.download_tracker.get_no_files_in_download(scan_pid)
- file_types = self.download_tracker.get_file_types_present(scan_pid)
- completed = files_downloaded == files_to_download
- if completed and (self.prefs.backup_images and self.backup_possible(file_type)):
- completed = self.download_tracker.all_files_backed_up(unique_id, file_type)
-
- if completed:
- files_remaining = self.thumbnails.get_no_files_remaining(scan_pid)
- else:
- files_remaining = 0
-
- if completed and files_remaining:
- # e.g.: 3 of 205 photos and videos (202 remaining)
- progress_bar_text = _("%(number)s of %(total)s %(filetypes)s (%(remaining)s remaining)") % {
- 'number': files_downloaded,
- 'total': files_to_download,
- 'filetypes': file_types,
- 'remaining': files_remaining}
- else:
- # e.g.: 205 of 205 photos and videos
- progress_bar_text = _("%(number)s of %(total)s %(filetypes)s") % \
- {'number': files_downloaded,
- 'total': files_to_download,
- 'filetypes': file_types}
- percent_complete = self.download_tracker.get_percent_complete(scan_pid)
- self.device_collection.update_progress(scan_pid=scan_pid,
- percent_complete=percent_complete,
- progress_bar_text=progress_bar_text,
- bytes_downloaded=None)
-
- percent_complete = self.download_tracker.get_overall_percent_complete()
- self.download_progressbar.set_fraction(percent_complete)
-
- return (completed, files_remaining)
-
-
- def _clean_all_temp_dirs(self):
- """
- Cleans all temp dirs if they exist
- """
- for scan_pid in self.temp_dirs_by_scan_pid:
- for temp_dir in self.temp_dirs_by_scan_pid[scan_pid]:
- self._purge_dir(temp_dir)
-
- self.temp_dirs_by_scan_pid = {}
-
-
- def _clean_temp_dirs_for_scan_pid(self, scan_pid):
- """
- Deletes temp files and folders used in download
- """
- for temp_dir in self.temp_dirs_by_scan_pid[scan_pid]:
- self._purge_dir(temp_dir)
- del self.temp_dirs_by_scan_pid[scan_pid]
-
- def _purge_dir(self, directory):
- """
- Deletes all files in the directory, and the directory itself.
-
- Does not recursively traverse any subfolders in the directory.
- """
-
- if directory:
- try:
- path = gio.File(directory)
- # first delete any files in the temp directory
- # assume there are no directories in the temp directory
- file_attributes = "standard::name,standard::type"
- children = path.enumerate_children(file_attributes)
- for child in children:
- f = path.get_child(child.get_name())
- f.delete(cancellable=None)
- path.delete(cancellable=None)
- logger.debug("Deleted directory %s", directory)
- except gio.Error, inst:
- logger.error("Failure deleting temporary folder %s", directory)
- logger.error(inst)
-
-
- # # #
- # Preferences
- # # #
-
-
- def _init_prefs(self, auto_detect, device_location):
- self.prefs = prefsrapid.RapidPreferences()
-
- # handle device preferences set from the command line
- # do this before preference changes are handled with notify_add
- if auto_detect:
- self.prefs.device_autodetection = True
- elif device_location:
- self.prefs.device_location = device_location
- self.prefs.device_autodetection = False
-
- self.prefs.notify_add(self.on_preference_changed)
-
- # flag to indicate whether the user changed some preferences that
- # indicate the image and backup devices should be setup again
- self.rerun_setup_available_image_and_video_media = False
- self.rerun_setup_available_backup_media = False
-
- # flag to indicate that the preferences dialog window is being
- # displayed to the user
- self.preferences_dialog_displayed = False
-
- # flag to indicate that the user has modified the download today
- # related values in the preferences dialog window
- self.refresh_downloads_today = False
-
- # these values are used to track the number of backup devices /
- # locations for each file type
- self.no_photo_backup_devices = 0
- self.no_video_backup_devices = 0
-
- self.downloads_today_tracker = self.prefs.get_downloads_today_tracker()
-
- downloads_today = self.downloads_today_tracker.get_and_maybe_reset_downloads_today()
- if downloads_today > 0:
- logger.info("Downloads that have occurred so far today: %s", downloads_today)
- else:
- logger.info("No downloads have occurred so far today")
-
- self.downloads_today_value = Value(c_int,
- self.downloads_today_tracker.get_raw_downloads_today())
- self.downloads_today_date_value = Array(c_char,
- self.downloads_today_tracker.get_raw_downloads_today_date())
- self.day_start_value = Array(c_char,
- self.downloads_today_tracker.get_raw_day_start())
- self.refresh_downloads_today_value = Value(c_bool, False)
- self.stored_sequence_value = Value(c_int, self.prefs.stored_sequence_no)
- self.uses_stored_sequence_no_value = Value(c_bool, self.prefs.any_pref_uses_stored_sequence_no())
- self.uses_session_sequece_no_value = Value(c_bool, self.prefs.any_pref_uses_session_sequece_no())
- self.uses_sequence_letter_value = Value(c_bool, self.prefs.any_pref_uses_sequence_letter_value())
-
- self.check_prefs_upgrade(__version__)
- self.prefs.program_version = __version__
-
- def _check_for_sequence_value_use(self):
- self.uses_stored_sequence_no_value.value = self.prefs.any_pref_uses_stored_sequence_no()
- self.uses_session_sequece_no_value.value = self.prefs.any_pref_uses_session_sequece_no()
- self.uses_sequence_letter_value.value = self.prefs.any_pref_uses_sequence_letter_value()
-
- def check_prefs_upgrade(self, running_version):
- """
- Checks if the running version of the program is different from the
- version recorded in the preferences.
-
- If the version is different, the preferences are checked to see
- whether they should be upgraded or not.
- """
- previous_version = self.prefs.program_version
- if len(previous_version) > 0:
- # the program has been run previously for this user
-
- pv = utilities.pythonify_version(previous_version)
- rv = utilities.pythonify_version(running_version)
-
- if pv <> rv:
- # 0.4.1 and below had only one manual backup location
- # 0.4.2 introduced a distinct video back up location that can be manually set
- # Therefore must duplicate the previous photo & video manual backup location into the
- # new video field, unless it has already been changed already.
-
- if pv < utilities.pythonify_version('0.4.2'):
- if self.prefs.backup_video_location == os.path.expanduser('~'):
- self.prefs.backup_video_location = self.prefs.backup_location
- logger.info("Migrated manual backup location preference to videos: %s",
- self.prefs.backup_video_location)
-
- def on_preference_changed(self, key, value):
- """
- Called when user changes the program's preferences
- """
- logger.debug("Preference change detected: %s", key)
-
- if key == 'show_log_dialog':
- self.menu_log_window.set_active(value)
- elif key in ['device_autodetection', 'device_autodetection_psd',
- 'device_location', 'ignored_paths',
- 'use_re_ignored_paths', 'device_blacklist']:
- self.rerun_setup_available_image_and_video_media = True
- self._set_from_toolbar_state()
- if not self.preferences_dialog_displayed:
- self.post_preference_change()
-
-
- elif key in ['backup_images', 'backup_device_autodetection',
- 'backup_location', 'backup_video_location',
- 'backup_identifier', 'video_backup_identifier']:
- self.rerun_setup_available_backup_media = True
- if not self.preferences_dialog_displayed:
- self.post_preference_change()
-
- # Downloads today and stored sequence numbers are kept in shared memory,
- # so that the subfolderfile daemon process can access and modify them
-
- # Note, totally ignore any changes in downloads today, as it
- # is modified in a special manner via a tracking class
-
- elif key == 'stored_sequence_no':
- if type(value) <> types.IntType:
- logger.critical("Stored sequence number value is malformed")
- else:
- self.stored_sequence_value.value = value
-
- elif key in ['image_rename', 'subfolder', 'video_rename', 'video_subfolder']:
- self.need_job_code_for_naming = self.prefs.any_pref_uses_job_code()
- # Check if stored sequence no is being used
- self._check_for_sequence_value_use()
-
- elif key in ['download_folder', 'video_download_folder']:
- self._set_to_toolbar_values()
- self.display_free_space()
-
- def post_preference_change(self):
- if self.rerun_setup_available_image_and_video_media:
-
- logger.info("Download device settings preferences were changed")
-
- self.thumbnails.clear_all()
- self.setup_devices(on_startup = False, on_preference_change = True, block_auto_start = True)
- self._set_device_collection_size()
-
- if self.main_notebook.get_current_page() == 1: # preview of file
- self.main_notebook.set_current_page(0)
-
- self.rerun_setup_available_image_and_video_media = False
-
- if self.rerun_setup_available_backup_media:
- if self.using_volume_monitor():
- self.start_volume_monitor()
- logger.info("Backup preferences were changed.")
-
- self.refresh_backup_media()
-
- self.rerun_setup_available_backup_media = False
-
- if self.refresh_downloads_today:
- self.downloads_today_value.value = self.downloads_today_tracker.get_raw_downloads_today()
- self.downloads_today_date_value.value = self.downloads_today_tracker.get_raw_downloads_today_date()
- self.day_start_value.value = self.downloads_today_tracker.get_raw_day_start()
- self.refresh_downloads_today_value.value = True
- self.prefs.set_downloads_today_from_tracker(self.downloads_today_tracker)
-
-
-
- # # #
- # Main app window management and setup
- # # #
-
- def _init_pynotify(self):
- """
- Initialize system notification messages
- """
-
- if not pynotify.init("TestCaps"):
- logger.warning("There might be problems using pynotify.")
-
- do_not_size_icon = False
- self.notification_icon_size = 48
- try:
- info = pynotify.get_server_info()
- except:
- logger.warning("Desktop environment notification server is incorrectly configured.")
- else:
- try:
- if info["name"] == 'notify-osd':
- do_not_size_icon = True
- except:
- pass
-
- if do_not_size_icon:
- self.application_icon = gtk.gdk.pixbuf_new_from_file(
- paths.share_dir('glade3/rapid-photo-downloader.svg'))
- else:
- self.application_icon = gtk.gdk.pixbuf_new_from_file_at_size(
- paths.share_dir('glade3/rapid-photo-downloader.svg'),
- self.notification_icon_size, self.notification_icon_size)
-
- def _init_widgets(self):
- """
- Initialize widgets in the main window, and variables that point to them
- """
- builder = gtk.Builder()
- builder.set_translation_domain(config.APP_NAME)
- self.builder = builder
- builder.add_from_file(paths.share_dir("glade3/rapid.ui"))
- self.rapidapp = builder.get_object("rapidapp")
- self.from_toolbar = builder.get_object("from_toolbar")
- self.copy_toolbar = builder.get_object("copy_toolbar")
- self.dest_toolbar = builder.get_object("dest_toolbar")
- self.menu_toolbar = builder.get_object("menu_toolbar")
- self.main_vpaned = builder.get_object("main_vpaned")
- self.main_notebook = builder.get_object("main_notebook")
- self.download_action = builder.get_object("download_action")
- self.download_button = builder.get_object("download_button")
-
- self.download_progressbar = builder.get_object("download_progressbar")
- self.rapid_statusbar = builder.get_object("rapid_statusbar")
- self.statusbar_context_id = self.rapid_statusbar.get_context_id("progress")
- self.device_collection_scrolledwindow = builder.get_object("device_collection_scrolledwindow")
- self.next_image_action = builder.get_object("next_image_action")
- self.prev_image_action = builder.get_object("prev_image_action")
- self.menu_log_window = builder.get_object("menu_log_window")
- self.speed_label = builder.get_object("speed_label")
- self.refresh_action = builder.get_object("refresh_action")
- self.preferences_action = builder.get_object("preferences_action")
-
- # Only enable this action when actually displaying a preview
- self.next_image_action.set_sensitive(False)
- self.prev_image_action.set_sensitive(False)
-
- self._init_toolbars()
-
- # About dialog
- builder.add_from_file(paths.share_dir("glade3/about.ui"))
- self.about = builder.get_object("about")
-
- builder.connect_signals(self)
-
- self.preview_image = PreviewImage(self, builder)
-
- thumbnails_scrolledwindow = builder.get_object('thumbnails_scrolledwindow')
- self.thumbnails = ThumbnailDisplay(self)
- thumbnails_scrolledwindow.add(self.thumbnails)
-
- #collection of devices from which to download
- self.device_collection_viewport = builder.get_object("device_collection_viewport")
- self.device_collection = DeviceCollection(self)
- self.device_collection_viewport.add(self.device_collection)
-
- #error log window
- self.error_log = errorlog.ErrorLog(self)
-
- # monitor to handle mounts and dismounts
- self.vmonitor = None
- # track scan ids for mount paths - very useful when a device is unmounted
- self.mounts_by_path = {}
-
- # Download action state
- self.download_action_is_download = True
-
- # Track the time a download commences
- self.download_start_time = None
-
- # Whether a system wide notifcation message should be shown
- # after a download has occurred in parallel
- self.display_summary_notification = False
-
- # Values used to display how much longer a download will take
- self.time_remaining = downloadtracker.TimeRemaining()
- self.time_check = downloadtracker.TimeCheck()
-
- def _init_toolbars(self):
- """ Setup the 3 vertical toolbars on the main screen """
- self._setup_from_toolbar()
- self._setup_copy_move_toolbar()
- self._setup_dest_toolbar()
-
- # size label widths so they are equal, or else the left border of the file chooser will not match
- self.photo_dest_label.realize()
- self._make_widget_widths_equal(self.photo_dest_label, self.video_dest_label)
- self.photo_dest_label.set_alignment(xalign=0.0, yalign=0.5)
- self.video_dest_label.set_alignment(xalign=0.0, yalign=0.5)
-
- # size copy / move buttons so they are equal in length, so arrows align
- self._make_widget_widths_equal(self.copy_button, self.move_button)
-
- def _setup_from_toolbar(self):
- self.from_toolbar.set_style(gtk.TOOLBAR_TEXT)
- self.from_toolbar.set_border_width(5)
-
- from_label = gtk.Label()
- from_label.set_markup("<i>" + _("From") + "</i>")
- self.from_toolbar_label = gtk.ToolItem()
- self.from_toolbar_label.add(from_label)
- self.from_toolbar_label.set_is_important(True)
- self.from_toolbar.insert(self.from_toolbar_label, 0)
-
- self.auto_detect_button = gtk.ToggleToolButton()
- self.auto_detect_button.set_is_important(True)
- self.auto_detect_button.set_label(_("Auto Detect"))
- self.from_toolbar.insert(self.auto_detect_button, 1)
-
- self.from_filechooser_button = gtk.FileChooserButton(
- _("Select a folder containing %(file_types)s") % {'file_types':file_types_to_download()})
- self.from_filechooser_button.set_action(
- gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
-
- self.from_filechooser = gtk.ToolItem()
- self.from_filechooser.set_is_important(True)
- self.from_filechooser.add(self.from_filechooser_button)
- self.from_filechooser.set_expand(True)
- self.from_toolbar.insert(self.from_filechooser, 2)
-
- self._set_from_toolbar_state()
-
- #set events after having initialized the values
- self.auto_detect_button.connect("toggled", self.on_auto_detect_button_toggled_event)
- self.from_filechooser_button.connect("selection-changed",
- self.on_from_filechooser_button_selection_changed)
-
- self.from_toolbar.show_all()
-
- def _setup_copy_move_toolbar(self):
- self.copy_toolbar.set_style(gtk.TOOLBAR_TEXT)
- self.copy_toolbar.set_border_width(5)
-
- copy_move_label = gtk.Label(" ")
- self.copy_move_toolbar_label = gtk.ToolItem()
- self.copy_move_toolbar_label.add(copy_move_label)
- self.copy_move_toolbar_label.set_is_important(True)
- self.copy_toolbar.insert(self.copy_move_toolbar_label, 0)
-
- self.copy_hbox = gtk.HBox()
- self.move_hbox = gtk.HBox()
- self.forward_image = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
- self.forward_image2 = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
- self.forward_image3 = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
- self.forward_image4 = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_SMALL_TOOLBAR)
- self.forward_label = gtk.Label(" ")
- self.forward_label2 = gtk.Label(" ")
- self.forward_label3 = gtk.Label(" ")
- self.forward_label4 = gtk.Label(" ")
-
- self.copy_button = gtk.RadioToolButton()
- self.copy_button.set_label(_("Copy"))
- self.copy_button.set_is_important(True)
-
- self.copy_hbox.pack_start(self.forward_label)
- self.copy_hbox.pack_start(self.forward_image)
- self.copy_hbox.pack_start(self.copy_button, expand=False, fill=False)
- self.copy_hbox.pack_start(self.forward_image2)
- self.copy_hbox.pack_start(self.forward_label2)
- copy_box = gtk.ToolItem()
- copy_box.add(self.copy_hbox)
- self.copy_toolbar.insert(copy_box, 1)
-
- self.move_button = gtk.RadioToolButton(self.copy_button)
- self.move_button.set_label(_("Move"))
- self.move_button.set_is_important(True)
- self.move_hbox.pack_start(self.forward_label3)
- self.move_hbox.pack_start(self.forward_image3)
- self.move_hbox.pack_start(self.move_button, expand=False, fill=False)
- self.move_hbox.pack_start(self.forward_image4)
- self.move_hbox.pack_start(self.forward_label4)
- move_box = gtk.ToolItem()
- move_box.add(self.move_hbox)
- self.copy_toolbar.insert(move_box, 2)
-
- self.move_button.set_active(self.prefs.auto_delete)
- self.copy_button.connect("toggled", self.on_copy_button_toggle_event)
-
- self.copy_toolbar.show_all()
- self._set_copy_toolbar_active_arrows()
-
- def _setup_dest_toolbar(self):
- #Destination Toolbar
- self.dest_toolbar.set_border_width(5)
-
- dest_label = gtk.Label()
- dest_label.set_markup("<i>" + _("To") + "</i>")
- self.dest_toolbar_label = gtk.ToolItem()
- self.dest_toolbar_label.add(dest_label)
- self.dest_toolbar_label.set_is_important(True)
- self.dest_toolbar.insert(self.dest_toolbar_label, 0)
-
- photo_dest_hbox = gtk.HBox()
- self.photo_dest_label = gtk.Label(_("Photos:"))
-
- self.to_photo_filechooser_button = gtk.FileChooserButton(
- _("Select a folder to download photos to"))
- self.to_photo_filechooser_button.set_action(
- gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
- photo_dest_hbox.pack_start(self.photo_dest_label, expand=False, fill=False, padding=6)
- photo_dest_hbox.pack_start(self.to_photo_filechooser_button)
- self.to_photo_filechooser = gtk.ToolItem()
- self.to_photo_filechooser.set_is_important(True)
- self.to_photo_filechooser.set_expand(True)
- self.to_photo_filechooser.add(photo_dest_hbox)
- self.dest_toolbar.insert(self.to_photo_filechooser, 1)
-
- video_dest_hbox = gtk.HBox()
- self.video_dest_label = gtk.Label(_("Videos:"))
- self.to_video_filechooser_button = gtk.FileChooserButton(
- _("Select a folder to download videos to"))
- self.to_video_filechooser_button.set_action(
- gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
- video_dest_hbox.pack_start(self.video_dest_label, expand=False, fill=False, padding=6)
- video_dest_hbox.pack_start(self.to_video_filechooser_button)
- self.to_video_filechooser = gtk.ToolItem()
- self.to_video_filechooser.set_is_important(True)
- self.to_video_filechooser.set_expand(True)
- self.to_video_filechooser.add(video_dest_hbox)
- self.dest_toolbar.insert(self.to_video_filechooser, 2)
-
- self._set_to_toolbar_values()
- self.to_photo_filechooser_button.connect("selection-changed",
- self.on_to_photo_filechooser_button_selection_changed)
- #~ self.to_photo_filechooser_button.connect("file-set",
- #~ self.on_to_photo_filechooser_button_file_set)
- #~ self.to_photo_filechooser_button.connect("current-folder-changed",
- #~ self.on_to_photo_filechooser_button_current_folder_changed)
- self.to_video_filechooser_button.connect("selection-changed",
- self.on_to_video_filechooser_button_selection_changed)
- self.dest_toolbar.show_all()
-
- def _make_widget_widths_equal(self, widget1, widget2):
- """takes two widgets and sets a width for both equal to widest one"""
-
- x1, y1, w1, h1 = widget1.get_allocation()
- x2, y2, w2, h2 = widget2.get_allocation()
- w = max(w1, w2)
- h = max(h1, h2)
- widget1.set_size_request(w,h)
- widget2.set_size_request(w,h)
-
- def _set_copy_toolbar_active_arrows(self):
- if self.copy_button.get_active():
- self.forward_image.set_visible(True)
- self.forward_image2.set_visible(True)
- self.forward_image3.set_visible(False)
- self.forward_image4.set_visible(False)
- self.forward_label.set_visible(False)
- self.forward_label2.set_visible(False)
- self.forward_label3.set_visible(True)
- self.forward_label4.set_visible(True)
- else:
- self.forward_image.set_visible(False)
- self.forward_image2.set_visible(False)
- self.forward_image3.set_visible(True)
- self.forward_image4.set_visible(True)
- self.forward_label.set_visible(True)
- self.forward_label2.set_visible(True)
- self.forward_label3.set_visible(False)
- self.forward_label4.set_visible(False)
-
- def on_copy_button_toggle_event(self, radio_button):
- self._set_copy_toolbar_active_arrows()
- self.prefs.auto_delete = not self.copy_button.get_active()
-
- def _set_from_toolbar_state(self):
- logger.debug("_set_from_toolbar_state")
- self.auto_detect_button.set_active(self.prefs.device_autodetection)
- if self.prefs.device_autodetection:
- self.from_filechooser_button.set_sensitive(False)
- self.from_filechooser_button.set_current_folder(self.prefs.device_location)
-
- def on_auto_detect_button_toggled_event(self, button):
- logger.debug("on_auto_detect_button_toggled_event")
- self.from_filechooser_button.set_sensitive(not button.get_active())
- if not self.rerun_setup_available_image_and_video_media:
- self.prefs.device_autodetection = button.get_active()
-
- def on_from_filechooser_button_selection_changed(self, filechooserbutton):
- logger.debug("on_from_filechooser_button_selection_changed")
- path = get_folder_selection(filechooserbutton)
- if path and not self.rerun_setup_available_image_and_video_media:
- self.prefs.device_location = path
-
- def on_from_filechooser_button_file_set(self, button):
- logger.debug("on_from_filechooser_button_file_set")
-
- def on_to_photo_filechooser_button_file_set(self, filechooserbutton):
- logger.debug("on_to_filechooser_button_file_set")
-
- def on_to_photo_filechooser_button_selection_changed(self, filechooserbutton):
- logger.debug("on_to_filechooser_button_selection_changed")
- path = get_folder_selection(filechooserbutton)
- #~ logger.debug("Path: %s", path)
- if path:
- self.prefs.download_folder = path
-
- def on_to_photo_filechooser_button_current_folder_changed(self, filechooserbutton):
- logger.debug("on_to_photo_filechooser_button_current_folder_changed")
-
- def on_to_video_filechooser_button_selection_changed(self, filechooserbutton):
- path = get_folder_selection(filechooserbutton)
- if path:
- self.prefs.video_download_folder = path
-
- def _set_to_toolbar_values(self):
- self.to_photo_filechooser_button.set_current_folder(self.prefs.download_folder)
- self.to_video_filechooser_button.set_current_folder(self.prefs.video_download_folder)
-
- def toolbar_event(self, widget, toolbar):
- pass
-
-
-
- def _set_window_size(self):
- """
- Remember the window size from the last time the program was run, or
- set a default size
- """
-
- if self.prefs.main_window_maximized:
- self.rapidapp.maximize()
- self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH,
- config.DEFAULT_WINDOW_HEIGHT)
- elif self.prefs.main_window_size_x > 0:
- self.rapidapp.set_default_size(self.prefs.main_window_size_x, self.prefs.main_window_size_y)
- else:
- # set a default size
- self.rapidapp.set_default_size(config.DEFAULT_WINDOW_WIDTH,
- config.DEFAULT_WINDOW_HEIGHT)
-
-
- def _set_device_collection_size(self):
- """
- Set the size of the device collection scrolled window widget
- """
- if self.device_collection.map_process_to_row:
- height = max(self.device_collection_viewport.size_request()[1], 24)
- self.device_collection_scrolledwindow.set_size_request(-1, height)
- self.main_vpaned.set_position(height)
- else:
- # don't allow the media collection to be absolutely empty
- self.device_collection_scrolledwindow.set_size_request(-1, 47)
-
-
- def on_rapidapp_window_state_event(self, widget, event):
- """ Records the window maximization state in the preferences."""
-
- if event.changed_mask & gdk.WINDOW_STATE_MAXIMIZED:
- self.prefs.main_window_maximized = event.new_window_state & gdk.WINDOW_STATE_MAXIMIZED
-
- def _setup_buttons(self):
- thumbnails_button = self.builder.get_object("thumbnails_button")
- image = gtk.image_new_from_file(paths.share_dir('glade3/thumbnails_icon.png'))
- thumbnails_button.set_image(image)
-
- preview_button = self.builder.get_object("preview_button")
- image = gtk.image_new_from_file(paths.share_dir('glade3/photo_icon.png'))
- preview_button.set_image(image)
-
- next_image_button = self.builder.get_object("next_image_button")
- image = gtk.image_new_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_BUTTON)
- next_image_button.set_image(image)
-
- prev_image_button = self.builder.get_object("prev_image_button")
- image = gtk.image_new_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_BUTTON)
- prev_image_button.set_image(image)
-
- def _setup_icons(self):
- icons = ['rapid-photo-downloader-jobcode',]
- icon_list = [(icon, paths.share_dir('glade3/%s.svg' % icon)) for icon in icons]
- register_iconsets(icon_list)
-
- def _setup_error_icons(self):
- """
- hide display of warning and error symbols in the taskbar until they
- are needed
- """
- self.error_image = self.builder.get_object("error_image")
- self.warning_image = self.builder.get_object("warning_image")
- self.warning_vseparator = self.builder.get_object("warning_vseparator")
- self.error_image.hide()
- self.warning_image.hide()
- self.warning_vseparator.hide()
-
- def enable_prefs_and_refresh(self, enabled):
- """
- If enable is true, then the user is able to activate the preferences
- or refresh command.
- The intention is to be able to disable this during a download
- """
- self.refresh_action.set_sensitive(enabled)
- self.preferences_action.set_sensitive(enabled)
-
- def statusbar_message(self, msg):
- self.rapid_statusbar.push(self.statusbar_context_id, msg)
-
- def statusbar_message_remove(self):
- self.rapid_statusbar.pop(self.statusbar_context_id)
-
- def display_backup_mounts(self):
- """
- Create a message to be displayed to the user showing which backup
- mounts will be used
- """
- message = ''
-
- paths = self.backup_devices.keys()
- i = 0
- v = len(paths)
- prefix = ''
- for b in paths:
- if v > 1:
- if i < (v -1) and i > 0:
- prefix = ', '
- elif i == (v - 1) :
- prefix = " " + _("and") + " "
- i += 1
- message = "%s%s'%s'" % (message, prefix, self.backup_devices[b][0].get_name())
-
- if v > 1:
- message = _("Using backup devices") + " %s" % message
- elif v == 1:
- message = _("Using backup device") + " %s" % message
- else:
- message = _("No backup devices detected")
-
- return message
-
- def display_free_space(self):
- """
- Displays the amount of space free on the filesystem the files will be
- downloaded to.
-
- Also displays backup volumes / path being used.
- """
- photo_dir = self.is_valid_download_dir(path=self.prefs.download_folder, is_photo_dir=True, show_error_in_log=True)
- video_dir = self.is_valid_download_dir(path=self.prefs.video_download_folder, is_photo_dir=False, show_error_in_log=True)
- if photo_dir and video_dir:
- same_file_system = self.same_file_system(self.prefs.download_folder,
- self.prefs.video_download_folder)
- else:
- same_file_system = False
-
- dirs = []
- if photo_dir:
- dirs.append((self.prefs.download_folder, _("photos")))
- if video_dir and not same_file_system:
- dirs.append((self.prefs.video_download_folder, _("videos")))
-
- msg = ''
- if len(dirs) > 1:
- msg = ' ' + _('Free space:') + ' '
-
- for i in range(len(dirs)):
- dir_info = dirs[i]
- folder = gio.File(dir_info[0])
- file_info = folder.query_filesystem_info(gio.FILE_ATTRIBUTE_FILESYSTEM_FREE)
- size = file_info.get_attribute_uint64(gio.FILE_ATTRIBUTE_FILESYSTEM_FREE)
- free = format_size_for_user(bytes=size)
- if len(dirs) > 1:
- #(videos) or (photos) will be appended to the free space message displayed to the
- #user in the status bar.
- #you should only translate this if your language does not use parantheses
- file_type = _("(%(file_type)s)") % {'file_type': dir_info[1]}
-
- #Freespace available on the filesystem for downloading to
- #Displayed in status bar message on main window
- msg += _("%(free)s %(file_type)s") % {'free': free, 'file_type': file_type}
- if i == 0:
- #Inserted in the middle of the statusbar message concerning the amount of freespace
- #Used to differentiate between two different file systems
- #e.g. Free space: 21.3GB (photos); 14.7GB (videos).
- msg += _("; ")
- elif not self.prefs.backup_images:
- #Inserted at the end of the statusbar message concerning the amount of freespace
- #Used to differentiate between two different file systems
- #e.g. Free space: 21.3GB (photos); 14.7GB (videos).
- msg += _(".")
-
- else:
- #Freespace available on the filesystem for downloading to
- #Displayed in status bar message on main window
- #e.g. 14.7GB available
- msg = " " + _("%(free)s free") % {'free': free}
-
-
- if self.prefs.backup_images:
- if not self.prefs.backup_device_autodetection:
- if self.prefs.backup_location == self.prefs.backup_video_location:
- if DOWNLOAD_VIDEO:
- # user manually specified the same location for photos and video backups
- msg2 = _('Backing up photos and videos to %(path)s') % {'path':self.prefs.backup_location}
- else:
- # user manually specified backup location
- msg2 = _('Backing up to %(path)s') % {'path':self.prefs.backup_location}
- else:
- # user manually specified different locations for photo and video backups
- msg2 = _('Backing up photos to %(path)s and videos to %(path2)s') % {
- 'path':self.prefs.backup_location,
- 'path2': self.prefs.backup_video_location}
- else:
- msg2 = self.display_backup_mounts()
-
- if msg:
- msg = _("%(freespace)s. %(backuppaths)s.") % {'freespace': msg, 'backuppaths': msg2}
- else:
- msg = msg2
-
- msg = msg.rstrip()
-
- self.statusbar_message(msg)
-
- def log_error(self, severity, problem, details, extra_detail=None):
- """
- Display error and warning messages to user in log window
- """
- self.error_log.add_message(severity, problem, details, extra_detail)
-
-
- def on_error_eventbox_button_press_event(self, widget, event):
- self.prefs.show_log_dialog = True
- self.error_log.widget.show()
-
-
- def on_menu_log_window_toggled(self, widget):
- active = widget.get_active()
- self.prefs.show_log_dialog = active
- if active:
- self.error_log.widget.show()
- else:
- self.error_log.widget.hide()
-
- def notify_prefs_are_invalid(self, details):
- title = _("Program preferences are invalid")
- logger.critical(title)
- self.log_error(severity=config.CRITICAL_ERROR, problem=title,
- details=details)
-
-
- # # #
- # Utility functions
- # # #
-
- def files_of_type_present(self, files, file_type, return_file_count=False):
- """
- Returns true if there is at least one instance of the file_type
- in the list of files to be copied
-
- If return_file_count is True, then the number of files of that type
- will be counted and returned instead of True or False
- """
- i = 0
- for rpd_file in files:
- if rpd_file.file_type == file_type:
- if return_file_count:
- i += 1
- else:
- return True
- if not return_file_count:
- return False
- else:
- return i
-
- def size_files_to_be_downloaded(self, files):
- """
- Returns the total sizes of the photos and videos to be downloaded in bytes
- """
- photo_size = 0
- video_size = 0
- for rpd_file in files:
- if rpd_file.file_type == rpdfile.FILE_TYPE_PHOTO:
- photo_size += rpd_file.size
- else:
- video_size += rpd_file.size
-
- return (photo_size, video_size)
-
- def check_file_types_to_be_downloaded(self, files_by_scan_pid):
- """Determines what types of files need to be downloaded, setting
- self.downloading_photos and self.downloading_videos accordingly"""
- self.downloading_photos = False
- self.downloading_videos = False
- while not self.downloading_photos and not self.downloading_videos:
- for scan_pid in files_by_scan_pid:
- files = files_by_scan_pid[scan_pid]
- if not self.downloading_photos:
- if self.files_of_type_present(files, rpdfile.FILE_TYPE_PHOTO):
- self.downloading_photos = True
- if not self.downloading_videos:
- if self.files_of_type_present(files, rpdfile.FILE_TYPE_VIDEO):
- self.downloading_videos = True
-
-
- def check_download_folder_validity(self, files_by_scan_pid):
- """
- Checks validity of download folders based on the file types the user
- is attempting to download.
-
- If valid, returns a tuple of True and an empty list.
- If invalid, returns a tuple of False and a list of the invalid directores.
- """
- valid = True
- invalid_dirs = []
-
- if self.downloading_photos:
- if not self.is_valid_download_dir(self.prefs.download_folder,
- is_photo_dir=True):
- valid = False
- invalid_dirs.append(self.prefs.download_folder)
- else:
- logger.debug("Photo download folder is valid: %s",
- self.prefs.download_folder)
-
- if self.downloading_videos:
- if not self.is_valid_download_dir(self.prefs.video_download_folder,
- is_photo_dir=False):
- valid = False
- invalid_dirs.append(self.prefs.video_download_folder)
- else:
- logger.debug("Video download folder is valid: %s",
- self.prefs.video_download_folder)
-
-
- return (valid, invalid_dirs)
-
- def backup_destinations_missing(self):
- if self.prefs.backup_images and self.prefs.backup_device_autodetection:
- photo_backup_ok = video_backup_ok = True
- if self.downloading_photos and not self.backup_possible(rpdfile.FILE_TYPE_PHOTO):
- photo_backup_ok = False
- if self.downloading_videos and not self.backup_possible(rpdfile.FILE_TYPE_VIDEO):
- video_backup_ok = False
- if photo_backup_ok and video_backup_ok:
- return None
- else:
- return (photo_backup_ok, video_backup_ok)
- return None
-
- def same_file_system(self, file1, file2):
- """Returns True if the files / diretories are on the same file system
- """
- f1 = gio.File(file1)
- f2 = gio.File(file2)
- f1_info = f1.query_info(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
- f1_id = f1_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
- f2_info = f2.query_info(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
- f2_id = f2_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILESYSTEM)
- return f1_id == f2_id
-
-
- def same_file(self, file1, file2):
- """Returns True if the files / directories are the same
- """
- f1 = gio.File(file1)
- f2 = gio.File(file2)
-
- file_attributes = "id::file"
- f1_info = f1.query_filesystem_info(file_attributes)
- f1_id = f1_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILE)
- f2_info = f2.query_filesystem_info(file_attributes)
- f2_id = f2_info.get_attribute_string(gio.FILE_ATTRIBUTE_ID_FILE)
- return f1_id == f2_id
-
- def is_valid_download_dir(self, path, is_photo_dir, show_error_in_log=False):
- """
- Checks the following conditions:
- Does the directory exist?
- Is it writable?
-
- if show_error_in_log is True, then display warning in log window, using
- is_photo_dir, which if true means the download directory is for photos,
- if false, for Videos
- """
- valid = False
- if is_photo_dir:
- download_folder_type = _("Photo")
- else:
- download_folder_type = _("Video")
-
- try:
- d = gio.File(path)
- if not d.query_exists(cancellable=None):
- logger.error("%s download folder does not exist: %s",
- download_folder_type, path)
- if show_error_in_log:
- severity = config.WARNING
- problem = _("%(file_type)s download folder does not exist") % {
- 'file_type': download_folder_type}
- details = _("Folder: %s") % path
- self.log_error(severity, problem, details)
- else:
- file_attributes = "standard::type,access::can-read,access::can-write"
- file_info = d.query_filesystem_info(file_attributes)
- file_type = file_info.get_file_type()
-
- if file_type != gio.FILE_TYPE_DIRECTORY and file_type != gio.FILE_TYPE_UNKNOWN:
- logger.error("%s download folder is invalid: %s",
- download_folder_type, path)
- if show_error_in_log:
- severity = config.WARNING
- problem = _("%(file_type)s download folder is invalid") % {
- 'file_type': download_folder_type}
- details = _("Folder: %s") % path
- self.log_error(severity, problem, details)
- else:
- # is the directory writable?
- try:
- temp_dir = tempfile.mkdtemp(prefix="rpd-tmp", dir=path)
- valid = True
- except:
- logger.error("%s is not writable", path)
- if show_error_in_log:
- severity = config.WARNING
- problem = _("%(file_type)s download folder is not writable") % {
- 'file_type': download_folder_type}
- details = _("Folder: %s") % path
- self.log_error(severity, problem, details)
- else:
- f = gio.File(temp_dir)
- f.delete(cancellable=None)
-
- except gio.Error, inst:
- logger.error("Error checking download directory %s", path)
- logger.error(inst)
-
- return valid
-
-
-
- # # #
- # Process results and management
- # # #
-
-
- def _start_process_managers(self):
- """
- Set up process managers.
-
- A task such as scanning a device or copying files is handled in its
- own process.
- """
-
- self.batch_size = 10
- self.batch_size_MB = 2
-
- sequence_values = (self.downloads_today_value,
- self.downloads_today_date_value,
- self.day_start_value,
- self.refresh_downloads_today_value,
- self.stored_sequence_value,
- self.uses_stored_sequence_no_value,
- self.uses_session_sequece_no_value,
- self.uses_sequence_letter_value)
-
- # daemon process to rename files and create subfolders
- self.subfolder_file_manager = SubfolderFileManager(
- self.subfolder_file_results,
- sequence_values)
-
- # process to scan source devices / paths
- self.scan_manager = ScanManager(self.scan_results, self.batch_size,
- self.device_collection.add_device)
-
- #process to copy files from source to destination
- self.copy_files_manager = CopyFilesManager(self.copy_files_results,
- self.batch_size_MB)
-
- #process to back files up
- self.backup_manager = BackupFilesManager(self.backup_results,
- self.batch_size_MB)
-
- #process to enhance files after they've been copied and before they're
- #renamed
- self.file_modify_manager = FileModifyManager(self.file_modify_results)
-
-
- def scan_results(self, source, condition):
- """
- Receive results from scan processes
- """
- connection = self.scan_manager.get_pipe(source)
-
- conn_type, data = connection.recv()
-
- if conn_type == rpdmp.CONN_COMPLETE:
- connection.close()
- self.scan_manager.no_tasks -= 1
- size, file_type_counter, scan_pid = data
- size = format_size_for_user(bytes=size)
- results_summary, file_types_present = file_type_counter.summarize_file_count()
- self.download_tracker.set_file_types_present(scan_pid, file_types_present)
- logger.info('Found %s' % results_summary)
- logger.info('Files total %s' % size)
- self.device_collection.update_device(scan_pid, size)
- self.device_collection.update_progress(scan_pid, 0.0, results_summary, 0, pulse=False)
- self.set_download_action_sensitivity()
-
- if (not self.auto_start_is_on and
- self.prefs.generate_thumbnails):
- self.download_progressbar.set_text(_("Thumbnails"))
- self.thumbnails.generate_thumbnails(scan_pid)
- elif self.auto_start_is_on:
- if self.need_job_code_for_naming and not self.job_code:
- self.get_job_code()
- else:
- self.start_download(scan_pid=scan_pid)
-
- logger.debug("Turning on display of thumbnails")
- self.display_scan_thumbnails()
- self.download_button.grab_focus()
-
- # signal that no more data is coming, finishing io watch for this pipe
- return False
- else:
- # partial results
- if len(data) > self.batch_size:
- logger.critical("incoming pipe length is unexpectedly long: %s" % len(data))
- else:
- size, file_type_counter, scan_pid, rpd_files = data
- size = format_size_for_user(bytes=size)
- scanning_progress = file_type_counter.running_file_count()
- self.device_collection.update_device(scan_pid, size)
- self.device_collection.update_progress(scan_pid, 0.0, scanning_progress, 0, pulse=True)
-
- for rpd_file in rpd_files:
- self.thumbnails.add_file(rpd_file=rpd_file,
- generate_thumbnail = not self.auto_start_is_on)
-
- # must return True for this method to be called again
- return True
-
-
- @dbus.service.method (config.DBUS_NAME,
- in_signature='', out_signature='b')
- def is_running (self):
- return self.running
-
- @dbus.service.method (config.DBUS_NAME,
- in_signature='', out_signature='')
- def start (self):
- if self.is_running():
- self.rapidapp.present()
- else:
- self.running = True
- gtk.main()
-
-def start():
-
- is_beta = config.version.find('~') > 0
-
- parser = OptionParser(version= "%%prog %s" % utilities.human_readable_version(config.version))
- parser.set_defaults(verbose=is_beta, extensions=False)
- # Translators: this text is displayed to the user when they request information on the command line options.
- # The text %default should not be modified or left out.
- parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help=_("display program information on the command line as the program runs (default: %default)"))
- parser.add_option("-d", "--debug", action="store_true", dest="debug", help=_('display debugging information when run from the command line'))
- parser.add_option("-q", "--quiet", action="store_false", dest="verbose", help=_("only output errors to the command line"))
- # image file extensions are recognized RAW files plus TIFF and JPG
- parser.add_option("-e", "--extensions", action="store_true", dest="extensions", help=_("list photo and video file extensions the program recognizes and exit"))
- parser.add_option("--focal-length", type=int, dest="focal_length", help="If an aperture value of 0.0 is encountered, the focal length metadata will be set to the number passed, and its aperture metadata to f/8")
- parser.add_option("-a", "--auto-detect", action="store_true", dest="auto_detect", help=_("automatically detect devices from which to download, overwriting existing program preferences"))
- parser.add_option("-l", "--device-location", type="string", metavar="PATH", dest="device_location", help=_("manually specify the PATH of the device from which to download, overwriting existing program preferences"))
- parser.add_option("--reset-settings", action="store_true", dest="reset", help=_("reset all program settings and preferences and exit"))
- (options, args) = parser.parse_args()
-
- if options.debug:
- logging_level = logging.DEBUG
- elif options.verbose:
- logging_level = logging.INFO
- else:
- logging_level = logging.ERROR
-
- logger.setLevel(logging_level)
-
- if options.auto_detect and options.device_location:
- logger.info(_("Error: specify device auto-detection or manually specify a device's path from which to download, but do not do both."))
- sys.exit(1)
-
- if options.auto_detect:
- auto_detect=True
- logger.info("Device auto detection set from command line")
- else:
- auto_detect=None
-
- if options.device_location:
- device_location=options.device_location
- if device_location[-1]=='/':
- device_location = device_location[:-1]
- logger.info("Device location set from command line: %s", device_location)
- else:
- device_location=None
-
- if options.extensions:
- extensions = ((rpdfile.PHOTO_EXTENSIONS, _("Photos:")), (rpdfile.VIDEO_EXTENSIONS, _("Videos:")))
- for exts, file_type in extensions:
- v = ''
- for e in exts[:-1]:
- v += '%s, ' % e.upper()
- v = file_type + " " + v[:-1] + ' '+ (_('and %s') % exts[-1].upper())
- print v
-
- sys.exit(0)
-
- if options.reset:
- prefs = prefsrapid.RapidPreferences()
- prefs.reset()
- print _("All settings and preferences have been reset")
- sys.exit(0)
-
- if options.focal_length:
- focal_length = options.focal_length
- else:
- focal_length = None
-
- logger.info("Rapid Photo Downloader %s", utilities.human_readable_version(config.version))
- logger.info("Using pyexiv2 %s", metadataphoto.pyexiv2_version_info())
- logger.info("Using exiv2 %s", metadataphoto.exiv2_version_info())
- if metadataexiftool.EXIFTOOL_VERSION is None:
- logger.info("Exiftool not detected")
- else:
- logger.info("Using exiftool %s", metadataexiftool.EXIFTOOL_VERSION)
- if metadatavideo.HAVE_HACHOIR:
- logger.info("Using hachoir %s", metadatavideo.version_info())
-
-
- if focal_length:
- logger.info("Focal length of %s will be used when an aperture of 0.0 is encountered", focal_length)
-
- bus = dbus.SessionBus ()
- request = bus.request_name (config.DBUS_NAME, dbus.bus.NAME_FLAG_DO_NOT_QUEUE)
- if request != dbus.bus.REQUEST_NAME_REPLY_EXISTS:
- app = RapidApp(bus, '/', config.DBUS_NAME, focal_length=focal_length,
- auto_detect=auto_detect, device_location=device_location)
- else:
- # this application is already running
- print "Rapid Photo Downloader is already running"
- object = bus.get_object (config.DBUS_NAME, "/")
- app = dbus.Interface (object, config.DBUS_NAME)
-
- app.start()
-
-if __name__ == "__main__":
- start()