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)
