~dlynch3/rapid/trunk

#!/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)