def build_gui(self): """Called by __init__ to take care of the gtk work or putting the gui together. This consists of loading mainwindow from the glade file, setting the bokeep logo, and getting the cell renderers and empty models set up for the book and transaction type combo boxes. Ends with a a call to set_sensitivities_and_status to nicely grey things out until we have something for the shell to actually display. This is meant to be done without self.book or self.guistate being available yet. It shouldn't be called from anywhere other than __init__, and only once. """ glade_file = get_main_window_glade_file() load_glade_file_get_widgets_and_connect_signals( glade_file, "mainwindow", self, self ) self.mainwindow.set_icon_from_file(get_bo_keep_logo()) self.books_combobox_model = ListStore(str, str, object) self.books_combobox.set_model(self.books_combobox_model) cell = CellRendererText() self.books_combobox.pack_start(cell, True) self.books_combobox.add_attribute(cell, 'text', 0) self.trans_type_model = ListStore(str, int, object) self.set_sensitivities_and_status()
class warning_dialog(Dialog): def __init__(self, parent, pacs, icon): Dialog.__init__( self, _("Warning!"), parent, DIALOG_MODAL | DIALOG_DESTROY_WITH_PARENT, (STOCK_YES, RESPONSE_YES, STOCK_NO, RESPONSE_REJECT), ) self.set_icon(pixbuf_new_from_file(icon)) self._setup_tree(pacs) self._setup_layout() def _setup_layout(self): self.set_default_size(-1, 250) label = Label( _( "This packages requires one of the packages you've selected for removal.\nDo you want to remove them all?" ) ) label.show() scr = ScrolledWindow() scr.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC) scr.add(self.tree) self.vbox.pack_start(label, False, False, 0) self.vbox.pack_start(scr, True, True, 0) self.vbox.show_all() return def _setup_tree(self, pacs): self.tree = TreeView() self.model = ListStore(str, str, str) self.tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id=0) self.tree.insert_column_with_attributes(-1, "", CellRendererText(), text=1) self.tree.insert_column_with_attributes(-1, "", CellRendererText(), text=2) for pac in pacs: if pac.isold: image = "yellow" elif pac.installed: image = "green" else: image = "red" self.model.append([image, pac.name, pac.inst_ver]) continue self.tree.set_model(self.model) self.tree.show_all() return
class upgrade_confirm_dialog(Dialog): def __init__(self, parent, to_upgrade, icon): Dialog.__init__(self, _("Confirm Upgrade"), parent, DIALOG_MODAL | DIALOG_DESTROY_WITH_PARENT, (STOCK_OK, RESPONSE_ACCEPT, STOCK_CANCEL, RESPONSE_REJECT)) self.set_icon(pixbuf_new_from_file(icon)) self._setup_tree(to_upgrade) self._setup_layout() def _setup_tree(self, pacs): self.model = ListStore(str, str, str) for pac in pacs: self.model.append(["yellow", pac.name, pac.version]) continue self.tree = TreeView() self.tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id = 0) self.tree.insert_column_with_attributes(-1, "Package", CellRendererText(), text = 1) self.tree.insert_column_with_attributes(-1, "Version", CellRendererText(), text = 2) self.tree.set_model(self.model) self.tree.show() def _setup_layout(self): self.label = Label(_("Are you sure yo want to upgrade those packages?\n")) self.label.show() self.set_default_size (300, 300) scr = ScrolledWindow() scr.set_policy("automatic", "automatic") scr.add(self.tree) scr.show() self.vbox.pack_start(self.label, False, False, 0) self.vbox.pack_start(scr, True, True, 0) def run(self): retcode = Dialog.run(self) self.destroy() if retcode == RESPONSE_ACCEPT: return True else: return False
def __init__(self, pacs): ListStore.__init__(self, str, str, str, str, str, int) for pac_tuple in enumerate( pacs ): if not pac_tuple[1].installed: continue position = pac_tuple[0] if pac_tuple[1].isold: image = "yellow" else: image = "green" self.append([image, None, pac_tuple[1].name, pac_tuple[1].inst_ver, pac_tuple[1].version, position])
def __init__(self, pacs): ListStore.__init__(self, str, str, str, str, str) for pac in pacs: if not pac.installed: continue if pac.isold: image = "yellow" else: image = "green" self.append([image, None, pac.name, pac.inst_ver, pac.version]) continue
def __init__(self, queue): ListStore.__init__(self, str, str, str) for pac in queue: if pac.isold: image = "yellow" version = pac.version elif pac.installed: image = "green" version = pac.inst_ver else: image = "red" version = pac.version self.append([image, pac.name, version])
def extended_init(self): self.trustor_list = ListStore( str ) self.trustor_combo.set_model(self.trustor_list) index = 0 use_index = -1 for trustor_name in self.trustors: self.trustor_list.append([trustor_name]) if not(self.trans_trustor == None) and self.trans_trustor.name == trustor_name: use_index = index index += 1 if use_index > -1: self.trustor_combo.set_active(use_index) self.amount_entry.set_text(str(self.trust_trans.get_displayable_amount())) self.description_textview.get_buffer().set_text(str(self.trust_trans.get_memo())) else: self.trustor_combo.set_active(0) trans_date = self.trust_trans.trans_date self.entry_date_label.set_text( "%s-%s-%s" % (trans_date.year, trans_date.month, trans_date.day) ) if not self.editable or self.trust_trans.get_trustor() == None : self.amount_entry.set_sensitive(False)
def _setup_tree(self, pacs): self.tree = TreeView() self.model = ListStore(str, str, str) self.tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id=0) self.tree.insert_column_with_attributes(-1, "", CellRendererText(), text=1) self.tree.insert_column_with_attributes(-1, "", CellRendererText(), text=2) for pac in pacs: if pac.isold: image = "yellow" elif pac.installed: image = "green" else: image = "red" self.model.append([image, pac.name, pac.inst_ver]) continue self.tree.set_model(self.model) self.tree.show_all() return
def __init__(self, trans, transid, plugin, gui_parent, change_register_function): self.fee_trans = trans self.transid = transid self.memberfee_plugin = plugin self.change_register_function = change_register_function load_glade_file_get_widgets_and_connect_signals( get_memberfee_glade_file(), 'window1', self, self) self.vbox1.reparent(gui_parent) self.window1.hide() self.fee_spread_liststore = ListStore(str, str) self.fee_spread_list.set_model(self.fee_spread_liststore) column_one = TreeViewColumn('Date') column_two = TreeViewColumn('Amount') self.fee_spread_list.append_column(column_one) self.fee_spread_list.append_column(column_two) for i, column in enumerate((column_one, column_two)): cell = CellRendererText() column.pack_start(cell, False) column.add_attribute(cell, 'text', i) self.populate_fee_spread_liststore()
def _setup_install_tree(self, queue): self.install_tree = TreeView() self.install_model = ListStore(str, str, str) self.install_tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id=0) self.install_tree.insert_column_with_attributes(-1, _("Package"), CellRendererText(), text=1) self.install_tree.insert_column_with_attributes(-1, _("Version"), CellRendererText(), text=2) for pac in queue: if pac.isold: image = "yellow" elif pac.installed: image = "green" else: image = "red" self.install_model.append([image, pac.name, pac.version]) continue self.install_tree.set_model(self.install_model) return
def __init__(self, pacs): ListStore.__init__(self, str, str, str, str, str, str) for pac in pacs: if not (pac.isold or pac.installed): image = "red" inst_ver = "-" elif pac.isold: image = "yellow" inst_ver = pac.inst_ver else: image = "green" inst_ver = pac.inst_ver self.append([image, None, pac.name, inst_ver, pac.version, pac.repo])
def __init__(self, pacs): ListStore.__init__(self, str, str, str, str, str, str) for pac_tuple in enumerate( pacs ): position = pac_tuple[0] if not pac_tuple[1].isorphan: continue if pac_tuple[1].isold: image = "yellow" inst_ver = pac_tuple[1].inst_ver else: image = "green" inst_ver = pac_tuple[1].inst_ver self.append([image, None, pac_tuple[1].name, inst_ver, pac_tuple[1].version, pac_tuple[1].repo])
def __init__(self, pacs): ListStore.__init__(self, str, str, str, str, str, int) for pac_tuple in enumerate(pacs): position = pac_tuple[0] if pac_tuple[1].explicitly[1] and pac_tuple[1].isold: image = "yellow" inst_ver = pac_tuple[1].inst_ver elif pac_tuple[1].explicitly[1] and not pac_tuple[1].isold: image = "green" inst_ver = pac_tuple[1].inst_ver else: continue self.append([image, None, pac_tuple[1].name, inst_ver, pac_tuple[1].version, position])
class MemberFeeCollectionEditor(object): def __init__(self, trans, transid, plugin, gui_parent, change_register_function): self.fee_trans = trans self.transid = transid self.memberfee_plugin = plugin self.change_register_function = change_register_function load_glade_file_get_widgets_and_connect_signals( get_memberfee_glade_file(), 'window1', self, self) self.vbox1.reparent(gui_parent) self.window1.hide() self.fee_spread_liststore = ListStore(str, str) self.fee_spread_list.set_model(self.fee_spread_liststore) column_one = TreeViewColumn('Date') column_two = TreeViewColumn('Amount') self.fee_spread_list.append_column(column_one) self.fee_spread_list.append_column(column_two) for i, column in enumerate((column_one, column_two)): cell = CellRendererText() column.pack_start(cell, False) column.add_attribute(cell, 'text', i) self.populate_fee_spread_liststore() def populate_fee_spread_liststore(self): self.fee_spread_liststore.clear() for month in gen_n_months_starting_from(first_of(date.today()), 4): self.fee_spread_liststore.append((month, '10')) def detach(self): self.vbox1.reparent(self.window1) def day_changed(self, *args): print('day_changed') def amount_collected_changed(self, *args): print('amount_collected_changed') def member_changed(self, *args): print('member_changed')
class HttpHandler(object): """Has callbacks that are invoked by the event system. It only accepts packets if: * They are HTTP requests * send or received by the IP given. If none is given, every IP is accepted. Subclass and overwrite handle for great good.""" def __init__(self, ip = None): self.ip = ip self.gtk_list_store = ListStore(str, str) def accept(self, pkg): logger.debug("Accepting? %s", pkg.summary()) if not pkg.haslayer(TCP): return False tcp_pkg = pkg[TCP] if not (tcp_pkg.dport == 80 or tcp_pkg.sport == 80): return False if isinstance(tcp_pkg.payload, NoPayload): return False if not GET.match(str(tcp_pkg.payload)): return False if self.ip is not None: return pkg[IP].src == self.ip or pkg[IP].dst == self.ip else: return True def handle(self, pkg): self.print(pkg) def print(self, pkg): logger.debug("got a package %s to print", pkg.summary()) time = datetime.fromtimestamp(pkg.time) logger.debug("initially at time={}".format(time)) tcp_pkg = pkg[TCP] server_name = reverse_dns(pkg[IP].dst) match = GET.match(str(tcp_pkg.payload)) try: entry = "http://{}{}".format(str(server_name.result(5.0)), match.group(1)) except TimeoutError: entry = "http://{}{}".format(str(pkg[IP].dst), match.group(1)) logger.info(entry) self.gtk_list_store.append([str(time), entry])
def create_prop_store(self, extra_props=[]): assert(self.component is not None) from gtk import ListStore store = ListStore(object, str, object) # use private properties so we connect to the actual object stores and not the inherited ones for atom in self.component._layer_atoms: store.append([atom, "pn", lambda o: o.name]) for atom in self.component._interlayer_atoms: store.append([atom, "pn", lambda o: o.name]) for prop in extra_props: store.append(prop) return store
def _setup_tree(self, pacs): self.model = ListStore(str, str, str) for pac in pacs: self.model.append(["yellow", pac.name, pac.version]) continue self.tree = TreeView() self.tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id=0) self.tree.insert_column_with_attributes(-1, "Package", CellRendererText(), text=1) self.tree.insert_column_with_attributes(-1, "Version", CellRendererText(), text=2) self.tree.set_model(self.model) self.tree.show()
def refresh_trustor_list(self): self.reset_view() self.trustor_list = ListStore( str, str ) self.trustor_view.set_model(self.trustor_list) for i, title in enumerate(('Trustor', 'Balance')): self.trustor_view.append_column( TreeViewColumn(title,CellRendererText(), text=i ) ) for trustor in self.trustors: self.trustor_list.append([trustor, str(self.trustors[trustor].get_balance())])
def extended_init(self): self.widgets['name_entry'].set_text(self.trustor.name) self.widgets['name_entry'].connect('changed', self.on_name_entry_changed) self.widgets['dyn_balance'].set_text(str(self.trustor.get_balance())) self.transactions_view = self.widgets['transactions_view'] self.transactions_list = ListStore( str, str, str ) self.transactions_view.set_model(self.transactions_list) for i, title in enumerate(('Date', 'Type', 'Balance')): self.transactions_view.append_column( TreeViewColumn(title,CellRendererText(), text=i ) ) for transaction in self.trustor.transactions: self.transactions_list.append([transaction.trans_date.strftime("%B %d, %Y, %H:%M"), self.get_tran_type(transaction), str(transaction.get_transfer_amount())])
def __populate_possible_plugins(self): """Populates the GUI with the possible front and backend plugins.""" available_plugin_liststore = ListStore(str) for plugin_name in get_available_frontend_plugins(): available_plugin_liststore.append([plugin_name]) self.plugin_add_entry_combo.set_model(available_plugin_liststore) self.plugin_add_entry_combo.set_text_column(0) available_backend_plugin_liststore = ListStore(str) for backend_plugin_name in get_available_backend_plugins(): available_backend_plugin_liststore.append([backend_plugin_name]) self.backend_plugin_entry_combo.set_model(available_backend_plugin_liststore) self.backend_plugin_entry_combo.set_text_column(0)
class do_dialog(Window): def __init__(self, queues, icon): Window.__init__(self, WINDOW_TOPLEVEL) self.set_property("skip-taskbar-hint", True) self.set_property("destroy-with-parent", True) self.set_modal(True) self.connect("delete-event", self._stop_closing) self.set_position(WIN_POS_CENTER) self.set_icon(pixbuf_new_from_file(icon)) self._setup_trees(queues) self._setup_layout() self.queues = queues def _setup_trees(self, queues): self._setup_install_tree(queues["add"]) self._setup_remove_tree(queues["remove"]) def _setup_install_tree(self, add_queue): self.inst_model = ListStore(str, str, str) for pac in add_queue: if pac.isold: image = "yellow" elif pac.installed: image = "green" else: image = "red" self.inst_model.append([image, pac.name, pac.version]) continue self.inst_tree = TreeView() self.inst_tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id = 0) self.inst_tree.insert_column_with_attributes(-1, _("Package"), CellRendererText(), text = 1) self.inst_tree.insert_column_with_attributes(-1, _("Version"), CellRendererText(), text = 2) self.inst_tree.set_model(self.inst_model) def _setup_remove_tree(self, remove_queue): self.rem_model = ListStore(str, str, str) for pac in remove_queue: if pac.isold: image = "yellow" elif pac.installed: image = "green" else: image = "red" self.rem_model.append([image, pac.name, pac.inst_ver]) continue self.rem_tree = TreeView() self.rem_tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id = 0) self.rem_tree.insert_column_with_attributes(-1, _("Package"), CellRendererText(), text = 1) self.rem_tree.insert_column_with_attributes(-1, _("Installed Version"), CellRendererText(), text = 2) self.rem_tree.set_model(self.rem_model) def _set_size (self, widget, event, data=None): if self.expander.get_expanded(): self.size = self.get_size() self.expander.add(self.terminal) self.terminal.show() else: self.expander.remove(self.terminal) self.resize(self.size[0], self.size[1]) self.show_all() def _setup_layout(self): self.hpaned = HPaned() self.hpaned.add1(self.inst_tree) self.hpaned.add2(self.rem_tree) self.hpaned.show_all() self.close_button = Button(stock=STOCK_CLOSE) self.close_button.connect("clicked", lambda _: self.destroy()) self.terminal = terminal() self.terminal.connect("child-exited", lambda _: self.close_button.show()) self.expander = Expander(_("Terminal")) self.expander.connect("notify::expanded", self._set_size) self.expander.show() self.vbox = VBox(False, 0) self.vbox.show() self.vbox.pack_start(self.hpaned, False, False, 0) self.vbox.pack_start(self.expander, False, False, 0) self.vbox.pack_start(self.close_button, False, False, 0) self.add(self.vbox) def run(self): self.show() self.terminal.do(self.queues) return def _stop_closing(self, widget, event): self.stop_emission("delete-event") return True
def _get_new_list_store(): return ListStore(str, str, str, int, bool, str, gobject.TYPE_PYOBJECT)
def __on_plugin_directories_button_click(self, button): """Present a dialog to the user for selecting extra plugin directories and process the request.""" dia = Dialog('Plugin Directories', None, DIALOG_MODAL, (STOCK_OK, RESPONSE_OK, STOCK_CANCEL, RESPONSE_CANCEL ) ) dia.resize(500, 300) dia.vbox.set_spacing(8) # Setup the tree view of plugin directories. model = ListStore(str) # each row contains a single string tv = TreeView(model) cell = CellRendererText() column = TreeViewColumn('Directory', cell, text = 0) tv.append_column(column) dia.vbox.pack_start(tv) # Populate the tree view. plugin_directories = \ get_plugins_directories_from_config(self.config, self.config_path) for plugin_directory in plugin_directories: row = (plugin_directory,) model.append(row) modify_box = HBox(spacing = 8) # Setup the remove directory button. remove_button = Button('Remove') remove_button.set_sensitive(False) # no directory selected initially remove_button.connect('clicked', self.__on_remove, tv) modify_box.pack_end(remove_button, expand = False) tv.connect('cursor-changed', self.__on_select, remove_button) # Setup the add directory button. add_button = Button('Add') add_button.connect('clicked', self.__on_add, tv) modify_box.pack_end(add_button, expand = False) dia.vbox.pack_start(modify_box, expand = False) # Setup the "already included directories" label. included_label = Label('Plugins in the PYTHONPATH are already ' + 'available to BoKeep.') # Use a horizontal box to left-justify the label. For some reason, # the label's set_justification property doesn't work for me. label_box = HBox() label_box.pack_start(included_label, expand = False) dia.vbox.pack_start(label_box, expand = False) dia.show_all() dia_result = dia.run() if dia_result == RESPONSE_OK: # Remove the old plugin directories from the program's path. plugin_directories = \ get_plugins_directories_from_config(self.config, self.config_path) for plugin_directory in plugin_directories: path.remove(plugin_directory) # Get the new plugin directories from the dialog. plugin_directories = [] for row in model: plugin_directory = row[0] plugin_directories.append(plugin_directory) # Update the BoKeep PYTHONPATH so that new plugins can be loaded and # populate the list of possible new plugins. for plugin_directory in plugin_directories: path.append(plugin_directory) self.__populate_possible_plugins() # Save the new plugin directories in the configuration file. set_plugin_directories_in_config(self.config, self.config_path, plugin_directories) dia.destroy()
def __init__(self, component_manager): Component.__init__(self, component_manager) self.w_tree = self.main_widget().w_tree self.get_widget = get_widget = self.w_tree.get_widget self.conf = self.config() self.connections = [] self.connect_signals([\ ("input_mode_toolbar_button_back_w", "clicked", \ self.input_to_main_menu_cb), ("front_to_back_mode_selector_w", "released", \ self.change_card_type_cb), ("both_way_mode_selector_w", "released", self.change_card_type_cb), ("three_side_mode_selector_w", "released", \ self.change_card_type_cb), ("cloze_mode_selector_w", "released", self.change_card_type_cb), ("picture_content_button", "clicked", self.add_picture_cb), ("image_selection_dialog_button_select", "clicked", \ self.select_item_cb), ("image_selection_dialog_button_close", "clicked", self.close_media_selection_dialog_cb), ("input_mode_prev_category_w", "clicked", self.change_category_cb), ("input_mode_next_category_w", "clicked", self.change_category_cb), ("input_mode_add_new_category_w", "clicked", \ self.create_new_category_cb), ("sound_content_button", "clicked", self.add_sound_cb), ("category_name_container", "clicked", \ self.show_add_category_block_cb), ("input_mode_close_add_category_block_w", "clicked", self.hide_add_category_block_cb), ("input_mode_snd_button", "released", \ self.preview_sound_in_input_cb)]) self.fact = None self.sounddir = None self.imagedir = None self.card_type = None self.categories_list = [] self.added_new_cards = False #liststore = [text, type, filename, dirname, pixbuf] self.liststore = ListStore(str, str, str, str, gtk.gdk.Pixbuf) iconview_widget = get_widget("iconview_widget") iconview_widget.set_model(self.liststore) iconview_widget.set_pixbuf_column(4) iconview_widget.set_text_column(0) get_widget = self.get_widget # Widgets as attributes self.areas = {# Text areas "cloze": get_widget("cloze_text_w"), "answer": get_widget("answer_text_w"), "foreign": get_widget("foreign_text_w"), "question": get_widget("question_text_w"), "translation": get_widget("translation_text_w"), "pronunciation": get_widget("pronun_text_w") } # Mandatory color setup fot GtkTextView for area in self.areas.values(): area.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse("#FFFFFF")) area.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000000")) # Change default font font = pango.FontDescription("Nokia Sans %s" % \ (self.conf['font_size'] - FONT_DISTINCTION)) for area in self.areas.values(): area.modify_font(font) self.widgets = {# Other widgets "CurrentCategory": get_widget("category_name_w"), "SoundButton": get_widget("sound_content_button"), "PictureButton": get_widget("picture_content_button"), "SoundIndicator": get_widget("input_mode_snd_button"), "CardTypeSwithcer": get_widget("card_type_switcher_w"), "MediaDialog": get_widget("media_selection_dialog"), "SoundContainer": get_widget("input_mode_snd_container"), "QuestionContainer": get_widget("input_mode_question_container"), "NewCategory": get_widget("input_mode_new_category_entry"), "ChangeCategoryBlock": get_widget(\ "input_mode_change_category_block"), "AddCategoryBlock": get_widget("input_mode_add_category_block") } # Mandatory color setup fot GtkEntry self.widgets["NewCategory"].modify_base(gtk.STATE_NORMAL, \ gtk.gdk.color_parse("#FFFFFF")) self.widgets["NewCategory"].modify_text(gtk.STATE_NORMAL, \ gtk.gdk.color_parse("#000000")) # card_id: {"page": page_id, "selector": selector_widget, # "widgets": [(field_name:text_area_widget)...]} self.selectors = { FrontToBack.id: { "page": 0, "selector": get_widget("front_to_back_mode_selector_w"), "widgets": [('q', self.areas["question"]), ('a', self.areas["answer"])] }, BothWays.id: { "page": 0, "selector": get_widget("both_way_mode_selector_w"), "widgets": [('q', self.areas["question"]), ('a', self.areas["answer"])] }, ThreeSided.id: { "page": 1, "selector": get_widget("three_side_mode_selector_w"), "widgets": [('f', self.areas["foreign"]), ('t', self.areas["translation"]), ('p', self.areas["pronunciation"])] }, Cloze.id: { "page": 2, "selector": get_widget("cloze_mode_selector_w"), "widgets": [('text', self.areas["cloze"])] } } # add card_type to selectors subdict for card_type in self.card_types(): self.selectors[card_type.id]["card_type"] = card_type # create {selector_widget:card_type.id} dict self.widget_card_id = dict((self.selectors[id]["selector"], id) \ for id in self.selectors.keys()) self.set_card_type(get_widget("front_to_back_mode_selector_w")) self.compose_widgets() # Turn off hildon autocapitalization try: for widget in self.areas.values(): widget.set_property("hildon-input-mode", 'full') # stock gtk doesn't have hildon properties except (TypeError, AttributeError): pass # so, skip silently
class InputWidget(Component): """Input mode widget for Rainbow theme.""" def __init__(self, component_manager): Component.__init__(self, component_manager) self.w_tree = self.main_widget().w_tree self.get_widget = get_widget = self.w_tree.get_widget self.conf = self.config() self.connections = [] self.connect_signals([\ ("input_mode_toolbar_button_back_w", "clicked", \ self.input_to_main_menu_cb), ("front_to_back_mode_selector_w", "released", \ self.change_card_type_cb), ("both_way_mode_selector_w", "released", self.change_card_type_cb), ("three_side_mode_selector_w", "released", \ self.change_card_type_cb), ("cloze_mode_selector_w", "released", self.change_card_type_cb), ("picture_content_button", "clicked", self.add_picture_cb), ("image_selection_dialog_button_select", "clicked", \ self.select_item_cb), ("image_selection_dialog_button_close", "clicked", self.close_media_selection_dialog_cb), ("input_mode_prev_category_w", "clicked", self.change_category_cb), ("input_mode_next_category_w", "clicked", self.change_category_cb), ("input_mode_add_new_category_w", "clicked", \ self.create_new_category_cb), ("sound_content_button", "clicked", self.add_sound_cb), ("category_name_container", "clicked", \ self.show_add_category_block_cb), ("input_mode_close_add_category_block_w", "clicked", self.hide_add_category_block_cb), ("input_mode_snd_button", "released", \ self.preview_sound_in_input_cb)]) self.fact = None self.sounddir = None self.imagedir = None self.card_type = None self.categories_list = [] self.added_new_cards = False #liststore = [text, type, filename, dirname, pixbuf] self.liststore = ListStore(str, str, str, str, gtk.gdk.Pixbuf) iconview_widget = get_widget("iconview_widget") iconview_widget.set_model(self.liststore) iconview_widget.set_pixbuf_column(4) iconview_widget.set_text_column(0) get_widget = self.get_widget # Widgets as attributes self.areas = {# Text areas "cloze": get_widget("cloze_text_w"), "answer": get_widget("answer_text_w"), "foreign": get_widget("foreign_text_w"), "question": get_widget("question_text_w"), "translation": get_widget("translation_text_w"), "pronunciation": get_widget("pronun_text_w") } # Mandatory color setup fot GtkTextView for area in self.areas.values(): area.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse("#FFFFFF")) area.modify_text(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000000")) # Change default font font = pango.FontDescription("Nokia Sans %s" % \ (self.conf['font_size'] - FONT_DISTINCTION)) for area in self.areas.values(): area.modify_font(font) self.widgets = {# Other widgets "CurrentCategory": get_widget("category_name_w"), "SoundButton": get_widget("sound_content_button"), "PictureButton": get_widget("picture_content_button"), "SoundIndicator": get_widget("input_mode_snd_button"), "CardTypeSwithcer": get_widget("card_type_switcher_w"), "MediaDialog": get_widget("media_selection_dialog"), "SoundContainer": get_widget("input_mode_snd_container"), "QuestionContainer": get_widget("input_mode_question_container"), "NewCategory": get_widget("input_mode_new_category_entry"), "ChangeCategoryBlock": get_widget(\ "input_mode_change_category_block"), "AddCategoryBlock": get_widget("input_mode_add_category_block") } # Mandatory color setup fot GtkEntry self.widgets["NewCategory"].modify_base(gtk.STATE_NORMAL, \ gtk.gdk.color_parse("#FFFFFF")) self.widgets["NewCategory"].modify_text(gtk.STATE_NORMAL, \ gtk.gdk.color_parse("#000000")) # card_id: {"page": page_id, "selector": selector_widget, # "widgets": [(field_name:text_area_widget)...]} self.selectors = { FrontToBack.id: { "page": 0, "selector": get_widget("front_to_back_mode_selector_w"), "widgets": [('q', self.areas["question"]), ('a', self.areas["answer"])] }, BothWays.id: { "page": 0, "selector": get_widget("both_way_mode_selector_w"), "widgets": [('q', self.areas["question"]), ('a', self.areas["answer"])] }, ThreeSided.id: { "page": 1, "selector": get_widget("three_side_mode_selector_w"), "widgets": [('f', self.areas["foreign"]), ('t', self.areas["translation"]), ('p', self.areas["pronunciation"])] }, Cloze.id: { "page": 2, "selector": get_widget("cloze_mode_selector_w"), "widgets": [('text', self.areas["cloze"])] } } # add card_type to selectors subdict for card_type in self.card_types(): self.selectors[card_type.id]["card_type"] = card_type # create {selector_widget:card_type.id} dict self.widget_card_id = dict((self.selectors[id]["selector"], id) \ for id in self.selectors.keys()) self.set_card_type(get_widget("front_to_back_mode_selector_w")) self.compose_widgets() # Turn off hildon autocapitalization try: for widget in self.areas.values(): widget.set_property("hildon-input-mode", 'full') # stock gtk doesn't have hildon properties except (TypeError, AttributeError): pass # so, skip silently def connect_signals(self, control): """Connect signals to widgets and save connection info.""" for wname, signal, callback in control: widget = self.get_widget(wname) cid = widget.connect(signal, callback) self.connections.append((widget, cid)) def disconnect_signals(self): """Disconnect previously connected signals.""" for widget, cid in self.connections: widget.disconnect(cid) self.connections = [] def show_snd_container(self): """Show or hide snd container. """ start, end = self.areas["question"].get_buffer().get_bounds() text = self.areas["question"].get_buffer().get_text(start, end) if "sound src=" in text: self.widgets["QuestionContainer"].hide() self.widgets["SoundContainer"].show() else: self.widgets["QuestionContainer"].show() self.widgets["SoundContainer"].hide() def compose_widgets (self): """Switch to neccessary input page. It depends on card_type.""" self.widgets["CardTypeSwithcer"].set_current_page( \ self.selectors[self.card_type.id]["page"]) self.selectors[self.card_type.id]["selector"].set_active(True) state = self.card_type.id in (FrontToBack.id) self.widgets["PictureButton"].set_sensitive(state) self.widgets["SoundButton"].set_sensitive(state) def set_card_type(self, widget): """Set current card type.""" card_type_id = self.widget_card_id[widget] self.card_type = self.selectors[card_type_id]["card_type"] def update_categories(self): """Update categories list content.""" if not self.categories_list: categories = dict([(i, name) for (i, name) in \ enumerate(self.database().tag_names())]) if categories.values(): for category in sorted(categories.values()): self.categories_list.append(category) self.widgets["CurrentCategory"].set_text( \ sorted(categories.values())[0]) else: self.categories_list.append("default category") self.widgets["CurrentCategory"].set_text("default category") def check_complete_input(self): """Check for non empty fields.""" pattern_list = ["Type %s here..." % item for item in ["ANSWER", \ "QUESTION", "FOREIGN", "PRONUNCIATION", "TRANSLATION", "TEXT"]] pattern_list.append("") for selector in self.selectors[self.card_type.id]["widgets"]: buf = selector[1].get_buffer() start, end = buf.get_bounds() if buf.get_text(start, end) in pattern_list: return False return True def change_category_cb(self, widget): """Change current category.""" if widget.name == "prev_category_w": direction = -1 direction = 1 category_index = self.categories_list.index( \ self.widgets["CurrentCategory"].get_text()) try: new_category = self.categories_list[category_index + direction] except IndexError: if direction: new_category = self.categories_list[0] else: new_category = self.categories_list[len(self.categories_list)-1] self.widgets["CurrentCategory"].set_text(new_category) def create_new_category_cb(self, widget): """Create new category.""" new_category = self.widgets["NewCategory"].get_text() if new_category: self.categories_list.append(new_category) self.widgets["NewCategory"].set_text("") self.widgets["CurrentCategory"].set_text(new_category) self.hide_add_category_block_cb(None) def add_picture_cb(self, widget): """Show image selection dialog.""" self.main_widget().soundplayer.stop() self.liststore.clear() self.imagedir = self.conf['imagedir'] if not os.path.exists(self.imagedir): self.imagedir = "./images" # on Desktop if not os.path.exists(self.imagedir): self.main_widget().information_box(\ _("'Images' directory does not exist!")) return if os.listdir(self.imagedir): self.widgets["MediaDialog"].show() for fname in os.listdir(self.imagedir): if os.path.isfile(os.path.join(self.imagedir, fname)): pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(\ os.path.join(self.imagedir, fname), 100, 100) self.liststore.append(["", "img", fname, \ self.imagedir, pixbuf]) else: self.main_widget().information_box(\ _("There are no files in 'Images' directory!")) def select_item_cb(self, widget): """ Set html-text with media path and type when user select media filefrom media selection dialog. """ self.widgets["MediaDialog"].hide() item_index = self.w_tree.get_widget("iconview_widget"). \ get_selected_items()[0] item_type = self.liststore.get_value( \ self.liststore.get_iter(item_index), 1) item_fname = self.liststore.get_value( \ self.liststore.get_iter(item_index), 2) item_dirname = self.liststore.get_value( \ self.liststore.get_iter(item_index), 3) question_text = """<%s src="%s">""" % \ (item_type, os.path.abspath(os.path.join(item_dirname, item_fname))) self.areas["question"].get_buffer().set_text(question_text) self.show_snd_container() def add_sound_cb(self, widget): """Show sound selection dialog.""" self.main_widget().soundplayer.stop() self.liststore.clear() self.sounddir = self.conf['sounddir'] if not os.path.exists(self.sounddir): self.sounddir = "./sounds" # on Desktop if not os.path.exists(self.sounddir): self.main_widget().information_box(\ _("'Sounds' directory does not exist!")) return if os.listdir(self.sounddir): self.widgets["MediaDialog"].show() for fname in os.listdir(self.sounddir): if os.path.isfile(os.path.join(self.sounddir, fname)): sound_logo_file = os.path.join( \ self.conf["theme_path"], "soundlogo.png") pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(\ sound_logo_file, 100, 100) self.liststore.append([fname, "sound", fname, \ self.sounddir, pixbuf]) else: self.main_widget().information_box(\ _("There are no files in 'Sounds' directory!")) def get_widgets_data(self, check_for_required=True): """ Get data from widgets. """ fact = {} for fact_key, widget in self.selectors[self.card_type.id]["widgets"]: start, end = widget.get_buffer().get_bounds() fact[fact_key] = widget.get_buffer().get_text(start, end) if check_for_required: for required in self.card_type.required_fields: if not fact[required]: raise ValueError return fact def set_widgets_data(self, fact): """Set widgets data from fact.""" for fact_key, widget in self.selectors[self.card_type.id]["widgets"]: widget.get_buffer().set_text(fact[fact_key]) def clear_widgets(self): """Clear data in widgets.""" for caption in self.areas.keys(): self.areas[caption].get_buffer().set_text( \ "Type %s here..." % caption.upper()) def change_card_type_cb(self, widget): """Change cardtype when user choose it from cardtype column.""" self.main_widget().soundplayer.stop() self.clear_widgets() self.show_snd_container() self.set_card_type(widget) self.compose_widgets() def preview_sound_in_input_cb(self, widget): """Preview sound in input mode.""" if widget.get_active(): start, end = self.areas["question"].get_buffer().get_bounds() text = self.areas["question"].get_buffer().get_text(start, end) self.main_widget().soundplayer.play(text, self) else: self.main_widget().soundplayer.stop() def update_indicator(self): """Set non active state for widget.""" self.widgets["SoundIndicator"].set_active(False) def close_media_selection_dialog_cb(self, widget): """Close image selection dialog.""" self.widgets["MediaDialog"].hide() def show_add_category_block_cb(self, widget): """Show add category block.""" self.widgets["ChangeCategoryBlock"].hide() self.widgets["AddCategoryBlock"].show() self.widgets["NewCategory"].grab_focus() def hide_add_category_block_cb(self, widget): """Hide add category block.""" self.widgets["ChangeCategoryBlock"].show() self.widgets["AddCategoryBlock"].hide() def input_to_main_menu_cb(self, widget): """Return to main menu.""" #if self.added_new_cards: #self.review_controller().reset() #self.added_new_cards = False self.disconnect_signals() self.main_widget().soundplayer.stop() self.main_widget().menu_()
def update_data_flows(model, data_flow_dict, tree_dict_combos): """ Updates data flow dictionary and combo dictionary of the widget according handed model. :param model: model for which the data_flow_dict and tree_dict_combos should be updated :param data_flow_dict: dictionary that holds all internal and external data-flows and those respective row labels :param tree_dict_combos: dictionary that holds all internal and external data-flow-adaptation-combos :return: """ data_flow_dict['internal'] = {} data_flow_dict['external'] = {} tree_dict_combos['internal'] = {} tree_dict_combos['external'] = {} # free input ports and scopes are real to_keys and real states [free_to_port_internal, from_ports_internal] = find_free_keys(model) [free_to_port_external, from_ports_external] = find_free_keys(model.parent) def take_from_dict(from_dict, key): if key in from_dict: return from_dict[key] else: logger.warning("Key '%s' is not in %s" % (key, from_dict)) pass # from_state, to_key, to_state, to_key, external if isinstance(model, ContainerStateModel): for data_flow in model.state.data_flows.values(): # model.data_flow_list_store: # TREE STORE LABEL # check if from Self_state if data_flow.from_state == model.state.state_id: from_state = model.state from_state_label = 'self.' + model.state.name + '.' + data_flow.from_state else: if take_from_dict(model.state.states, data_flow.from_state): from_state = take_from_dict(model.state.states, data_flow.from_state) from_state_label = from_state.name + '.' + data_flow.from_state else: # print data_flow.from_state, data_flow.from_key, data_flow.to_state, data_flow.to_key logger.warning("DO break in ctrl/data_flow.py -1") break # check if to Self_state if data_flow.to_state == model.state.state_id: to_state = model.state to_state_label = 'self.' + model.state.name + '.' + data_flow.to_state else: if take_from_dict(model.state.states, data_flow.to_state): to_state = take_from_dict(model.state.states, data_flow.to_state) to_state_label = to_state.name + '.' + data_flow.to_state else: # print data_flow.from_state, data_flow.from_key, data_flow.to_state, data_flow.to_key logger.warning("DO break in ctrl/data_flow.py 0") break from_key_port = from_state.get_data_port_by_id(data_flow.from_key) from_key_label = '' if from_key_port is not None: from_key_label = PORT_TYPE_TAG.get(type(from_key_port), 'None') + '.' + \ from_key_port.data_type.__name__ + '.' + \ from_key_port.name to_key_port = to_state.get_data_port_by_id(data_flow.to_key) # to_key_label = '' if to_key_port is not None: to_key_label = PORT_TYPE_TAG.get(type(to_key_port), 'None') + '.' + \ (to_key_port.data_type.__name__ or 'None') + '.' + \ to_key_port.name data_flow_dict['internal'][data_flow.data_flow_id] = {'from_state': from_state_label, 'from_key': from_key_label, 'to_state': to_state_label, 'to_key': to_key_label} # ALL INTERNAL COMBOS from_states_store = ListStore(str) to_states_store = ListStore(str) if isinstance(model, ContainerStateModel): if model.state.state_id in free_to_port_internal or model.state.state_id == data_flow.to_state: to_states_store.append(['self.' + model.state.name + '.' + model.state.state_id]) if model.state.state_id in from_ports_internal or model.state.state_id == data_flow.from_state: from_states_store.append(['self.' + model.state.name + '.' + model.state.state_id]) for state_model in model.states.itervalues(): if state_model.state.state_id in free_to_port_internal or \ state_model.state.state_id == data_flow.to_state: to_states_store.append([state_model.state.name + '.' + state_model.state.state_id]) if state_model.state.state_id in from_ports_internal or \ state_model.state.state_id == data_flow.from_state: from_states_store.append([state_model.state.name + '.' + state_model.state.state_id]) from_keys_store = ListStore(str) if model.state.state_id == data_flow.from_state: # print "input_ports", model.state.input_data_ports # print type(model) if isinstance(model, ContainerStateModel): # print "scoped_variables", model.state.scoped_variables combined_ports = {} combined_ports.update(model.state.scoped_variables) combined_ports.update(model.state.input_data_ports) get_key_combos(combined_ports, from_keys_store, data_flow.from_key) else: get_key_combos(model.state.input_data_ports, from_keys_store, data_flow.from_key) else: # print "output_ports", model.states[data_flow.from_state].state.output_data_ports get_key_combos(model.state.states[data_flow.from_state].output_data_ports, from_keys_store, data_flow.from_key) to_keys_store = ListStore(str) if model.state.state_id == data_flow.to_state: # print "output_ports", model.state.output_data_ports # print type(model) if isinstance(model, ContainerStateModel): # print "scoped_variables", model.state.scoped_variables combined_ports = {} combined_ports.update(model.state.scoped_variables) combined_ports.update(model.state.output_data_ports) get_key_combos(combined_ports, to_keys_store, data_flow.to_key) else: get_key_combos(model.state.output_data_ports, to_keys_store, data_flow.to_key) else: # print "input_ports", model.states[data_flow.to_state].state.input_data_ports get_key_combos(model.state.states[data_flow.to_state].input_data_ports , to_keys_store, data_flow.to_key) tree_dict_combos['internal'][data_flow.data_flow_id] = {'from_state': from_states_store, 'from_key': from_keys_store, 'to_state': to_states_store, 'to_key': to_keys_store} # print "internal", data_flow_dict['internal'][data_flow.data_flow_id] if not model.state.is_root_state: for data_flow in model.parent.state.data_flows.values(): # model.parent.data_flow_list_store: # TREE STORE LABEL # check if from Self_state if model.state.state_id == data_flow.from_state: from_state = model.state from_state_label = 'self.' + model.state.name + '.' + data_flow.from_state else: if model.parent.state.state_id == data_flow.from_state: from_state = model.parent.state from_state_label = 'parent.' + model.parent.state.name + '.' + data_flow.from_state else: if take_from_dict(model.parent.state.states, data_flow.from_state): from_state = take_from_dict(model.parent.state.states, data_flow.from_state) from_state_label = from_state.name + '.' + data_flow.from_state else: # print "#", data_flow.from_state, data_flow.from_key, data_flow.to_state, data_flow.to_key logger.warning("DO break in ctrl/data_flow.py 1") break # check if to Self_state if model.state.state_id == data_flow.to_state: to_state = model.state to_state_label = 'self.' + model.state.name + '.' + data_flow.to_state else: if model.parent.state.state_id == data_flow.to_state: to_state = model.parent.state to_state_label = 'parent.' + model.parent.state.name + '.' + data_flow.to_state else: if take_from_dict(model.parent.state.states, data_flow.to_state): to_state = take_from_dict(model.parent.state.states, data_flow.to_state) to_state_label = to_state.name + '.' + data_flow.to_state else: # print "##", data_flow.from_state, data_flow.from_key, data_flow.to_state, data_flow.to_key logger.warning("DO break in ctrl/data_flow.py 2") break if model.state.state_id in [data_flow.from_state, data_flow.to_state]: from_key_port = from_state.get_data_port_by_id(data_flow.from_key) if from_key_port is None: continue from_key_label = PORT_TYPE_TAG.get(type(from_key_port), 'None') + '.' + \ from_key_port.data_type.__name__ + '.' + \ from_key_port.name to_key_port = to_state.get_data_port_by_id(data_flow.to_key) if to_key_port is None: continue to_key_label = PORT_TYPE_TAG.get(type(to_key_port), 'None') + '.' + \ to_key_port.data_type.__name__ + '.' + \ to_key_port.name data_flow_dict['external'][data_flow.data_flow_id] = {'from_state': from_state_label, 'from_key': from_key_label, 'to_state': to_state_label, 'to_key': to_key_label} # ALL EXTERNAL COMBOS if model.state.state_id in [data_flow.from_state, data_flow.to_state]: # only self-state from_states_store = ListStore(str) for state_id in from_ports_external.keys(): if model.parent.state.state_id == state_id: state_model = model.parent else: state_model = model.parent.states[state_id] if state_model.state.state_id == model.state.state_id: from_states_store.append(['self.' + state_model.state.name + '.' + state_model.state.state_id]) else: from_states_store.append([state_model.state.name + '.' + state_model.state.state_id]) # from_states_store.append(['self.' + model.state.name + '.' + model.state.state_id]) # only outports of self from_keys_store = ListStore(str) if model.parent.state.state_id == data_flow.from_state: # print "output_ports", model.parent.states[data_flow.from_state].state.output_data_ports combined_ports = {} combined_ports.update(model.parent.state.input_data_ports) combined_ports.update(model.parent.state.scoped_variables) get_key_combos(combined_ports, from_keys_store, data_flow.to_key) elif data_flow.from_state in [state_m.state.state_id for state_m in model.parent.states.values()]: get_key_combos(model.parent.state.states[data_flow.from_state].output_data_ports, from_keys_store, data_flow.to_key) else: logger.error( "---------------- FAILURE %s ------------- external from_state PARENT or STATES" % model.state.state_id) # all states and parent-state to_states_store = ListStore(str) for state_id in free_to_port_external.keys(): if model.parent.state.state_id == state_id: state_model = model.parent else: state_model = model.parent.states[state_id] if state_model.state.state_id == model.state.state_id: to_states_store.append(['self.' + state_model.state.name + '.' + state_model.state.state_id]) else: to_states_store.append([state_model.state.name + '.' + state_model.state.state_id]) # all keys of actual to-state to_keys_store = ListStore(str) if get_state_model(model.parent, data_flow.to_state): to_state_model = get_state_model(model.parent, data_flow.to_state) from_state_model = get_state_model(model.parent, data_flow.to_state) act_from_key_port = from_state_model.state.get_data_port_by_id(data_flow.from_key) act_to_key_port = to_state_model.state.get_data_port_by_id(data_flow.to_key) # first actual port to_keys_store.append([PORT_TYPE_TAG.get(type(act_to_key_port), 'None') + '.#' + str(act_to_key_port.data_port_id) + '.' + act_to_key_port.data_type.__name__ + '.' + act_to_key_port.name]) # second all other possible ones if to_state_model.state is model.state.parent: possible_port_ids = to_state_model.state.output_data_ports.keys() + to_state_model.state.scoped_variables.keys() else: possible_port_ids = to_state_model.state.input_data_ports.keys() for port_id in possible_port_ids: port = to_state_model.state.get_data_port_by_id(port_id) # to_state = get_state_model(model.parent, data_flow.to_state).state if not (PORT_TYPE_TAG.get(type(act_from_key_port), 'None') == 'SV' and port.data_port_id == data_flow.from_key)\ and port is not act_to_key_port: to_keys_store.append([PORT_TYPE_TAG.get(type(port), 'None') + '.#' + str(port.data_port_id) + '.' + port.data_type.__name__ + '.' + port.name]) tree_dict_combos['external'][data_flow.data_flow_id] = {'from_state': from_states_store, 'from_key': from_keys_store, 'to_state': to_states_store, 'to_key': to_keys_store} # print "external", data_flow_dict['external'][data_flow.data_flow_id] # print "ALL SCANNED: ", data_flow_dict['internal'].keys(), data_flow_dict['external'].keys(), \ # tree_dict_combos['internal'].keys(), tree_dict_combos['external'].keys() return free_to_port_internal, free_to_port_external, from_ports_internal, from_ports_external
class trustor_transactions(object): def __init__(self, trust_module, trustor, trust_manager): self.trust_module = trust_module self.trustor = trustor self.trust_manager = trust_manager self.init() self.extended_init() parent_window = trust_manager.top_window self.top_window.set_transient_for(parent_window) self.top_window.set_modal(True) def construct_filename(self, filename): import trustor_management as trust_module return join( dirname( abspath( trust_module.__file__ ) ), filename) def get_tran_type(self, transaction): if isinstance(transaction, TrustMoneyInTransaction): return 'In' elif isinstance(transaction, TrustMoneyOutTransaction): return 'Out' else: return 'unknown' def extended_init(self): self.widgets['name_entry'].set_text(self.trustor.name) self.widgets['name_entry'].connect('changed', self.on_name_entry_changed) self.widgets['dyn_balance'].set_text(str(self.trustor.get_balance())) self.transactions_view = self.widgets['transactions_view'] self.transactions_list = ListStore( str, str, str ) self.transactions_view.set_model(self.transactions_list) for i, title in enumerate(('Date', 'Type', 'Balance')): self.transactions_view.append_column( TreeViewColumn(title,CellRendererText(), text=i ) ) for transaction in self.trustor.transactions: self.transactions_list.append([transaction.trans_date.strftime("%B %d, %Y, %H:%M"), self.get_tran_type(transaction), str(transaction.get_transfer_amount())]) def init(self): filename = 'data/trustor_transactions.glade' top_window = 'window1' do_OldGladeWindowStyleConnect( self, self.construct_filename(filename), top_window) def generate_transaction_report(self, filename): report_file = open(filename, 'w') now = datetime.today() nowstring = now.strftime("%B %d, %Y, %H:%M") report_file.write("Trustor transaction report for " + self.trustor.name + " as at " + nowstring + "\n\n") for transaction in self.trustor.transactions: report_file.write(transaction.trans_date.strftime("%B %d, %Y, %H:%M") + ' ' + self.get_tran_type(transaction) + ' ' + str(transaction.get_transfer_amount()) + '\n') report_file.write('\ncurrent balance: ' + str(self.trustor.get_balance()) + '\n') report_file.close() def on_name_entry_changed(self, *args): current_name = self.trustor.name new_name = self.widgets['name_entry'].get_text() save_button = self.widgets['save_button'] if current_name != new_name and new_name != '': save_button.set_sensitive(True) else: save_button.set_sensitive(False) def on_report_button_clicked(self, *args): fcd = gtk.FileChooserDialog( "Choose report file and location", None, gtk.FILE_CHOOSER_ACTION_SAVE, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK) ) fcd.set_modal(True) result = fcd.run() file_path = fcd.get_filename() fcd.destroy() if result == gtk.RESPONSE_OK and file_path != None: self.generate_transaction_report(file_path) def on_save_button_clicked(self, *args): #we're updating the name of someone who already exists current_name = self.trustor.name new_name = self.widgets['name_entry'].get_text() self.trust_module.rename_trustor(current_name, new_name) # refresh view self.trust_manager.refresh_trustor_list() self.widgets['save_button'].set_sensitive(False)
def __create_model(self): from gtk import ListStore model = ListStore(str, str) return model
class confirm_dialog(Dialog): def __init__(self, parent, queues, icon): Dialog.__init__(self, _("Confirm"), parent, DIALOG_MODAL | DIALOG_DESTROY_WITH_PARENT, (STOCK_OK, RESPONSE_ACCEPT, STOCK_CANCEL, RESPONSE_REJECT)) self.set_icon(pixbuf_new_from_file(icon)) self._setup_trees(queues) self._setup_layout() def _setup_trees(self, queues): self._setup_install_tree(queues["add"]) self._setup_remove_tree (queues["remove"]) def _setup_install_tree(self, queue): self.install_tree = TreeView() self.install_model = ListStore(str, str, str) self.install_tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id=0) self.install_tree.insert_column_with_attributes(-1, _("Package"), CellRendererText(), text=1) self.install_tree.insert_column_with_attributes(-1, _("Version"), CellRendererText(), text=2) for pac in queue: if pac.isold: image = "yellow" elif pac.installed: image = "green" else: image = "red" self.install_model.append([image, pac.name, pac.version]) continue self.install_tree.set_model(self.install_model) return def _setup_remove_tree(self, queue): self.remove_tree = TreeView() self.remove_model = ListStore(str, str, str) self.remove_tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id=0) self.remove_tree.insert_column_with_attributes(-1, _("Package"), CellRendererText(), text=1) self.remove_tree.insert_column_with_attributes(-1, _("Version"), CellRendererText(), text=2) for pac in queue: if pac.isold: image = "yellow" elif pac.installed: image = "green" else: image = "red" self.remove_model.append([image, pac.name, pac.version]) continue self.remove_tree.set_model(self.remove_model) return def _setup_layout(self): hpaned = HPaned() label = Label(_("Are you sure you want to install/remove those packages?")) label.show() inst_frame = Frame(_("Packages to install")) rem_frame = Frame(_("Packages to remove")) inst_frame.add(self.install_tree) rem_frame.add(self.remove_tree) hpaned.add1(inst_frame) hpaned.add2(rem_frame) hpaned.show_all() self.vbox.pack_start(label, False, False, 0) self.vbox.pack_start(hpaned, True, True, 0) return def run(self): response = Dialog.run(self) self.destroy() if response == RESPONSE_ACCEPT: return True else: return False
def create_editable_type_defined_listview_and_model( field_list, new_row_func, parralell_list, change_register, readonly=False, insert_pre_hook=null_function, insert_post_hook=null_function, change_pre_hook=null_function, change_post_hook=null_function, del_pre_hook=null_function, del_post_hook=null_function): vbox = VBox() tv = TreeView() model = ListStore( * chain((display_fieldtype_transform(fieldtype) for fieldname, fieldtype in field_list), (store_fieldtype_transform(fieldtype) for fieldname, fieldtype in field_list) ) # chain ) # ListStore # it is important to do this fill of the liststore # with the existing items first prior to adding event handlers # (row-changed, row-inserted, row-deleted) that # look for changes and keep the two lists in sync for list_row in parralell_list: model.append( tuple(transform_list_row_into_twice_repeated_row_for_model( list_row, field_list) ) ) # append if not readonly: model.connect("row-changed", row_changed_handler, parralell_list, change_register, field_list, change_pre_hook, change_post_hook, ) model.connect("row-inserted", row_inserted_handler, parralell_list, change_register, insert_pre_hook, insert_post_hook ) model.connect("row-deleted", row_deleted_handler, parralell_list, change_register, del_pre_hook, del_post_hook) for i, (fieldname, fieldtype) in enumerate(field_list): def setup_edited_handler_for_renderer_to_original_model(cell_renderer): cell_renderer.connect( 'edited', cell_edited_update_original_modelhandler, model, i, field_list[i][FIELD_TYPE]) return cell_renderer if fieldtype == date: cell_renderer = \ setup_edited_handler_for_renderer_to_original_model( CellRendererDate() ) elif type(fieldtype) == tuple: cell_renderer = CellRendererCombo() cell_renderer.set_property("has-entry", fieldtype[COMBO_TYPE_HAS_ENTRY_FIELD]) combo_liststore = ListStore( str, store_fieldtype_transform(fieldtype) ) for combo_string, combo_value in \ combobox_list_strings_and_values_iteration(fieldtype): combo_liststore.append( (combo_string, combo_value) ) cell_renderer.set_property("model", combo_liststore) cell_renderer.set_property("text-column", 0) if fieldtype[COMBO_TYPE_HAS_ENTRY_FIELD]: setup_edited_handler_for_renderer_to_original_model( cell_renderer) else: lookup_dict = dict( combobox_list_strings_and_values_iteration(fieldtype) ) cell_renderer.connect( 'edited', combo_cell_edited_update_original_modelhandler, model, i, lookup_dict) elif type(fieldtype) == dict and fieldtype['type'] == file: cell_renderer = CellRendererFile( fieldtype['file_type'] if 'file_type' in fieldtype else FILE_CHOOSER_ACTION_OPEN ) setup_edited_handler_for_renderer_to_original_model(cell_renderer) else: cell_renderer = \ setup_edited_handler_for_renderer_to_original_model( CellRendererText() ) if not readonly: cell_renderer.set_property("editable", True) cell_renderer.set_property("editable-set", True) tvc = TreeViewColumn(fieldname, cell_renderer, text=i) tv.append_column(tvc) vbox.pack_start(tv) tv.set_model(model) hbox = HBox() buttons = [ pack_in_stock_but_and_ret(start_stock_button(code), hbox) for code in (STOCK_ADD, STOCK_DELETE) ] if readonly: for button in buttons: button.set_property("sensitive", False) else: buttons[0].connect( "clicked", editable_listview_add_button_clicked_handler, model, new_row_func, field_list ) buttons[1].connect( "clicked", editable_listview_del_button_clicked_handler, tv ) vbox.pack_start(hbox, expand=False) return model, tv, vbox
class trustor_management(object): def __init__(self, trust_module, parent_window, backend_account_fetch): self.backend_account_fetch = backend_account_fetch self.trust_module = trust_module self.trustors = self.trust_module.get_trustors() self.current_name = None self.init() if parent_window != None: self.top_window.set_transient_for(parent_window) self.top_window.set_modal(True) self.extended_init() if hasattr(self.trust_module, 'trust_liability_account_str'): self.widgets['trust_liability_account_label'].set_text( self.trust_module.trust_liability_account_str) if hasattr(self.trust_module, 'cash_account_str'): self.widgets['cash_account_label'].set_text( self.trust_module.cash_account_str ) self.widgets['currency_text_entry'].set_text( self.trust_module.get_currency() ) self.widgets['TrustManagement'].run() self.widgets['TrustManagement'].destroy() def construct_filename(self, filename): import trustor_management as trust_module return join( dirname( abspath( trust_module.__file__ ) ), filename) def reset_view(self): if self.trustor_view.get_column(0) == None: #no columns to remove return while self.trustor_view.remove_column(self.trustor_view.get_column(0)) > 0: pass def refresh_trustor_list(self): self.reset_view() self.trustor_list = ListStore( str, str ) self.trustor_view.set_model(self.trustor_list) for i, title in enumerate(('Trustor', 'Balance')): self.trustor_view.append_column( TreeViewColumn(title,CellRendererText(), text=i ) ) for trustor in self.trustors: self.trustor_list.append([trustor, str(self.trustors[trustor].get_balance())]) def extended_init(self): self.trustor_view = self.widgets['trustor_view'] self.refresh_trustor_list() def init(self): filename = 'data/trustor_management.glade' top_window = 'TrustManagement' do_OldGladeWindowStyleConnect( self, self.construct_filename(filename), top_window) def on_add_button_clicked(self, *args): # Ask the user for a new trustor's name. md = MessageDialog(parent = self.top_window, type = MESSAGE_QUESTION, buttons = BUTTONS_OK_CANCEL, message_format = "What's the new trustor's name?") vbox = md.get_child() name_entry = Entry() vbox.pack_end(name_entry) vbox.show_all() r = md.run() new_trustor_name = name_entry.get_text() md.destroy() # destroys embedded widgets too # Save the new trustor. if r == RESPONSE_OK and new_trustor_name != '': self.current_name = new_trustor_name self.trust_module.add_trustor_by_name(new_trustor_name) transaction.get().commit() self.refresh_trustor_list() def on_remove_button_clicked(self, *args): trustor = self.trust_module.get_trustor(self.current_name) if len(trustor.transactions) > 0: cantDeleteDia = MessageDialog( flags = DIALOG_MODAL, message_format = 'Cannot delete, trustor has associated transacactions.', buttons = BUTTONS_OK) cantDeleteDia.run() cantDeleteDia.hide() else: self.trust_module.drop_trustor_by_name(self.current_name) transaction.get().commit() # Update the view. self.widgets['remove_button'].set_sensitive(False) self.widgets['details_button'].set_sensitive(False) self.refresh_trustor_list() def on_details_button_clicked(self, *args): if self.current_name != None: trustor = self.trust_module.get_trustor(self.current_name) trans = trustor_transactions(self.trust_module, trustor, self) def set_trustor(self, trustor_selected): trustor = self.trust_module.get_trustor(trustor_selected) self.current_name = trustor.name def on_trustor_view_cursor_changed(self, *args): sel = self.trustor_view.get_selection() sel_iter = sel.get_selected()[1] if sel_iter != None: # If the user clicked a row as opposed to whitespace... sel_row = self.trustor_list[sel_iter] trustor_selected = sel_row[0] self.set_trustor(trustor_selected) # Update the view. self.widgets['remove_button'].set_sensitive(True) self.widgets['details_button'].set_sensitive(True) def generate_balance_report(self, filename): report_file = open(filename, 'w') now = datetime.today() nowstring = now.strftime("%B %d, %Y, %H:%M") report_file.write("Trustor balance report as at " + nowstring + "\n\n") for trustor in self.trustors: report_file.write(trustor + ' ' + str(self.trustors[trustor].get_balance()) + '\n') report_file.close() def on_report_button_clicked(self, *args): fcd = FileChooserDialog("Choose report file and location", None, FILE_CHOOSER_ACTION_SAVE, (STOCK_CANCEL, RESPONSE_CANCEL, STOCK_SAVE, RESPONSE_OK)) fcd.set_modal(True) result = fcd.run() file_path = fcd.get_filename() fcd.destroy() if result == RESPONSE_OK and file_path != None: self.generate_balance_report(file_path) def handle_account_fetch(self, label, setter): account_spec, account_str = self.backend_account_fetch( self.top_window) if account_spec != None: setter(account_spec, account_str) label.set_text(account_str) def on_select_trust_liability_clicked(self, *args): self.handle_account_fetch( self.widgets['trust_liability_account_label'], self.trust_module.set_trust_liability_account ) def on_select_cash_account_clicked(self, *args): self.handle_account_fetch( self.widgets['cash_account_label'], self.trust_module.set_cash_account ) def currency_text_entry_changed(self, *args): self.trust_module.currency = \ self.widgets['currency_text_entry'].get_text() transaction.get().commit()
def __create_model(self): from gtk import ListStore from gobject import TYPE_STRING model = ListStore(TYPE_STRING, TYPE_STRING) return model
class upgrade_dialog(Window): def __init__(self, to_upgrade, icon): Window.__init__(self, WINDOW_TOPLEVEL) self.set_property("skip-taskbar-hint", True) self.set_property("modal", True) self.set_property("destroy-with-parent", True) self.set_position(WIN_POS_CENTER) self.set_default_size (300, 300) self.set_icon(pixbuf_new_from_file(icon)) self._setup_tree(to_upgrade) self._setup_layout() def _setup_layout(self): self.vbox = VBox(False, 0) self.vbox.show() self.terminal = terminal() self.terminal.connect("child-exited", lambda _: self.close_button.show()) self.expander = expander_new_with_mnemonic(_("_Terminal")) self.expander.set_expanded(False) self.expander.add(self.terminal) self.expander.show_all() self.close_button = Button(stock=STOCK_CLOSE) self.close_button.connect("clicked", lambda _: self.destroy()) scr = ScrolledWindow() scr.set_policy ("automatic", "automatic") scr.add (self.tree) scr.show() vpaned = VPaned() vpaned.add1(scr) vpaned.add2(self.expander) vpaned.set_position (260) vpaned.show() self.vbox.pack_start(vpaned, True, True, 0) self.vbox.pack_start(self.close_button, False, False, 0) self.add(self.vbox) return def _setup_tree(self, pacs): self.model = ListStore(str, str, str) for pac in pacs: self.model.append(["yellow", pac.name, pac.version]) continue self.tree = TreeView() self.tree.show() self.tree.insert_column_with_attributes(-1, "", CellRendererPixbuf(), stock_id = 0) self.tree.insert_column_with_attributes(-1, "Package", CellRendererText(), text = 1) self.tree.insert_column_with_attributes(-1, "Version", CellRendererText(), text = 2) self.tree.set_model(self.model) return def run(self): self.show() self.terminal.do_upgrade()
class trustor_entry(object): def __init__(self, trust_trans, trans_id, trust_module, gui_parent, editable, change_register_function): self.change_register_function = change_register_function self.gui_built = False self.trust_trans = trust_trans self.trans_id = trans_id self.trust_module = trust_module self.trustors = self.trust_module.get_trustors() self.editable = editable self.trans_trustor = self.trust_trans.get_trustor() import trustor_entry as plugin_mod filename = get_file_in_same_dir_as_module(plugin_mod, 'data/trustor_entry.glade') load_glade_file_get_widgets_and_connect_signals( glade_file = filename, root_widget = 'window1', widget_holder = self, signal_recipient = self) self.extended_init() if not gui_parent == None: self.table.reparent(gui_parent) buff = self.description_textview.get_buffer() buff.connect("changed", self.description_changed, None) self.window1.hide() self.gui_built = True self.update_trans() # save new transaction immediately after creation def description_changed(self, textbuffer, args): if self.gui_built: self.update_trans() def detach(self): self.table.reparent(self.window1) def extended_init(self): self.trustor_list = ListStore( str ) self.trustor_combo.set_model(self.trustor_list) index = 0 use_index = -1 for trustor_name in self.trustors: self.trustor_list.append([trustor_name]) if not(self.trans_trustor == None) and self.trans_trustor.name == trustor_name: use_index = index index += 1 if use_index > -1: self.trustor_combo.set_active(use_index) self.amount_entry.set_text(str(self.trust_trans.get_displayable_amount())) self.description_textview.get_buffer().set_text(str(self.trust_trans.get_memo())) else: self.trustor_combo.set_active(0) trans_date = self.trust_trans.trans_date self.entry_date_label.set_text( "%s-%s-%s" % (trans_date.year, trans_date.month, trans_date.day) ) if not self.editable or self.trust_trans.get_trustor() == None : self.amount_entry.set_sensitive(False) def construct_filename(self, filename): import trustor_entry as trust_module return join( dirname( abspath( trust_module.__file__ ) ), filename) def update_trans(self): entered_amount = self.amount_entry.get_text() try: self.trust_trans.transfer_amount = Decimal(entered_amount) except InvalidOperation: # In case the user has entered something like "" or ".". self.trust_trans.transfer_amount = Decimal('0') textbuff = self.description_textview.get_buffer() entered_description = textbuff.get_text(textbuff.get_start_iter(), textbuff.get_end_iter()) self.trust_trans.memo = entered_description self.change_register_function() trustor = self.trust_module.get_trustor(self.trustor_combo.get_active_text()) if not(trustor == None): self.trust_module.associate_transaction_with_trustor(self.trans_id, self.trust_trans, trustor.name) def on_window_destroy(self, *args): if self.editable: self.update_trans() main_quit() def on_trustor_combo_changed(self, *args): if self.gui_built: self.update_trans() def on_amount_entry_changed(self, *args): if self.gui_built: self.update_trans()
def __create_model(self): from gtk import ListStore from gobject import TYPE_BOOLEAN model = ListStore(TYPE_BOOLEAN, str, str) return model
def create_model(self): return ListStore(int, str)
def __init__(self, objectives, new): Expander.__init__(self) self.connect("enter-notify-event", self.onEnterNotifyEvent) self.connect("leave-notify-event", self.onLeaveNotifyEvent) vBox = VBox() self.add(vBox) # Data model self.model = ListStore(str, float) # Title bar hBox = HBox() self.set_property("label-widget", hBox) self.title = Label() hBox.pack_start(self.title) # Alternatives treeView = TreeView(self.model) # treeView.set_headers_visible(False) vBox.pack_start(treeView) listStore_objectives = ListStore(str) for name in objectives: listStore_objectives.append((name, )) def combo_changed(_, path, text, model): model[path][0] = text cellRenderer = CellRendererCombo() cellRenderer.connect("edited", combo_changed, self.model) cellRenderer.set_property("text-column", 0) cellRenderer.set_property("editable", True) cellRenderer.set_property("has-entry", True) cellRenderer.set_property("model", listStore_objectives) treeViewColumn = TreeViewColumn("Alternative", cellRenderer, text=0) # treeViewColumn = TreeViewColumn(None,cellRenderer,text=0) treeView.append_column(treeViewColumn) def spin_changed(_, path, value, model): model[path][1] = float(value.replace(",", ".")) cellRenderer = CellRendererSpin() cellRenderer.connect("edited", spin_changed, self.model) cellRenderer.set_property("adjustment", Adjustment(1, 0, 100, 1, 10, 0)) cellRenderer.set_property("editable", True) cellRenderer.set_property("digits", 2) treeViewColumn = TreeViewColumn(None, cellRenderer, text=1) treeView.append_column(treeViewColumn) # Add/remove alternative button box # hButtonBox = HButtonBox() # vBox.pack_start(hButtonBox, False) # Add alternative button = Button("gtk-add") button.connect("clicked", self.on_btnAdd_Alternative_clicked) button.set_use_stock(True) # hButtonBox.pack_start(button) vBox.pack_start(button, False) # # Remove alternative # button = Button("gtk-remove") # button.connect("clicked",self.on_btnDel_Alternative_clicked) # button.set_use_stock(True) # hButtonBox.pack_start(button) # Expand the requirement and add an alternative if it's new if new: self.set_expanded(True) self.model.append((None, 1.0)) # Show requirement self.show_all() # Delete requirement button (default is hidden) self.imgRemove = Image() self.imgRemove.connect("button-press-event", self.onDelRequirement) self.imgRemove.set_from_stock("gtk-cancel", ICON_SIZE_MENU) hBox.pack_start(self.imgRemove)