diff options
Diffstat (limited to 'rapid/preferencesdialog.py')
| -rw-r--r-- | rapid/preferencesdialog.py | 1583 |
1 files changed, 1583 insertions, 0 deletions
diff --git a/rapid/preferencesdialog.py b/rapid/preferencesdialog.py new file mode 100644 index 0000000..5ad257d --- /dev/null +++ b/rapid/preferencesdialog.py @@ -0,0 +1,1583 @@ +#!/usr/bin/python +# -*- coding: latin1 -*- + +### Copyright (C) 2007 - 2011 Damon Lynch <damonlynch@gmail.com> + +### This program is free software; you can redistribute it and/or modify +### it under the terms of the GNU General Public License as published by +### the Free Software Foundation; either version 2 of the License, or +### (at your option) any later version. + +### This program is distributed in the hope that it will be useful, +### but WITHOUT ANY WARRANTY; without even the implied warranty of +### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +### GNU General Public License for more details. + +### You should have received a copy of the GNU General Public License +### along with this program; if not, write to the Free Software +### Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +import datetime + +import gtk + +import multiprocessing +import logging +logger = multiprocessing.get_logger() + +import ValidatedEntry +import misc + +import config +import paths +import higdefaults as hd +import metadataphoto +import metadatavideo +import tableplusminus as tpm + +import utilities + +import generatename as gn +from generatenameconfig import * +import problemnotification as pn + +from prefsrapid import format_pref_list_for_pretty_print + +from gettext import gettext as _ + +class PrefError(Exception): + """ base class """ + def unpackList(self, l): + """ + Make the preferences presentable to the user + """ + + s = '' + for i in l: + if i <> ORDER_KEY: + s += "'" + i + "', " + return s[:-2] + + def __str__(self): + return self.msg + +class PrefKeyError(PrefError): + def __init__(self, error): + value = error[0] + expectedValues = self.unpackList(error[1]) + self.msg = "Preference key '%(key)s' is invalid.\nExpected one of %(value)s" % { + 'key': value, 'value': expectedValues} + + +class PrefValueInvalidError(PrefKeyError): + def __init__(self, error): + value = error[0] + self.msg = "Preference value '%(value)s' is invalid" % {'value': value} + +class PrefLengthError(PrefError): + def __init__(self, error): + self.msg = "These preferences are not well formed:" + "\n %s" % self.unpackList(error) + +class PrefValueKeyComboError(PrefError): + def __init__(self, error): + self.msg = error + + +def check_pref_valid(pref_defn, prefs, modulo=3): + """ + Checks to see if prefs are valid according to definition. + + prefs is a list of preferences. + pref_defn is a Dict specifying what is valid. + modulo is how many list elements are equivalent to one line of preferences. + + Returns True if prefs match with pref_defn, + else raises appropriate error. + """ + + if (len(prefs) % modulo <> 0) or not prefs: + raise PrefLengthError(prefs) + else: + for i in range(0, len(prefs), modulo): + _check_pref_valid(pref_defn, prefs[i:i+modulo]) + + return True + +def _check_pref_valid(pref_defn, prefs): + + key = prefs[0] + value = prefs[1] + + + if pref_defn.has_key(key): + + next_pref_defn = pref_defn[key] + + if value == None: + # value should never be None, at any time + raise PrefValueInvalidError((None, next_pref_defn)) + + if next_pref_defn and not value: + raise gn.PrefValueInvalidError((value, next_pref_defn)) + + if type(next_pref_defn) == type({}): + return _check_pref_valid(next_pref_defn, prefs[1:]) + else: + if type(next_pref_defn) == type([]): + result = value in next_pref_defn + if not result: + raise gn.PrefValueInvalidError((value, next_pref_defn)) + return True + elif not next_pref_defn: + return True + else: + result = next_pref_defn == value + if not result: + raise gn.PrefKeyValue((value, next_pref_defn)) + return True + else: + raise PrefKeyError((key, pref_defn[ORDER_KEY])) + + +def filter_subfolder_prefs(pref_list): + """ + Filters out extraneous preference choices + """ + prefs_changed = False + continue_check = True + while continue_check and pref_list: + continue_check = False + if pref_list[0] == SEPARATOR: + # subfolder preferences should not start with a / + pref_list = pref_list[3:] + prefs_changed = True + continue_check = True + elif pref_list[-3] == SEPARATOR: + # subfolder preferences should not end with a / + pref_list = pref_list[:-3] + continue_check = True + prefs_changed = True + else: + for i in range(0, len(pref_list) - 3, 3): + if pref_list[i] == SEPARATOR and pref_list[i+3] == SEPARATOR: + # subfolder preferences should not contain two /s side by side + continue_check = True + prefs_changed = True + # note we are messing with the contents of the pref list, + # must exit loop and try again + pref_list = pref_list[:i] + pref_list[i+3:] + break + + return (prefs_changed, pref_list) + +class Comboi18n(gtk.ComboBox): + """ very simple i18n version of the venerable combo box + with one column displayed to the user. + + This combo box has two columns: + 1. the first contains the actual value and is invisible + 2. the second contains the translation of the first column, and this is what + the users sees + """ + def __init__(self): + liststore = gtk.ListStore(str, str) + gtk.ComboBox.__init__(self, liststore) + cell = gtk.CellRendererText() + self.pack_start(cell, True) + self.add_attribute(cell, 'text', 1) + + def append_text(self, text): + model = self.get_model() + model.append((text, _(text))) + + def get_active_text(self): + model = self.get_model() + active = self.get_active() + if active < 0: + return None + return model[active][0] + +class PreferenceWidgets: + + def __init__(self, default_row, default_prefs, pref_defn_L0, pref_list): + self.default_row = default_row + self.default_prefs = default_prefs + self.pref_defn_L0 = pref_defn_L0 + self.pref_list = pref_list + + def _create_combo(self, choices): + combobox = Comboi18n() + for text in choices: + combobox.append_text(text) + return combobox + + def get_default_row(self): + """ + returns a list of default widgets + """ + return self.get_widgets_based_on_user_selection(self.default_row) + + def _get_pref_widgets(self, pref_definition, prefs, widgets): + key = prefs[0] + value = prefs[1] + + # supply a default value if the user has not yet chosen a value! + if not key: + key = pref_definition[ORDER_KEY][0] + + if not key in pref_definition: + raise gn.PrefKeyError((key, pref_definition.keys())) + + + list0 = pref_definition[ORDER_KEY] + + # the first widget will always be a combo box + widget0 = self._create_combo(list0) + widget0.set_active(list0.index(key)) + + widgets.append(widget0) + + if key == TEXT: + widget1 = gtk.Entry() + widget1.set_text(value) + + widgets.append(widget1) + widgets.append(None) + return + elif key in [SEPARATOR, JOB_CODE]: + widgets.append(None) + widgets.append(None) + return + else: + next_pref_definition = pref_definition[key] + if type(next_pref_definition) == type({}): + return self._get_pref_widgets(next_pref_definition, + prefs[1:], + widgets) + else: + if type(next_pref_definition) == type([]): + widget1 = self._create_combo(next_pref_definition) + if not value: + value = next_pref_definition[0] + try: + widget1.set_active(next_pref_definition.index(value)) + except: + raise gn.PrefValueInvalidError((value, next_pref_definition)) + + widgets.append(widget1) + else: + widgets.append(None) + + def _get_values_from_list(self): + for i in range(0, len(self.pref_list), 3): + yield (self.pref_list[i], self.pref_list[i+1], self.pref_list[i+2]) + + def get_widgets_based_on_prefs(self): + """ + Yields a list of widgets and their callbacks based on the users preferences. + + This list is equivalent to one row of preferences when presented to the + user in the Plus Minus Table. + """ + + for L0, L1, L2 in self._get_values_from_list(): + prefs = [L0, L1, L2] + widgets = [] + self._get_pref_widgets(self.pref_defn_L0, prefs, widgets) + yield widgets + + + def get_widgets_based_on_user_selection(self, selection): + """ + Returns a list of widgets and their callbacks based on what the user has selected. + + Selection is the values the user has chosen thus far in comboboxes. + It determines the contents of the widgets returned. + It should be a list of three values, with None for values not chosen. + For values which are None, the first value in the preferences + definition is chosen. + + """ + widgets = [] + + self._get_pref_widgets(self.pref_defn_L0, selection, widgets) + return widgets + + def check_prefs_for_validity(self): + """ + Checks preferences validity + """ + + #~ print logger.debug(dir(self)) + return check_pref_valid(self.pref_defn_L0, self.pref_list) + +class PhotoNamePrefs(PreferenceWidgets): + def __init__(self, pref_list): + PreferenceWidgets.__init__(self, + default_row = [FILENAME, NAME_EXTENSION, ORIGINAL_CASE], + default_prefs = [FILENAME, NAME_EXTENSION, ORIGINAL_CASE], + pref_defn_L0 = DICT_IMAGE_RENAME_L0, + pref_list = pref_list) + +class VideoNamePrefs(PreferenceWidgets): + def __init__(self, pref_list): + PreferenceWidgets.__init__(self, + default_row = [FILENAME, NAME_EXTENSION, ORIGINAL_CASE], + default_prefs = [FILENAME, NAME_EXTENSION, ORIGINAL_CASE], + pref_defn_L0 = DICT_VIDEO_RENAME_L0, + pref_list = pref_list) + + +class PhotoSubfolderPrefs(PreferenceWidgets): + def __init__(self, pref_list): + + PreferenceWidgets.__init__(self, + default_row = [DATE_TIME, IMAGE_DATE, LIST_DATE_TIME_L2[0]], + default_prefs = DEFAULT_SUBFOLDER_PREFS, + pref_defn_L0 = DICT_SUBFOLDER_L0, + pref_list = pref_list) + + def filter_preferences(self): + filtered, pref_list = filter_subfolder_prefs(self.pref_list) + if filtered: + self.pref_list = pref_list + + def check_prefs_for_validity(self): + """ + Checks subfolder preferences validity above and beyond image name checks. + + See parent method for full description. + + Subfolders have additional requirments to that of file names. + """ + v = PreferenceWidgets.check_prefs_for_validity(self) + if v: + # peform additional checks: + # 1. do not start with a separator + # 2. do not end with a separator + # 3. do not have two separators in a row + # these three rules will ensure something else other than a + # separator is specified + L1s = [] + for i in range(0, len(self.pref_list), 3): + L1s.append(self.pref_list[i]) + + if L1s[0] == SEPARATOR: + raise PrefValueKeyComboError(_("Subfolder preferences should not start with a %s") % os.sep) + elif L1s[-1] == SEPARATOR: + raise PrefValueKeyComboError(_("Subfolder preferences should not end with a %s") % os.sep) + else: + for i in range(len(L1s) - 1): + if L1s[i] == SEPARATOR and L1s[i+1] == SEPARATOR: + raise PrefValueKeyComboError(_("Subfolder preferences should not contain two %s one after the other") % os.sep) + return v + +class VideoSubfolderPrefs(PhotoSubfolderPrefs): + def __init__(self, pref_list): + PreferenceWidgets.__init__(self, + default_row = [DATE_TIME, VIDEO_DATE, LIST_DATE_TIME_L2[0]], + default_prefs = DEFAULT_VIDEO_SUBFOLDER_PREFS, + pref_defn_L0 = DICT_VIDEO_SUBFOLDER_L0, + pref_list = pref_list) + +class RemoveAllJobCodeDialog(gtk.Dialog): + def __init__(self, parent_window, post_choice_callback): + gtk.Dialog.__init__(self, _('Remove all Job Codes?'), None, + gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, + (gtk.STOCK_NO, gtk.RESPONSE_CANCEL, + gtk.STOCK_YES, gtk.RESPONSE_OK)) + + self.post_choice_callback = post_choice_callback + self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg')) + + prompt_hbox = gtk.HBox() + + icontheme = gtk.icon_theme_get_default() + icon = icontheme.load_icon('gtk-dialog-question', 36, gtk.ICON_LOOKUP_USE_BUILTIN) + if icon: + image = gtk.Image() + image.set_from_pixbuf(icon) + prompt_hbox.pack_start(image, False, False, padding = 6) + + prompt_label = gtk.Label(_('Should all Job Codes be removed?')) + prompt_label.set_line_wrap(True) + prompt_hbox.pack_start(prompt_label, False, False, padding=6) + + self.vbox.pack_start(prompt_hbox, padding=6) + + self.set_border_width(6) + self.set_has_separator(False) + + self.set_default_response(gtk.RESPONSE_OK) + + + self.set_transient_for(parent_window) + self.show_all() + + + self.connect('response', self.on_response) + + def on_response(self, device_dialog, response): + user_selected = response == gtk.RESPONSE_OK + self.post_choice_callback(self, user_selected) + +class PhotoRenameTable(tpm.TablePlusMinus): + + def __init__(self, preferencesdialog, adjust_scroll_window): + + tpm.TablePlusMinus.__init__(self, 1, 3) + self.preferencesdialog = preferencesdialog + self.adjust_scroll_window = adjust_scroll_window + if not hasattr(self, "error_title"): + self.error_title = _("Error in Photo Rename preferences") + + self.table_type = self.error_title[len("Error in "):] + self.i = 0 + + if adjust_scroll_window: + self.scroll_bar = self.adjust_scroll_window.get_vscrollbar() + #this next line does not work on early versions of pygtk :( + self.scroll_bar.connect('visibility-notify-event', self.scrollbar_visibility_change) + self.connect("size-request", self.size_adjustment) + self.connect("add", self.size_adjustment) + self.connect("remove", self.size_adjustment) + + # get scrollbar thickness from parent app scrollbar - very hackish, but what to do?? + self.bump = 16# self.preferencesdialog.parentApp.image_scrolledwindow.get_hscrollbar().allocation.height + self.have_vertical_scrollbar = False + + + self.get_preferencesdialog_prefs() + self.get_prefs_factory() + #~ self.prefs_factory.setDownloadStartTime(datetime.datetime.now()) + + try: + self.prefs_factory.check_prefs_for_validity() + + except (PrefValueInvalidError, PrefLengthError, + PrefValueKeyComboError, PrefKeyError), e: + + logger.error(self.error_title) + logger.error("Sorry, these preferences contain an error:") + logger.error(format_pref_list_for_pretty_print(self.prefs_factory.pref_list)) + + # the preferences were invalid + # reset them to their default + + self.pref_list = self.prefs_factory.default_prefs + self.get_prefs_factory() + self.update_parentapp_prefs() + + msg = "%s.\n" % e + msg += "Resetting to default values." + logger.error(msg) + + + misc.run_dialog(self.error_title, msg, + preferencesdialog, + gtk.MESSAGE_ERROR) + + for row in self.prefs_factory.get_widgets_based_on_prefs(): + self.append(row) + + def update_preferences(self): + pref_list = [] + for row in self.pm_rows: + for col in range(self.pm_no_columns): + widget = row[col] + if widget: + name = widget.get_name() + if name == 'GtkComboBox': + value = widget.get_active_text() + elif name == 'GtkEntry': + value = widget.get_text() + else: + logger.critical("Program error: Unknown preference widget!") + value = '' + else: + value = '' + pref_list.append(value) + + self.pref_list = pref_list + self.update_parentapp_prefs() + self.prefs_factory.pref_list = pref_list + self.update_example() + + + def scrollbar_visibility_change(self, widget, event): + if event.state == gtk.gdk.VISIBILITY_UNOBSCURED: + self.have_vertical_scrollbar = True + self.adjust_scroll_window.set_size_request(self.adjust_scroll_window.allocation.width + self.bump, -1) + + + def size_adjustment(self, widget, arg2): + """ + Adjust scrolledwindow width in preferences dialog to reflect width of image rename table + + The algorithm is complicated by the need to take into account the presence of a vertical scrollbar, + which might be added as the user adds more rows + + The pygtk code behaves inconsistently depending on the pygtk version + """ + + if self.adjust_scroll_window: + self.have_vertical_scrollbar = self.scroll_bar.allocation.width > 1 or self.have_vertical_scrollbar + if not self.have_vertical_scrollbar: + if self.allocation.width > self.adjust_scroll_window.allocation.width: + self.adjust_scroll_window.set_size_request(self.allocation.width, -1) + else: + if self.allocation.width > self.adjust_scroll_window.allocation.width - self.bump: + self.adjust_scroll_window.set_size_request(self.allocation.width + self.bump, -1) + self.bump = 0 + + def get_preferencesdialog_prefs(self): + self.pref_list = self.preferencesdialog.prefs.image_rename + + + def get_prefs_factory(self): + self.prefs_factory = PhotoNamePrefs(self.pref_list) + + def update_parentapp_prefs(self): + self.preferencesdialog.prefs.image_rename = self.pref_list + + def update_example_job_code(self): + job_code = self.preferencesdialog.prefs.get_sample_job_code() + if not job_code: + job_code = _('Job code') + #~ self.prefs_factory.setJobCode(job_code) + + def update_example(self): + self.preferencesdialog.update_image_rename_example() + + def get_default_row(self): + return self.prefs_factory.get_default_row() + + def on_combobox_changed(self, widget, row_position): + + for col in range(self.pm_no_columns): + if self.pm_rows[row_position][col] == widget: + break + selection = [] + for i in range(col + 1): + # ensure it is a combo box we are getting the value from + w = self.pm_rows[row_position][i] + name = w.get_name() + if name == 'GtkComboBox': + selection.append(w.get_active_text()) + else: + selection.append(w.get_text()) + + for i in range(col + 1, self.pm_no_columns): + selection.append('') + + if col <> (self.pm_no_columns - 1): + widgets = self.prefs_factory.get_widgets_based_on_user_selection(selection) + + for i in range(col + 1, self.pm_no_columns): + old_widget = self.pm_rows[row_position][i] + if old_widget: + self.remove(old_widget) + if old_widget in self.pm_callbacks: + del self.pm_callbacks[old_widget] + new_widget = widgets[i] + self.pm_rows[row_position][i] = new_widget + if new_widget: + self._create_callback(new_widget, row_position) + self.attach(new_widget, i, i+1, row_position, row_position + 1) + new_widget.show() + self.update_preferences() + + + def on_entry_changed(self, widget, row_position): + self.update_preferences() + + def on_row_added(self, row_position): + """ + Update preferences, as a row has been added + """ + self.update_preferences() + + # if this was the last row or 2nd to last row, and another has just been added, move vertical scrollbar down + if row_position in range(self.pm_no_rows - 3, self.pm_no_rows - 2): + adjustment = self.preferencesdialog.rename_scrolledwindow.get_vadjustment() + adjustment.set_value(adjustment.upper) + + + def on_row_deleted(self, row_position): + """ + Update preferences, as a row has been deleted + """ + self.update_preferences() + +class VideoRenameTable(PhotoRenameTable): + def __init__(self, preferencesdialog, adjust_scroll_window): + self.error_title = _("Error in Video Rename preferences") + PhotoRenameTable.__init__(self, preferencesdialog, adjust_scroll_window) + + def get_preferencesdialog_prefs(self): + self.pref_list = self.preferencesdialog.prefs.video_rename + + def get_prefs_factory(self): + self.prefs_factory = VideoNamePrefs(self.pref_list) + + def update_parentapp_prefs(self): + self.preferencesdialog.prefs.video_rename = self.pref_list + + def update_example(self): + self.preferencesdialog.update_video_rename_example() + +class SubfolderTable(PhotoRenameTable): + """ + Table to display photo download subfolder preferences as part of preferences + dialog window. + """ + def __init__(self, preferencesdialog, adjust_scroll_window): + self.error_title = _("Error in Photo Download Subfolders preferences") + PhotoRenameTable.__init__(self, preferencesdialog, adjust_scroll_window) + + def get_preferencesdialog_prefs(self): + self.pref_list = self.preferencesdialog.prefs.subfolder + + def get_prefs_factory(self): + self.prefs_factory = PhotoSubfolderPrefs(self.pref_list) + + def update_parentapp_prefs(self): + self.preferencesdialog.prefs.subfolder = self.pref_list + + def update_example(self): + self.preferencesdialog.update_photo_download_folder_example() + +class VideoSubfolderTable(PhotoRenameTable): + def __init__(self, preferencesdialog, adjust_scroll_window): + self.error_title = _("Error in Video Download Subfolders preferences") + PhotoRenameTable.__init__(self, preferencesdialog, adjust_scroll_window) + + def get_preferencesdialog_prefs(self): + self.pref_list = self.preferencesdialog.prefs.video_subfolder + + def get_prefs_factory(self): + self.prefs_factory = VideoSubfolderPrefs(self.pref_list) + + def update_parentapp_prefs(self): + self.preferencesdialog.prefs.video_subfolder = self.pref_list + + def update_example(self): + self.preferencesdialog.update_video_download_folder_example() + +class RemoveAllJobCodeDialog(gtk.Dialog): + def __init__(self, parent_window, post_choice_callback): + gtk.Dialog.__init__(self, _('Remove all Job Codes?'), None, + gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, + (gtk.STOCK_NO, gtk.RESPONSE_CANCEL, + gtk.STOCK_YES, gtk.RESPONSE_OK)) + + self.post_choice_callback = post_choice_callback + self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg')) + + prompt_hbox = gtk.HBox() + + icontheme = gtk.icon_theme_get_default() + icon = icontheme.load_icon('gtk-dialog-question', 36, gtk.ICON_LOOKUP_USE_BUILTIN) + if icon: + image = gtk.Image() + image.set_from_pixbuf(icon) + prompt_hbox.pack_start(image, False, False, padding = 6) + + prompt_label = gtk.Label(_('Should all Job Codes be removed?')) + prompt_label.set_line_wrap(True) + prompt_hbox.pack_start(prompt_label, False, False, padding=6) + + self.vbox.pack_start(prompt_hbox, padding=6) + + self.set_border_width(6) + self.set_has_separator(False) + + self.set_default_response(gtk.RESPONSE_OK) + + self.set_transient_for(parent_window) + self.show_all() + + self.connect('response', self.on_response) + + def on_response(self, device_dialog, response): + user_selected = response == gtk.RESPONSE_OK + self.post_choice_callback(self, user_selected) + +class JobCodeDialog(gtk.Dialog): + """ Dialog prompting for a job code""" + + def __init__(self, parent_window, job_codes, default_job_code, post_job_code_entry_callback, entry_only): + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode + gtk.Dialog.__init__(self, _('Enter a Job Code'), None, + gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, + (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, + gtk.STOCK_OK, gtk.RESPONSE_OK)) + + + self.set_icon_from_file(paths.share_dir('glade3/rapid-photo-downloader.svg')) + self.post_job_code_entry_callback = post_job_code_entry_callback + + self.combobox = gtk.combo_box_entry_new_text() + for text in job_codes: + self.combobox.append_text(text) + + self.job_code_hbox = gtk.HBox(homogeneous = False) + + if len(job_codes) and not entry_only: + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode + task_label = gtk.Label(_('Enter a new Job Code, or select a previous one')) + else: + # Translators: for an explanation of what this means, see http://damonlynch.net/rapid/documentation/index.html#jobcode + task_label = gtk.Label(_('Enter a new Job Code')) + task_label.set_line_wrap(True) + task_hbox = gtk.HBox() + task_hbox.pack_start(task_label, False, False, padding=6) + + label = gtk.Label(_('Job Code:')) + self.job_code_hbox.pack_start(label, False, False, padding=6) + self.job_code_hbox.pack_start(self.combobox, True, True, padding=6) + + self.set_border_width(6) + self.set_has_separator(False) + + # make entry box have entry completion + self.entry = self.combobox.child + + completion = gtk.EntryCompletion() + completion.set_match_func(self.match_func) + completion.connect("match-selected", + self.on_completion_match) + completion.set_model(self.combobox.get_model()) + completion.set_text_column(0) + self.entry.set_completion(completion) + + # when user hits enter, close the dialog window + self.set_default_response(gtk.RESPONSE_OK) + self.entry.set_activates_default(True) + + if default_job_code: + self.entry.set_text(default_job_code) + + self.vbox.pack_start(task_hbox, False, False, padding = 6) + self.vbox.pack_start(self.job_code_hbox, False, False, padding=12) + + self.set_transient_for(parent_window) + self.show_all() + self.connect('response', self.on_job_code_resp) + + def match_func(self, completion, key, iter): + model = completion.get_model() + return model[iter][0].lower().startswith(self.entry.get_text().lower()) + + def on_completion_match(self, completion, model, iter): + self.entry.set_text(model[iter][0]) + self.entry.set_position(-1) + + def get_job_code(self): + return self.combobox.child.get_text() + + def on_job_code_resp(self, jc_dialog, response): + user_chose_code = False + if response == gtk.RESPONSE_OK: + user_chose_code = True + logger.debug("Job Code entered") + else: + logger.debug("Job Code not entered") + self.post_job_code_entry_callback(self, user_chose_code, self.get_job_code()) + + +class PreferencesDialog(gtk.Window): + """ + Dialog window to show Rapid Photo Downloader preferences. + + Is tightly integrated into main Rapid Photo Downloader window, i.e. + directly access members in class RapidApp. + """ + + def __init__(self, rapidapp): + + self.builder = gtk.Builder() + self.builder.add_from_file(paths.share_dir("glade3/prefs.ui")) + self.builder.connect_signals(self) + + self.dialog = self.preferencesdialog + self.widget = self.dialog + self.dialog.set_transient_for(rapidapp.rapidapp) + self.prefs = rapidapp.prefs + + rapidapp.preferences_dialog_displayed = True + + self.rapidapp = rapidapp + + self._setup_tab_selector() + + self._setup_control_spacing() + + if metadatavideo.DOWNLOAD_VIDEO: + self.file_types = _("photos and videos") + else: + self.file_types = _("photos") + + # get example photo and video data + #~ try: + #~ w = workers.firstWorkerReadyToDownload() + #~ mediaFile = w.firstImage() + #~ self.sample_image_name = mediaFile.name + #~ # assume the metadata is already read + #~ self.sample_image = mediaFile.metadata + #~ except: + self.sample_image = metadataphoto.DummyMetaData() + self.sample_image_name = 'IMG_0524.CR2' + + if not metadatavideo.DOWNLOAD_VIDEO: + self.sample_video = None + self.sample_video_name = '' + else: + #~ try: + #~ mediaFile = w.firstVideo() + #~ self.sample_video_name = mediaFile.name + #~ self.sample_video = mediaFile.metadata + #~ self.videoFallBackDate = mediaFile.modificationTime + #~ except: + self.sample_video = metadatavideo.DummyMetaData() + self.sample_video_name = 'MVI_1379.MOV' + #~ self.videoFallBackDate = datetime.datetime.now() + + + # setup tabs + self._setup_photo_download_folder_tab() + self._setup_image_rename_tab() + self._setup_video_download_folder_tab() + self._setup_video_rename_tab() + self._setup_rename_options_tab() + self._setup_job_code_tab() + self._setup_device_tab() + self._setup_backup_tab() + self._setup_miscellaneous_tab() + self._setup_error_tab() + + if not metadatavideo.DOWNLOAD_VIDEO: + self.disable_video_controls() + + self.dialog.realize() + + #set the width of the left column for selecting values + #note: this must be called after self.dialog.realize(), or else the width calculation will fail + width_of_widest_sel_row = self.treeview.get_background_area(1, self.treeview_column)[2] + self.scrolled_window.set_size_request(width_of_widest_sel_row + 2, -1) + + #set the minimum width of the scolled window holding the photo rename table + if self.rename_scrolledwindow.get_vscrollbar(): + extra = self.rename_scrolledwindow.get_vscrollbar().allocation.width + 10 + else: + extra = 10 + self.rename_scrolledwindow.set_size_request(self.rename_table.allocation.width + extra, -1) + + self.dialog.show() + + def __getattr__(self, key): + """Allow builder widgets to be accessed as self.widgetname + """ + widget = self.builder.get_object(key) + if widget: # cache lookups + setattr(self, key, widget) + return widget + raise AttributeError(key) + + def on_preferencesdialog_destroy(self, widget): + """ Delete variables from memory that cause a file descriptor to be created on a mounted media""" + del self.sample_image, self.rename_table.prefs_factory, self.subfolder_table.prefs_factory + + def _setup_tab_selector(self): + self.notebook.set_show_tabs(0) + self.model = gtk.ListStore(type("")) + column = gtk.TreeViewColumn() + rentext = gtk.CellRendererText() + column.pack_start(rentext, expand=0) + column.set_attributes(rentext, text=0) + self.treeview_column = column + self.treeview.append_column(column) + self.treeview.props.model = self.model + for c in self.notebook.get_children(): + label = self.notebook.get_tab_label(c).get_text() + if not label.startswith("_"): + self.model.append( (label,) ) + + + # select the first value in the list store + self.treeview.set_cursor(0,column) + + def on_download_folder_filechooser_button_selection_changed(self, widget): + self.prefs.download_folder = widget.get_current_folder() + self.update_photo_download_folder_example() + + def on_video_download_folder_filechooser_button_selection_changed(self, widget): + self.prefs.video_download_folder = widget.get_current_folder() + self.update_video_download_folder_example() + + def on_backup_folder_filechooser_button_selection_changed(self, widget): + self.prefs.backup_location = widget.get_current_folder() + self.update_backup_example() + + def on_device_location_filechooser_button_selection_changed(self, widget): + self.prefs.device_location = widget.get_current_folder() + + def _setup_control_spacing(self): + """ + set spacing of some but not all controls + """ + + self._setup_table_spacing(self.download_folder_table) + self._setup_table_spacing(self.video_download_folder_table) + self.download_folder_table.set_row_spacing(2, + hd.VERTICAL_CONTROL_SPACE) + self.video_download_folder_table.set_row_spacing(2, + hd.VERTICAL_CONTROL_SPACE) + self._setup_table_spacing(self.rename_example_table) + self._setup_table_spacing(self.video_rename_example_table) + self.devices_table.set_col_spacing(0, hd.NESTED_CONTROLS_SPACE) + self.automation_table.set_col_spacing(0, hd.NESTED_CONTROLS_SPACE) + + self._setup_table_spacing(self.backup_table) + self.backup_table.set_col_spacing(1, hd.NESTED_CONTROLS_SPACE) + self.backup_table.set_col_spacing(2, hd.CONTROL_LABEL_SPACE) + self._setup_table_spacing(self.compatibility_table) + self.compatibility_table.set_row_spacing(0, + hd.VERTICAL_CONTROL_LABEL_SPACE) + self._setup_table_spacing(self.error_table) + + + def _setup_table_spacing(self, table): + table.set_col_spacing(0, hd.NESTED_CONTROLS_SPACE) + table.set_col_spacing(1, hd.CONTROL_LABEL_SPACE) + + def _setup_subfolder_table(self): + self.subfolder_table = SubfolderTable(self, None) + self.subfolder_vbox.pack_start(self.subfolder_table) + self.subfolder_table.show_all() + + def _setup_video_subfolder_table(self): + self.video_subfolder_table = VideoSubfolderTable(self, None) + self.video_subfolder_vbox.pack_start(self.video_subfolder_table) + self.video_subfolder_table.show_all() + + def _setup_photo_download_folder_tab(self): + self.download_folder_filechooser_button = gtk.FileChooserButton( + _("Select a folder to download photos to")) + self.download_folder_filechooser_button.set_current_folder( + self.prefs.download_folder) + self.download_folder_filechooser_button.set_action( + gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) + self.download_folder_filechooser_button.connect("selection-changed", + self.on_download_folder_filechooser_button_selection_changed) + + self.download_folder_table.attach( + self.download_folder_filechooser_button, + 2, 3, 2, 3, yoptions = gtk.SHRINK) + self.download_folder_filechooser_button.show() + + self._setup_subfolder_table() + self.update_photo_download_folder_example() + + def _setup_video_download_folder_tab(self): + self.video_download_folder_filechooser_button = gtk.FileChooserButton( + _("Select a folder to download videos to")) + self.video_download_folder_filechooser_button.set_current_folder( + self.prefs.video_download_folder) + self.video_download_folder_filechooser_button.set_action( + gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) + self.video_download_folder_filechooser_button.connect("selection-changed", + self.on_video_download_folder_filechooser_button_selection_changed) + + self.video_download_folder_table.attach( + self.video_download_folder_filechooser_button, + 2, 3, 2, 3, yoptions = gtk.SHRINK) + self.video_download_folder_filechooser_button.show() + self._setup_video_subfolder_table() + self.update_video_download_folder_example() + + def _setup_image_rename_tab(self): + + self.rename_table = PhotoRenameTable(self, self.rename_scrolledwindow) + self.rename_table_vbox.pack_start(self.rename_table) + self.rename_table.show_all() + self.original_name_label.set_markup("<i>%s</i>" % self.sample_image_name) + self.update_image_rename_example() + + def _setup_video_rename_tab(self): + + self.video_rename_table = VideoRenameTable(self, self.video_rename_scrolledwindow) + self.video_rename_table_vbox.pack_start(self.video_rename_table) + self.video_rename_table.show_all() + self.video_original_name_label.set_markup("<i>%s</i>" % self.sample_video_name) + self.update_video_rename_example() + + def _setup_rename_options_tab(self): + + # sequence numbers + self.downloads_today_entry = ValidatedEntry.ValidatedEntry(ValidatedEntry.bounded(ValidatedEntry.v_int, int, 0)) + self.stored_number_entry = ValidatedEntry.ValidatedEntry(ValidatedEntry.bounded(ValidatedEntry.v_int, int, 1)) + self.downloads_today_entry.connect('changed', self.on_downloads_today_entry_changed) + self.stored_number_entry.connect('changed', self.on_stored_number_entry_changed) + v = self.rapidapp.downloads_today_tracker.get_and_maybe_reset_downloads_today() + self.downloads_today_entry.set_text(str(v)) + # make the displayed value of stored sequence no 1 more than actual value + # so as not to confuse the user + self.stored_number_entry.set_text(str(self.prefs.stored_sequence_no+1)) + self.sequence_vbox.pack_start(self.downloads_today_entry, expand=True, fill=True) + self.sequence_vbox.pack_start(self.stored_number_entry, expand=False) + self.downloads_today_entry.show() + self.stored_number_entry.show() + hour, minute = self.rapidapp.downloads_today_tracker.get_day_start() + self.hour_spinbutton.set_value(float(hour)) + self.minute_spinbutton.set_value(float(minute)) + + self.synchronize_raw_jpg_checkbutton.set_active( + self.prefs.synchronize_raw_jpg) + + #compatibility + self.strip_characters_checkbutton.set_active( + self.prefs.strip_characters) + + def _setup_job_code_tab(self): + self.job_code_liststore = gtk.ListStore(str) + column = gtk.TreeViewColumn() + rentext = gtk.CellRendererText() + rentext.connect('edited', self.on_job_code_edited) + rentext .set_property('editable', True) + + column.pack_start(rentext, expand=0) + column.set_attributes(rentext, text=0) + self.job_code_treeview_column = column + self.job_code_treeview.append_column(column) + self.job_code_treeview.props.model = self.job_code_liststore + for code in self.prefs.job_codes: + self.job_code_liststore.append((code, )) + + # set multiple selections + self.job_code_treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE) + + self.remove_all_job_code_button.set_image(gtk.image_new_from_stock( + gtk.STOCK_CLEAR, + gtk.ICON_SIZE_BUTTON)) + def _setup_device_tab(self): + + self.device_location_filechooser_button = gtk.FileChooserButton( + _("Select a folder containing %(file_types)s") % {'file_types':self.file_types}) + self.device_location_filechooser_button.set_current_folder( + self.prefs.device_location) + self.device_location_filechooser_button.set_action( + gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) + + self.device_location_filechooser_button.connect("selection-changed", + self.on_device_location_filechooser_button_selection_changed) + + self.devices2_table.attach(self.device_location_filechooser_button, + 1, 2, 1, 2, xoptions = gtk.EXPAND|gtk.FILL, yoptions = gtk.SHRINK) + self.device_location_filechooser_button.show() + self.autodetect_device_checkbutton.set_active( + self.prefs.device_autodetection) + self.autodetect_psd_checkbutton.set_active( + self.prefs.device_autodetection_psd) + + self.update_device_controls() + + + def _setup_backup_tab(self): + self.backup_folder_filechooser_button = gtk.FileChooserButton( + _("Select a folder in which to backup %(file_types)s") % {'file_types':self.file_types}) + self.backup_folder_filechooser_button.set_current_folder( + self.prefs.backup_location) + self.backup_folder_filechooser_button.set_action( + gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) + self.backup_folder_filechooser_button.connect("selection-changed", + self.on_backup_folder_filechooser_button_selection_changed) + self.backup_table.attach(self.backup_folder_filechooser_button, + 3, 4, 8, 9, yoptions = gtk.SHRINK) + self.backup_folder_filechooser_button.show() + self.backup_identifier_entry.set_text(self.prefs.backup_identifier) + self.video_backup_identifier_entry.set_text(self.prefs.video_backup_identifier) + + #setup controls for manipulating sensitivity + self._backup_controls0 = [self.auto_detect_backup_checkbutton] + self._backup_controls1 = [self.backup_identifier_explanation_label, + self.backup_identifier_label, + self.backup_identifier_entry, + self.example_backup_path_label, + self.backup_example_label,] + self._backup_controls2 = [self.backup_location_label, + self.backup_folder_filechooser_button, + self.backup_location_explanation_label] + self._backup_controls = self._backup_controls0 + self._backup_controls1 + \ + self._backup_controls2 + + self._backup_video_controls = [self.video_backup_identifier_label, + self.video_backup_identifier_entry] + + #assign values to checkbuttons only when other controls + #have been setup, because their toggle signal is activated + #when a value is assigned + + self.backup_checkbutton.set_active(self.prefs.backup_images) + self.auto_detect_backup_checkbutton.set_active( + self.prefs.backup_device_autodetection) + self.update_backup_controls() + self.update_backup_example() + + def _setup_miscellaneous_tab(self): + self.auto_startup_checkbutton.set_active( + self.prefs.auto_download_at_startup) + self.auto_insertion_checkbutton.set_active( + self.prefs.auto_download_upon_device_insertion) + self.auto_unmount_checkbutton.set_active( + self.prefs.auto_unmount) + self.auto_exit_checkbutton.set_active( + self.prefs.auto_exit) + self.auto_exit_force_checkbutton.set_active( + self.prefs.auto_exit_force) + self.auto_delete_checkbutton.set_active( + self.prefs.auto_delete) + + self.update_misc_controls() + + + def _setup_error_tab(self): + if self.prefs.download_conflict_resolution == config.SKIP_DOWNLOAD: + self.skip_download_radiobutton.set_active(True) + else: + self.add_identifier_radiobutton.set_active(True) + + if self.prefs.backup_duplicate_overwrite: + self.backup_duplicate_overwrite_radiobutton.set_active(True) + else: + self.backup_duplicate_skip_radiobutton.set_active(True) + + + def update_example_file_name(self, display_table, rename_table, sample, sampleName, example_label, fallback_date = None): + problem = pn.Problem() + name = 'file.cr2' + #~ if hasattr(self, display_table): + #~ rename_table.update_example_job_code() + #~ rename_table.prefs_factory.initializeProblem(problem) + #~ name = rename_table.prefs_factory.generateNameUsingPreferences( + #~ sample, sampleName, + #~ self.prefs.strip_characters, sequencesPreliminary=False, fallback_date=fallback_date) + #~ else: + #~ name = '' + + # since this is markup, escape it + text = "<i>%s</i>" % utilities.escape(name) + + if problem.has_problem(): + text += "\n" + # Translators: please do not modify or leave out html formatting tags like <i> and <b>. These are used to format the text the users sees + text += _("<i><b>Warning:</b> There is insufficient metadata to fully generate the name. Please use other renaming options.</i>") + + example_label.set_markup(text) + + def update_image_rename_example(self): + """ + Displays example image name to the user + """ + self.update_example_file_name('rename_table', self.rename_table, self.sample_image, self.sample_image_name, self.new_name_label) + + + def update_video_rename_example(self): + """ + Displays example video name to the user + """ + self.update_example_file_name('video_rename_table', self.video_rename_table, self.sample_video, self.sample_video_name, self.video_new_name_label) + + def update_download_folder_example(self, display_table, subfolder_table, download_folder, sample, sampleName, example_download_path_label, subfolder_warning_label): + """ + Displays example subfolder name(s) to the user + """ + + problem = pn.Problem() + #~ if hasattr(self, display_table): + #~ subfolder_table.update_example_job_code() + #~ subfolder_table.update_example_job_code() + #~ subfolder_table.prefs_factory.initializeProblem(problem) + #~ path = subfolder_table.prefs_factory.generateNameUsingPreferences( + #~ sample, sampleName, + #~ self.prefs.strip_characters, fallback_date = fallback_date) + #~ else: + #~ path = '' + + path = 'sample' + + text = os.path.join(download_folder, path) + # since this is markup, escape it + path = utilities.escape(text) + if problem.has_problem(): + warning = _("<i><b>Warning:</b> There is insufficient metadata to fully generate subfolders. Please use other subfolder naming options.</i>" ) + else: + warning = "" + # Translators: you should not modify or leave out the %s. This is a code used by the programming language python to insert a value that thes user will see + example_download_path_label.set_markup(_("<i>Example: %s</i>") % text) + subfolder_warning_label.set_markup(warning) + + def update_photo_download_folder_example(self): + if hasattr(self, 'subfolder_table'): + self.update_download_folder_example('subfolder_table', self.subfolder_table, self.prefs.download_folder, self.sample_image, self.sample_image_name, self.example_photo_download_path_label, self.photo_subfolder_warning_label) + + def update_video_download_folder_example(self): + if hasattr(self, 'video_subfolder_table'): + self.update_download_folder_example('video_subfolder_table', self.video_subfolder_table, self.prefs.video_download_folder, self.sample_video, self.sample_video_name, self.example_video_download_path_label, self.video_subfolder_warning_label) + + def on_hour_spinbutton_value_changed(self, spinbutton): + hour = spinbutton.get_value_as_int() + minute = self.minute_spinbutton.get_value_as_int() + self.rapidapp.downloads_today_tracker.set_day_start(hour, minute) + self.on_downloads_today_entry_changed(self.downloads_today_entry) + + def on_minute_spinbutton_value_changed(self, spinbutton): + hour = self.hour_spinbutton.get_value_as_int() + minute = spinbutton.get_value_as_int() + self.rapidapp.downloads_today_tracker.set_day_start(hour, minute) + self.on_downloads_today_entry_changed(self.downloads_today_entry) + + def on_downloads_today_entry_changed(self, entry): + # do not update value if a download is occurring - it will mess it up! + if self.rapidapp.download_is_occurring(): + logger.info("Downloads today value not updated, as a download is currently occurring") + else: + v = entry.get_text() + try: + v = int(v) + except: + v = 0 + if v < 0: + v = 0 + self.rapidapp.downloads_today_tracker.reset_downloads_today(v) + self.rapidapp.refresh_downloads_today = True + self.update_image_rename_example() + + def on_stored_number_entry_changed(self, entry): + # do not update value if a download is occurring - it will mess it up! + if self.rapidapp.download_is_occurring(): + logger.info("Stored number value not updated, as a download is currently occurring") + else: + v = entry.get_text() + try: + # the displayed value of stored sequence no 1 more than actual value + # so as not to confuse the user + v = int(v) - 1 + except: + v = 0 + if v < 0: + v = 0 + self.prefs.stored_sequence_no = v + self.update_image_rename_example() + + def _update_subfolder_pref_on_error(self, new_pref_list): + self.prefs.subfolder = new_pref_list + + def _update_video_subfolder_pref_on_error(self, new_pref_list): + self.prefs.video_subfolder = new_pref_list + + + def check_subfolder_values_valid_on_exit(self, users_pref_list, update_pref_function, filetype, default_pref_list): + """ + Checks that the user has not entered in any inappropriate values + + If they have, filters out bad values and warns the user + """ + filtered, pref_list = filter_subfolder_prefs(users_pref_list) + if filtered: + logger.info("The %(filetype)s subfolder preferences had some unnecessary values removed.", {'filetype': filetype}) + if pref_list: + update_pref_function(pref_list) + else: + #Preferences list is now empty + msg = _("The %(filetype)s subfolder preferences entered are invalid and cannot be used.\nThey will be reset to their default values.") % {'filetype': filetype} + sys.stderr.write(msg + "\n") + misc.run_dialog(PROGRAM_NAME, msg) + update_pref_function(self.prefs.get_default(default_pref_list)) + + def on_preferencesdialog_response(self, dialog, arg): + if arg == gtk.RESPONSE_HELP: + webbrowser.open("http://www.damonlynch.net/rapid/documentation") + else: + # arg==gtk.RESPONSE_CLOSE, or the user hit the 'x' to close the window + self.prefs.backup_identifier = self.backup_identifier_entry.get_property("text") + self.prefs.video_backup_identifier = self.video_backup_identifier_entry.get_property("text") + + #check subfolder preferences for bad values + self.check_subfolder_values_valid_on_exit(self.prefs.subfolder, self._update_subfolder_pref_on_error, _("photo"), "subfolder") + self.check_subfolder_values_valid_on_exit(self.prefs.video_subfolder, self._update_video_subfolder_pref_on_error, _("video"), "video_subfolder") + + self.dialog.destroy() + self.rapidapp.preferences_dialog_displayed = False + self.rapidapp.post_preference_change() + + + + + def on_add_job_code_button_clicked(self, button): + j = JobCodeDialog(parent_window = self.dialog, + job_codes = self.prefs.job_codes, + default_job_code = None, + post_job_code_entry_callback=self.add_job_code, + entry_only = True) + + def add_job_code(self, dialog, user_chose_code, job_code): + dialog.destroy() + if user_chose_code: + if job_code and job_code not in self.prefs.job_codes: + self.job_code_liststore.prepend((job_code, )) + self.update_job_codes() + selection = self.job_code_treeview.get_selection() + selection.unselect_all() + selection.select_path((0, )) + #scroll to the top + adjustment = self.job_code_scrolledwindow.get_vadjustment() + adjustment.set_value(adjustment.lower) + + def on_remove_job_code_button_clicked(self, button): + """ remove selected job codes (can be multiple selection)""" + selection = self.job_code_treeview.get_selection() + model, selected = selection.get_selected_rows() + iters = [model.get_iter(path) for path in selected] + # only delete if a jobe code is selected + if iters: + no = len(iters) + path = None + for i in range(0, no): + iter = iters[i] + if i == no - 1: + path = model.get_path(iter) + model.remove(iter) + + # now that we removed the selection, play nice with + # the user and select the next item + selection.select_path(path) + + # if there was no selection that meant the user + # removed the last entry, so we try to select the + # last item + if not selection.path_is_selected(path): + row = path[0]-1 + # test case for empty lists + if row >= 0: + selection.select_path((row,)) + + self.update_job_codes() + self.update_image_rename_example() + self.update_video_rename_example() + self.update_photo_download_folder_example() + self.update_video_download_folder_example() + + def on_remove_all_job_code_button_clicked(self, button): + j = RemoveAllJobCodeDialog(self.dialog, self.remove_all_job_code) + + def remove_all_job_code(self, dialog, user_selected): + dialog.destroy() + if user_selected: + self.job_code_liststore.clear() + self.update_job_codes() + self.update_image_rename_example() + self.update_video_rename_example() + self.update_photo_download_folder_example() + self.update_video_download_folder_example() + + def on_job_code_edited(self, widget, path, new_text): + iter = self.job_code_liststore.get_iter(path) + self.job_code_liststore.set_value(iter, 0, new_text) + self.update_job_codes() + self.update_image_rename_example() + self.update_video_rename_example() + self.update_photo_download_folder_example() + self.update_video_download_folder_example() + + def update_job_codes(self): + """ update preferences with list of job codes""" + job_codes = [] + for row in self.job_code_liststore: + job_codes.append(row[0]) + self.prefs.job_codes = job_codes + + def on_auto_startup_checkbutton_toggled(self, checkbutton): + self.prefs.auto_download_at_startup = checkbutton.get_active() + + def on_auto_insertion_checkbutton_toggled(self, checkbutton): + self.prefs.auto_download_upon_device_insertion = checkbutton.get_active() + + def on_auto_unmount_checkbutton_toggled(self, checkbutton): + self.prefs.auto_unmount = checkbutton.get_active() + + + def on_auto_delete_checkbutton_toggled(self, checkbutton): + self.prefs.auto_delete = checkbutton.get_active() + + def on_auto_exit_checkbutton_toggled(self, checkbutton): + active = checkbutton.get_active() + self.prefs.auto_exit = active + if not active: + self.prefs.auto_exit_force = False + self.auto_exit_force_checkbutton.set_active(False) + self.update_misc_controls() + + def on_auto_exit_force_checkbutton_toggled(self, checkbutton): + self.prefs.auto_exit_force = checkbutton.get_active() + + def on_scan_metadata_checkbutton_toggled(self, checkbutton): + self.prefs.enable_previews = checkbutton.get_active() + + def on_autodetect_device_checkbutton_toggled(self, checkbutton): + self.prefs.device_autodetection = checkbutton.get_active() + self.update_device_controls() + + def on_autodetect_psd_checkbutton_toggled(self, checkbutton): + self.prefs.device_autodetection_psd = checkbutton.get_active() + + def on_backup_duplicate_overwrite_radiobutton_toggled(self, widget): + self.prefs.backup_duplicate_overwrite = widget.get_active() + + def on_backup_duplicate_skip_radiobutton_toggled(self, widget): + self.prefs.backup_duplicate_overwrite = not widget.get_active() + + def on_treeview_cursor_changed(self, tree): + path, column = tree.get_cursor() + self.notebook.set_current_page(path[0]) + + def on_synchronize_raw_jpg_checkbutton_toggled(self, check_button): + self.prefs.synchronize_raw_jpg = check_button.get_active() + + def on_strip_characters_checkbutton_toggled(self, check_button): + self.prefs.strip_characters = check_button.get_active() + self.update_image_rename_example() + self.update_photo_download_folder_example() + self.update_video_download_folder_example() + + def on_add_identifier_radiobutton_toggled(self, widget): + if widget.get_active(): + self.prefs.download_conflict_resolution = config.ADD_UNIQUE_IDENTIFIER + else: + self.prefs.download_conflict_resolution = config.SKIP_DOWNLOAD + + + def update_device_controls(self): + """ + Sets sensitivity of image device controls + """ + controls = [self.device_location_explanation_label, + self.device_location_label, + self.device_location_filechooser_button] + + if self.prefs.device_autodetection: + for c in controls: + c.set_sensitive(False) + self.autodetect_psd_checkbutton.set_sensitive(True) + self.autodetect_image_devices_label.set_sensitive(True) + else: + for c in controls: + c.set_sensitive(True) + self.autodetect_psd_checkbutton.set_sensitive(False) + self.autodetect_image_devices_label.set_sensitive(False) + + def update_misc_controls(self): + """ + Sets sensitivity of miscillaneous controls + """ + + self.auto_exit_force_checkbutton.set_sensitive(self.prefs.auto_exit) + + + def update_backup_controls(self): + """ + Sets sensitivity of backup related widgets + """ + + if not self.backup_checkbutton.get_active(): + for c in self._backup_controls + self._backup_video_controls: + c.set_sensitive(False) + + else: + for c in self._backup_controls0: + c.set_sensitive(True) + self.update_backup_controls_auto() + + def update_backup_controls_auto(self): + """ + Sets sensitivity of subset of backup related widgets + """ + + if self.auto_detect_backup_checkbutton.get_active(): + for c in self._backup_controls1: + c.set_sensitive(True) + for c in self._backup_controls2: + c.set_sensitive(False) + for c in self._backup_video_controls: + c.set_sensitive(False) + if metadatavideo.DOWNLOAD_VIDEO: + for c in self._backup_video_controls: + c.set_sensitive(True) + else: + for c in self._backup_controls1: + c.set_sensitive(False) + for c in self._backup_controls2: + c.set_sensitive(True) + if metadatavideo.DOWNLOAD_VIDEO: + for c in self._backup_video_controls: + c.set_sensitive(False) + + def disable_video_controls(self): + """ + Disables video preferences if video downloading is disabled + (probably because the appropriate libraries to enable + video metadata extraction are not installed) + """ + controls = [self.example_video_filename_label, + self.original_video_filename_label, + self.new_video_filename_label, + self.video_new_name_label, + self.video_original_name_label, + self.video_rename_scrolledwindow, + self.video_folders_hbox, + self.video_backup_identifier_label, + self.video_backup_identifier_entry + ] + for c in controls: + c.set_sensitive(False) + + self.videos_cannot_be_downloaded_label.show() + self.folder_videos_cannot_be_downloaded_label.show() + self.folder_videos_cannot_be_downloaded_hbox.show() + + def on_auto_detect_backup_checkbutton_toggled(self, widget): + self.prefs.backup_device_autodetection = widget.get_active() + self.update_backup_controls_auto() + + def on_backup_checkbutton_toggled(self, widget): + self.prefs.backup_images = self.backup_checkbutton.get_active() + self.update_backup_controls() + + def on_backup_identifier_entry_changed(self, widget): + self.update_backup_example() + #~ self.prefs. + + def on_video_backup_identifier_entry_changed(self, widget): + self.update_backup_example() + + def on_backup_scan_folder_on_entry_changed(self, widget): + self.update_backup_example() + + def update_backup_example(self): + # Translators: this value is used as an example device when automatic backup device detection is enabled. You should translate this. + drive1 = os.path.join(config.MEDIA_LOCATION, _("externaldrive1")) + # Translators: this value is used as an example device when automatic backup device detection is enabled. You should translate this. + drive2 = os.path.join(config.MEDIA_LOCATION, _("externaldrive2")) + + path = os.path.join(drive1, self.backup_identifier_entry.get_text()) + path2 = os.path.join(drive2, self.backup_identifier_entry.get_text()) + path3 = os.path.join(drive2, self.video_backup_identifier_entry.get_text()) + path = utilities.escape(path) + path2 = utilities.escape(path2) + path3 = utilities.escape(path3) + if metadatavideo.DOWNLOAD_VIDEO: + example = "<i>%s</i>\n<i>%s</i>\n<i>%s</i>" % (path, path2, path3) + else: + example = "<i>%s</i>\n<i>%s</i>" % (path, path2) + self.example_backup_path_label.set_markup(example) |