def __init__(self, db, scol=0, order=Gtk.SortType.ASCENDING, search=None, skip=set(), sort_map=None): cput = time.clock() super(FlatBaseModel, self).__init__() #inheriting classes must set self.map to obtain the data self.prev_handle = None self.prev_data = None #GTK3 We leak ref, yes?? #self.set_property("leak_references", False) self.db = db #normally sort on first column, so scol=0 if sort_map: #sort_map is the stored order of the columns and if they are #enabled or not. We need to store on scol of that map self.sort_map = [ f for f in sort_map if f[0]] #we need the model col, that corresponds with scol col = self.sort_map[scol][1] else: col = scol self.sort_func = lambda x: glocale.sort_key(self.smap[col](x)) self.sort_col = scol self.skip = skip self._in_build = False self.node_map = FlatNodeMap() self.set_search(search) self._reverse = (order == Gtk.SortType.DESCENDING) self.rebuild_data() _LOG.debug(self.__class__.__name__ + ' __init__ ' + str(time.clock() - cput) + ' sec')
def __init__(self, ref, parent, sortkey, handle, secondary): if sortkey: self.name = sortkey #sortkey must be localized sort, so self.sortkey = glocale.sort_key(sortkey) if not self.sortkey: self.sortkey = glocale.sort_key('') else: self.name = '' self.sortkey = glocale.sort_key('') self.ref = ref self.handle = handle self.secondary = secondary self.parent = parent self.prev = None self.next = None self.children = []
def build_columns(self): #first the standard text columns with normal method EmbeddedList.build_columns(self) # now we add the two special columns # combobox for type colno = len(self.columns) name = self._column_combo[0] renderer = Gtk.CellRendererCombo() renderer.set_property('ellipsize', Pango.EllipsizeMode.END) # set up the comboentry editable no = NameOriginType() self.cmborig = Gtk.ListStore(GObject.TYPE_INT, GObject.TYPE_STRING) self.cmborigmap = no.get_map().copy() #sort the keys based on the value keys = sorted(self.cmborigmap, key=lambda x: glocale.sort_key(self.cmborigmap[x])) for key in keys: if key != no.get_custom(): self.cmborig.append(row=[key, self.cmborigmap[key]]) additional = self.dbstate.db.get_origin_types() if additional: for type in additional: if type: self.cmborig.append(row=[no.get_custom(), type]) renderer.set_property("model", self.cmborig) renderer.set_property("text-column", 1) renderer.set_property('editable', not self.dbstate.db.readonly) renderer.connect('editing_started', self.on_edit_start_cmb, colno) renderer.connect('edited', self.on_orig_edited, self._column_combo[3]) # add to treeview column = Gtk.TreeViewColumn(name, renderer, text=self._column_combo[3]) column.set_resizable(True) column.set_sort_column_id(self._column_combo[1]) column.set_min_width(self._column_combo[2]) column.set_expand(False) self.columns.append(column) self.tree.append_column(column) # toggle box for primary colno += 1 name = self._column_toggle[0] renderer = Gtk.CellRendererToggle() renderer.set_property('activatable', True) renderer.set_property('radio', True) renderer.connect('toggled', self.on_prim_toggled, self._column_toggle[3]) # add to treeview column = Gtk.TreeViewColumn(name, renderer, active=self._column_toggle[3]) column.set_resizable(False) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) column.set_alignment(0.5) column.set_sort_column_id(self._column_toggle[1]) column.set_max_width(self._column_toggle[2]) self.columns.append(column) self.tree.append_column(column)
def build_columns(self): #first the standard text columns with normal method EmbeddedList.build_columns(self) # now we add the two special columns # combobox for type colno = len(self.columns) name = self._column_combo[0] renderer = Gtk.CellRendererCombo() renderer.set_property('ellipsize', Pango.EllipsizeMode.END) # set up the comboentry editable no = NameOriginType() self.cmborig = Gtk.ListStore(GObject.TYPE_INT, GObject.TYPE_STRING) self.cmborigmap = no.get_map().copy() #sort the keys based on the value keys = sorted(self.cmborigmap, key=lambda x: glocale.sort_key(self.cmborigmap[x])) for key in keys: if key != no.get_custom(): self.cmborig.append(row=[key, self.cmborigmap[key]]) additional = self.dbstate.db.get_origin_types() if additional: for type in additional: if type: self.cmborig.append(row=[no.get_custom(), type]) renderer.set_property("model", self.cmborig) renderer.set_property("text-column", 1) renderer.set_property('editable', not self.dbstate.db.readonly) renderer.connect('editing_started', self.on_edit_start_cmb, colno) renderer.connect('edited', self.on_orig_edited, self._column_combo[3]) # add to treeview column = Gtk.TreeViewColumn(name, renderer, text=self._column_combo[3]) column.set_resizable(True) column.set_sort_column_id(self._column_combo[1]) column.set_min_width(self._column_combo[2]) column.set_expand(False) self.columns.append(column) self.tree.append_column(column) # toggle box for primary colno += 1 name = self._column_toggle[0] renderer = Gtk.CellRendererToggle() renderer.set_property('activatable', True) renderer.set_property('radio', True) renderer.connect( 'toggled', self.on_prim_toggled, self._column_toggle[3]) # add to treeview column = Gtk.TreeViewColumn(name, renderer, active=self._column_toggle[3]) column.set_resizable(False) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) column.set_alignment(0.5) column.set_sort_column_id(self._column_toggle[1]) column.set_max_width(self._column_toggle[2]) self.columns.append(column) self.tree.append_column(column)
def search_iter_sorted_column_flat(self, selection, cur_iter, text, count, n): """ Search among the currently set search-column for a cell starting with text It assumes that this column is currently sorted, and as a LIST_ONLY view it therefore contains index2hndl = model.node_map._index2hndl which is a _sorted_ list of (sortkey, handle) tuples """ model = self._treeview.get_model() search_column = self._treeview.get_search_column() is_tree = not (model.get_flags() & Gtk.TreeModelFlags.LIST_ONLY) # If there is a sort_key index, let's use it if not is_tree and hasattr(model, "node_map"): import bisect index2hndl = model.node_map._index2hndl # create lookup key from the appropriate sort_func # TODO: explicitely announce the data->sortkey func in models # sort_key = model.sort_func(text) sort_key = glocale.sort_key(text.lower()) srtkey_hndl = (sort_key, None) lo_bound = 0 # model.get_path(cur_iter) found_index = bisect.bisect_left(index2hndl, srtkey_hndl, lo=lo_bound) # if insert position is at tail, no match if found_index == len(index2hndl): return False srt_key, hndl = index2hndl[found_index] # Check if insert position match for real # (as insert position might not start with the text) if not model[found_index][search_column].lower().startswith( text.lower()): return False found_path = Gtk.TreePath( (model.node_map.real_path(found_index), )) self._treeview.scroll_to_cell(found_path, None, 1, 0.5, 0) selection.select_path(found_path) self._treeview.set_cursor(found_path) return True return False
def search_iter_sorted_column_flat(self, selection, cur_iter, text, count, n): """ Search among the currently set search-column for a cell starting with text It assumes that this column is currently sorted, and as a LIST_ONLY view it therefore contains index2hndl = model.node_map._index2hndl which is a _sorted_ list of (sortkey, handle) tuples """ model = self._treeview.get_model() search_column = self._treeview.get_search_column() is_tree = not (model.get_flags() & Gtk.TreeModelFlags.LIST_ONLY) # If there is a sort_key index, let's use it if not is_tree and hasattr(model, "node_map"): import bisect index2hndl = model.node_map._index2hndl # create lookup key from the appropriate sort_func # TODO: explicitely announce the data->sortkey func in models # sort_key = model.sort_func(text) sort_key = glocale.sort_key(text.lower()) srtkey_hndl = (sort_key, "") lo_bound = 0 # model.get_path(cur_iter) found_index = bisect.bisect_left(index2hndl, srtkey_hndl, lo=lo_bound) # if insert position is at tail, no match if found_index == len(index2hndl): return False srt_key, hndl = index2hndl[found_index] # Check if insert position match for real # (as insert position might not start with the text) if not model[found_index][search_column].lower().startswith(text.lower()): return False found_path = Gtk.TreePath((model.node_map.real_path(found_index),)) self._treeview.scroll_to_cell(found_path, None, 1, 0.5, 0) selection.select_path(found_path) self._treeview.set_cursor(found_path) return True return False
def __init__(self, db, uistate, track, handle_list, filtname, namespace): ManagedWindow.__init__(self, uistate, track, self) self.db = db self.filtname = filtname self.namespace = namespace self.define_glade('test', RULE_GLADE,) self.set_window( self.get_widget('test'), self.get_widget('test_title'), _('Filter Test')) self.setup_configs('interface.showresults', 450, 400) render = Gtk.CellRendererText() tree = self.get_widget('list') model = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING) tree.set_model(model) column_n = Gtk.TreeViewColumn(_('Name'), render, text=0) tree.append_column(column_n) column_n = Gtk.TreeViewColumn(_('ID'), render, text=1) tree.append_column(column_n) self.get_widget('test_close').connect('clicked', self.close) new_list = sorted( (self.sort_val_from_handle(h) for h in handle_list), key=lambda x: glocale.sort_key(x[0]) ) for s_, handle in new_list: name, gid = self.get_name_id(handle) model.append(row=[name, gid]) self.show()
def __init__(self, db, uistate, scol=0, order=Gtk.SortType.ASCENDING, search=None, skip=set(), sort_map=None): cput = time.clock() GObject.GObject.__init__(self) BaseModel.__init__(self) #inheriting classes must set self.map to obtain the data self.prev_handle = None self.prev_data = None #GTK3 We leak ref, yes?? #self.set_property("leak_references", False) self.db = db #normally sort on first column, so scol=0 if sort_map: #sort_map is the stored order of the columns and if they are #enabled or not. We need to store on scol of that map self.sort_map = [ f for f in sort_map if f[0]] #we need the model col, that corresponds with scol col = self.sort_map[scol][1] else: col = scol # get the function that maps data to sort_keys self.sort_func = lambda x: glocale.sort_key(self.smap[col](x)) self.sort_col = scol self.skip = skip self._in_build = False self.node_map = FlatNodeMap() self.set_search(search) self._reverse = (order == Gtk.SortType.DESCENDING) self.rebuild_data() _LOG.debug(self.__class__.__name__ + ' __init__ ' + str(time.clock() - cput) + ' sec')
def by_value(self, val): """ Method for sorting keys based on the values. """ return glocale.sort_key(self.mapping[val])
def __by_value_key(self, first): """ Method for sorting keys based on the values. """ return glocale.sort_key(self.mapping[first])
def __init__(self, dbstate, uistate, track, handle_list, filtname, namespace): ManagedWindow.__init__(self, uistate, track, self) self.dbstate = dbstate self.db = dbstate.db self.filtname = filtname self.namespace = namespace self.category_info = get_category_info(self.db, namespace) glade = Glade(toplevel='test') test_title = glade.get_child_object('test_title') title = "{namespace}: {filtname} ({n} {objects})".format( namespace=_(namespace), filtname=filtname, objects=_("objects"), n=len(handle_list)) test_title.set_label(title) self.set_window( glade.get_child_object('test'), None, _('Filter Test')) render = Gtk.CellRendererText() self.treeview = glade.get_child_object('list') model = Gtk.ListStore(GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING, object) self.treeview.set_model(model) col = Gtk.TreeViewColumn(_('ID'), render, text=0) col.set_clickable(True) col.set_resizable(True) col.set_sort_column_id(0) self.treeview.append_column(col) if self.namespace == "Event": col = Gtk.TreeViewColumn(_('Type'), render, text=1) col.set_clickable(True) col.set_resizable(True) col.set_sort_column_id(1) self.treeview.append_column(col) col = Gtk.TreeViewColumn(_('Description'), render, text=2) col.set_clickable(True) col.set_resizable(True) col.set_sort_column_id(3) self.treeview.append_column(col) elif self.namespace == "Citation": col = Gtk.TreeViewColumn(_('Page'), render, text=1) col.set_clickable(True) col.set_resizable(True) col.set_sort_column_id(1) self.treeview.append_column(col) col = Gtk.TreeViewColumn(_('Source'), render, text=2) col.set_clickable(True) col.set_resizable(True) col.set_sort_column_id(3) self.treeview.append_column(col) else: col = Gtk.TreeViewColumn(_('Name'), render, text=1) col.set_clickable(True) col.set_resizable(True) col.set_sort_column_id(1) self.treeview.append_column(col) self.treeview.connect("button-press-event", self.button_press) glade.get_child_object('test_close').connect('clicked', self.close) glade.get_child_object('open_button').connect('clicked', self.open_object) new_list = sorted( (self.sort_val_from_handle(h) for h in handle_list), key=lambda x: glocale.sort_key(x[0]) ) for s_, handle in new_list: gid, name, name2, obj = self.get_obj(handle) model.append(row=[gid, name, name2, obj]) glade.get_child_object('open_button').set_sensitive(len(new_list) > 0) self.show()
def add_menu_options(self, menu): """ Add options to the menu for the statistics report. """ ################################ category_name = _("Report Options") add_option = partial(menu.add_option, category_name) ################################ self.__filter = FilterOption(_("Filter"), 0) self.__filter.set_help(_("Determines what people are included " "in the report.")) add_option("filter", self.__filter) self.__filter.connect('value-changed', self.__filter_changed) self.__pid = PersonOption(_("Filter Person")) self.__pid.set_help(_("The center person for the filter.")) menu.add_option(category_name, "pid", self.__pid) self.__pid.connect('value-changed', self.__update_filters) sortby = EnumeratedListOption(_('Sort chart items by'), _options.SORT_VALUE) for item_idx in range(len(_options.opt_sorts)): item = _options.opt_sorts[item_idx] sortby.add_item(item_idx, item[2]) sortby.set_help(_("Select how the statistical data is sorted.")) add_option("sortby", sortby) reverse = BooleanOption(_("Sort in reverse order"), False) reverse.set_help(_("Check to reverse the sorting order.")) add_option("reverse", reverse) this_year = time.localtime()[0] year_from = NumberOption(_("People Born After"), 1700, 1, this_year) year_from.set_help(_("Birth year from which to include people.")) add_option("year_from", year_from) year_to = NumberOption(_("People Born Before"), this_year, 1, this_year) year_to.set_help(_("Birth year until which to include people")) add_option("year_to", year_to) no_years = BooleanOption(_("Include people without known birth years"), False) no_years.set_help(_("Whether to include people without " "known birth years.")) add_option("no_years", no_years) gender = EnumeratedListOption(_('Genders included'), Person.UNKNOWN) for item_idx in range(len(_options.opt_genders)): item = _options.opt_genders[item_idx] gender.add_item(item[0], item[2]) gender.set_help(_("Select which genders are included into " "statistics.")) add_option("gender", gender) bar_items = NumberOption(_("Max. items for a pie"), 8, 0, 20) bar_items.set_help(_("With fewer items pie chart and legend will be " "used instead of a bar chart.")) add_option("bar_items", bar_items) ################################ category_name = _("Report Options (2)") add_option = partial(menu.add_option, category_name) ################################ self._nf = stdoptions.add_name_format_option(menu, category_name) self._nf.connect('value-changed', self.__update_filters) self.__update_filters() stdoptions.add_private_data_option(menu, category_name) stdoptions.add_living_people_option(menu, category_name) stdoptions.add_localization_option(menu, category_name) ################################ # List of available charts on separate option tabs ################################ idx = 0 third = (len(_Extract.extractors) + 1) // 3 chart_types = [] for (chart_opt, ctuple) in _Extract.extractors.items(): chart_types.append((_(ctuple[1]), chart_opt, ctuple)) sorted_chart_types = sorted(chart_types, key=lambda x: glocale.sort_key(x[0])) for (translated_option_name, opt_name, ctuple) in sorted_chart_types: if idx >= (third * 2): category_name = _("Charts 3") elif idx >= third: category_name = _("Charts 2") else: category_name = _("Charts 1") opt = BooleanOption(translated_option_name, False) opt.set_help(_("Include charts with indicated data.")) menu.add_option(category_name, opt_name, opt) idx += 1 # Enable a couple of charts by default menu.get_option_by_name("data_gender").set_value(True) menu.get_option_by_name("data_ccount").set_value(True) menu.get_option_by_name("data_bmonth").set_value(True)