def __init__(self, dbstate, uistate, clicked):
self.clicked_func = clicked
self.filter_src_id = BasicEntry()
self.filter_src_title = BasicEntry()
self.filter_src_author = BasicEntry()
self.filter_src_abbr = BasicEntry()
self.filter_src_pub = BasicEntry()
self.filter_src_note = BasicEntry()
self.filter_id = gtk.Entry()
self.filter_page = gtk.Entry()
self.filter_date = DateEntry(uistate, [])
self.filter_conf = gtk.ComboBox()
model = gtk.ListStore(str)
for conf_value in sorted(confidence.keys()):
model.append((confidence[conf_value], ))
self.filter_conf.set_model(model)
self.filter_conf.set_active(2) # gen.lib.Citation.CONF_NORMAL
self.filter_note = gtk.Entry()
self.filter_regex = gtk.CheckButton(_('Use regular expressions'))
self.generic = gtk.ComboBox()
SidebarFilter.__init__(self, dbstate, uistate, "Citation")
def create_widgets(self):
# Item selection
self.select_items = Label(self.top,
text='Select the items to download:')
self.select_items.grid(row=0, sticky=W)
# [x] Download profile pictures
self.propics_checkbox = CheckBox(self.top,
on_changed=self.refresh_size,
text='Download profile pictures')
self.propics_checkbox.grid(row=1, sticky=W)
# [x] Download photos
self.photos_checkbox = CheckBox(self.top,
on_changed=self.refresh_size,
text='Download photos')
self.photos_checkbox.grid(row=2, sticky=W)
# [x] Download documents
self.docs_checkbox = CheckBox(self.top,
on_changed=self.refresh_size,
text='Download documents')
self.docs_checkbox.grid(row=3, sticky=W)
# Extra filters when downloading the selected items
self.select_extra = Label(self.top, text='Select extra filters:')
self.select_extra.grid(row=4, sticky=W)
# Only documents smaller than a given size (in MB)
self.only_smaller_frame = Frame(self.top)
self.only_smaller_frame.grid(row=5, sticky=W)
self.only_smaller_checkbox = CheckBox(
self.only_smaller_frame,
on_changed=self.refresh_size,
text='Only download documents smaller than')
self.only_smaller_checkbox.grid(row=0, column=0, sticky=W)
self.only_smaller_entry = Entry(self.only_smaller_frame, width=6)
self.only_smaller_entry.insert(0, '2') # 2MB default
self.only_smaller_entry.grid(row=0, column=1, sticky=W)
self.only_smaller_units = Label(self.only_smaller_frame, text='MB')
self.only_smaller_units.grid(row=0, column=2, sticky=W)
# Do NOT download media before a given date
self.skip_before_frame = Frame(self.top)
self.skip_before_frame.grid(row=6, sticky=W)
self.skip_before_checkbox = CheckBox(
self.skip_before_frame,
on_changed=self.refresh_size,
text='Do not download media before:')
self.skip_before_checkbox.grid(row=0, column=0, sticky=W)
self.skip_before_date = DateEntry(self.skip_before_frame)
self.skip_before_date.grid(row=0, column=1, sticky=W)
# Do NOT download media after a given date
self.skip_after_frame = Frame(self.top)
self.skip_after_frame.grid(row=7, sticky=W)
self.skip_after_checkbox = CheckBox(
self.skip_after_frame,
on_changed=self.refresh_size,
text='Do not download media after:')
self.skip_after_checkbox.grid(row=0, column=0, sticky=W)
self.skip_after_date = DateEntry(self.skip_after_frame)
self.skip_after_date.grid(row=0, column=1, sticky=W)
# Label showing the estimated download size (size_calculator(**result))
self.estimated_size = Label(self.top)
self.estimated_size.grid(row=8, sticky=W)
# Frame showing the cancel and OK buttons
self.cancel_ok_frame = Frame(self.top)
self.cancel_ok_frame.grid(row=9, sticky=EW)
self.top.columnconfigure(0, weight=1)
self.cancel_button = Button(self.cancel_ok_frame,
text='Cancel',
command=self.cancel)
self.cancel_button.grid(row=0, column=0, sticky=W)
self.ok_button = Button(self.cancel_ok_frame,
text='Accept',
command=self.accept)
self.ok_button.grid(row=0, column=1, sticky=E)
def __init__(self, namespace, dbstate, uistate, track, filterdb, val,
label, update, filter_name):
ManagedWindow.ManagedWindow.__init__(self, uistate, track, EditRule)
self.width_key = "interface.edit-rule-width"
self.height_key = "interface.edit-rule-height"
self.namespace = namespace
self.dbstate = dbstate
self.db = dbstate.db
self.filterdb = filterdb
self.update_rule = update
self.filter_name = filter_name
self.active_rule = val
self.define_glade('rule_editor', const.RULE_GLADE)
self.set_window(self.get_widget('rule_editor'),
self.get_widget('rule_editor_title'),label)
self.window.hide()
self.valuebox = self.get_widget('valuebox')
self.rname = self.get_widget('ruletree')
self.rule_name = self.get_widget('rulename')
self.notebook = gtk.Notebook()
self.notebook.set_show_tabs(0)
self.notebook.set_show_border(0)
self.notebook.show()
self.valuebox.add(self.notebook)
self.page_num = 0
self.page = []
self.class2page = {}
the_map = {}
if self.namespace == 'Person':
class_list = Rules.Person.editor_rule_list
elif self.namespace == 'Family':
class_list = Rules.Family.editor_rule_list
elif self.namespace == 'Event':
class_list = Rules.Event.editor_rule_list
elif self.namespace == 'Source':
class_list = Rules.Source.editor_rule_list
elif self.namespace == 'Citation':
class_list = Rules.Citation.editor_rule_list
elif self.namespace == 'Place':
class_list = Rules.Place.editor_rule_list
elif self.namespace == 'MediaObject':
class_list = Rules.MediaObject.editor_rule_list
elif self.namespace == 'Repository':
class_list = Rules.Repository.editor_rule_list
elif self.namespace == 'Note':
class_list = Rules.Note.editor_rule_list
for class_obj in class_list:
arglist = class_obj.labels
vallist = []
tlist = []
pos = 0
l2 = gtk.Label(class_obj.name)
l2.set_alignment(0, 0.5)
l2.show()
c = gtk.TreeView()
c.set_data('d', pos)
c.show()
the_map[class_obj] = c
# Only add a table with parameters if there are any parameters
if arglist:
table = gtk.Table(3, len(arglist))
else:
table = gtk.Table(1, 1)
table.set_border_width(6)
table.set_col_spacings(6)
table.set_row_spacings(6)
table.show()
for v in arglist:
l = gtk.Label(v)
l.set_alignment(1, 0.5)
l.show()
if v == _('Place:'):
t = MyPlaces([])
elif v in [_('Reference count:'),
_('Number of instances:')
]:
t = MyInteger(0, 999)
elif v == _('Reference count must be:'):
t = MyLesserEqualGreater()
elif v == _('Number must be:'):
t = MyLesserEqualGreater(2)
elif v == _('Number of generations:'):
t = MyInteger(1, 32)
elif v == _('ID:'):
t = MyID(self.dbstate, self.uistate, self.track,
self.namespace)
elif v == _('Source ID:'):
t = MySource(self.dbstate, self.uistate, self.track)
elif v == _('Filter name:'):
t = MyFilters(self.filterdb.get_filters(self.namespace),
self.filter_name)
# filters of another namespace, name may be same as caller!
elif v == _('Person filter name:'):
t = MyFilters(self.filterdb.get_filters('Person'))
elif v == _('Event filter name:'):
t = MyFilters(self.filterdb.get_filters('Event'))
elif v == _('Source filter name:'):
t = MyFilters(self.filterdb.get_filters('Source'))
elif v == _('Repository filter name:'):
t = MyFilters(self.filterdb.get_filters('Repository'))
elif v == _('Place filter name:'):
t = MyFilters(self.filterdb.get_filters('Place'))
elif v in _name2typeclass:
additional = None
if v == _('Personal event:'):
additional = self.db.get_person_event_types()
elif v == _('Family event:'):
additional = self.db.get_family_event_types()
elif v == _('Event type:'):
additional = (self.db.get_person_event_types() +
self.db.get_family_event_types())
elif v == _('Personal attribute:'):
additional = self.db.get_person_attribute_types()
elif v == _('Family attribute:'):
additional = self.db.get_family_attribute_types()
elif v == _('Media attribute:'):
additional = self.db.get_media_attribute_types()
elif v == _('Relationship type:'):
additional = self.db.get_family_relation_types()
elif v == _('Note type:'):
additional = self.db.get_note_types()
elif v == _('Name type:'):
additional = self.db.get_name_types()
elif v == _('Surname origin type:'):
additional = self.db.get_origin_types()
t = MySelect(_name2typeclass[v], additional)
elif v == _('Inclusive:'):
t = MyBoolean(_('Include original person'))
elif v == _('Case sensitive:'):
t = MyBoolean(_('Use exact case of letters'))
elif v == _('Regular-Expression matching:'):
t = MyBoolean(_('Use regular expression'))
elif v == _('Include Family events:'):
t = MyBoolean(_('Also family events where person is '
'wife/husband'))
elif v == _('Primary Role:'):
t = MyBoolean(_('Only include primary participants'))
elif v == _('Tag:'):
taglist = ['']
taglist = taglist + [tag.get_name() for tag in dbstate.db.iter_tags()]
t = MyList(taglist, taglist)
elif v == _('Confidence level:'):
t = MyList(map(str, range(5)),
[Utils.confidence[i] for i in range(5)])
elif v == _('Date:'):
t = DateEntry(self.uistate, self.track)
elif v == _('Day of Week:'):
days_of_week = long_days[2:] + long_days[1:2]
t = MyList(map(str, range(7)), days_of_week)
else:
t = MyEntry()
tlist.append(t)
table.attach(l, 1, 2, pos, pos+1, gtk.FILL, 0, 5, 5)
table.attach(t, 2, 3, pos, pos+1, gtk.EXPAND|gtk.FILL, 0, 5, 5)
pos += 1
use_regex = None
if class_obj.allow_regex:
use_regex = gtk.CheckButton(_('Use regular expressions'))
tip = _('Interpret the contents of string fields as regular '
'expressions.\n'
'A decimal point will match any character. '
'A question mark will match zero or one occurences '
'of the previous character or group. '
'An asterisk will match zero or more occurences. '
'A plus sign will match one or more occurences. '
'Use parentheses to group expressions. '
'Specify alternatives using a vertical bar. '
'A caret will match the start of a line. '
'A dollar sign will match the end of a line.')
use_regex.set_tooltip_text(tip)
table.attach(use_regex, 2, 3, pos, pos+1, gtk.FILL, 0, 5, 5)
self.page.append((class_obj, vallist, tlist, use_regex))
# put the table into a scrollable area:
scrolled_win = gtk.ScrolledWindow()
scrolled_win.add_with_viewport(table)
scrolled_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_win.show()
self.notebook.append_page(scrolled_win, gtk.Label(class_obj.name))
self.class2page[class_obj] = self.page_num
self.page_num = self.page_num + 1
self.page_num = 0
self.store = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
self.selection = self.rname.get_selection()
col = gtk.TreeViewColumn(_('Rule Name'), gtk.CellRendererText(),
text=0)
self.rname.append_column(col)
self.rname.set_model(self.store)
prev = None
last_top = None
top_level = {}
top_node = {}
#
# If editing a rule, get the name so that we can select it later
#
sel_node = None
if self.active_rule is not None:
self.sel_class = self.active_rule.__class__
else:
self.sel_class = None
keys = sorted(the_map, by_rule_name, reverse=True)
catlist = sorted(set(class_obj.category for class_obj in keys))
for category in catlist:
top_node[category] = self.store.insert_after(None, last_top)
top_level[category] = []
last_top = top_node[category]
self.store.set(last_top, 0, category, 1, None)
for class_obj in keys:
category = class_obj.category
top_level[category].append(class_obj.name)
node = self.store.insert_after(top_node[category], prev)
self.store.set(node, 0, class_obj.name, 1, class_obj)
# if this is an edit rule, save the node
if class_obj == self.sel_class:
sel_node = (top_node[category], node)
if sel_node:
self.select_iter(sel_node)
page = self.class2page[self.active_rule.__class__]
self.notebook.set_current_page(page)
self.display_values(self.active_rule.__class__)
(class_obj, vallist, tlist, use_regex) = self.page[page]
r = self.active_rule.values()
for i in range(0, min(len(tlist), len(r))):
tlist[i].set_text(r[i])
if class_obj.allow_regex:
use_regex.set_active(self.active_rule.use_regex)
self.selection.connect('changed', self.on_node_selected)
self.rname.connect('button-press-event', self._button_press)
self.rname.connect('key-press-event', self._key_press)
self.get_widget('rule_editor_ok').connect('clicked', self.rule_ok)
self.get_widget('rule_editor_cancel').connect('clicked', self.close_window)
self.get_widget('rule_editor_help').connect('clicked', self.on_help_clicked)
self._set_size()
self.show()
