def __init__(self, keypresses=(), name=None, label=None, tooltip=None, stock_id=None):
"""
Create a new Action instance.
@param key_presses a tuple of (keyval1, mod_mask1, keyval2, mod_mask2, ...)
@param the regular gtk.Action parameters (defaults to None)
"""
if name is None: name = label
gtk.Action.__init__(self,
name=name, label=label,
tooltip=tooltip, stock_id=stock_id,
)
#register this action
_all_actions_list.append(self)
for i in range(len(keypresses)/2):
keyval, mod_mask = keypresses[i*2:(i+1)*2]
#register this keypress
if _actions_keypress_dict.has_key((keyval, mod_mask)):
raise KeyError('keyval/mod_mask pair already registered "%s"'%str((keyval, mod_mask)))
_actions_keypress_dict[(keyval, mod_mask)] = self
#set the accelerator group, and accelerator path
#register the key name and mod mask with the accelerator path
if label is None: continue #dont register accel
accel_path = '<main>/'+self.get_name()
self.set_accel_group(get_accel_group())
self.set_accel_path(accel_path)
gtk.accel_map_add_entry(accel_path, keyval, mod_mask)
def _setup_menus(self):
mnu_transfer = self.mainview.gui.get_object('mnu_placnext')
self.mnui_edit = self.mainview.gui.get_object('menuitem_edit')
self.menu = self.mnui_edit.get_submenu()
self.mnu_select_files, _menu = self.mainview.find_menu_item(_('Terminology _Files...'), self.mnui_edit)
if not self.mnu_select_files:
self.mnu_select_files = self.mainview.append_menu_item(_('Terminology _Files...'), self.mnui_edit, after=mnu_transfer)
self._signal_ids.append((
self.mnu_select_files,
self.mnu_select_files.connect('activate', self._on_select_term_files)
))
self.mnu_add_term, _menu = self.mainview.find_menu_item(_('Add _Term...'), self.mnui_edit)
if not self.mnu_add_term:
self.mnu_add_term = self.mainview.append_menu_item(_('Add _Term...'), self.mnui_edit, after=mnu_transfer)
self._signal_ids.append((
self.mnu_add_term,
self.mnu_add_term.connect('activate', self._on_add_term)
))
gtk.accel_map_add_entry("<Virtaal>/Terminology/Add Term", gtk.keysyms.t, gdk.CONTROL_MASK)
accel_group = self.menu.get_accel_group()
if accel_group is None:
accel_group = gtk.AccelGroup()
self.menu.set_accel_group(accel_group)
self.mnu_add_term.set_accel_path("<Virtaal>/Terminology/Add Term")
self.menu.set_accel_group(accel_group)
def register_shortcut(name, accel, category, desc):
registered_shortcuts[name] = category, desc
key, modifier = gtk.accelerator_parse(accel)
path = get_path_by_name(name)
default_shortcuts[path] = (key, modifier)
gtk.accel_map_add_entry(path, key, modifier)
return path
def _setup_key_bindings(self):
"""Setup Gtk+ key bindings (accelerators)."""
gtk.accel_map_add_entry("<Virtaal>/View/IPython Console", gtk.keysyms.y, gdk.CONTROL_MASK)
self.accel_group = gtk.AccelGroup()
self.accel_group.connect_by_path("<Virtaal>/View/IPython Console", self._on_menuitem_activated)
self.main_controller.view.add_accel_group(self.accel_group)
def add(self, parent, child, properties, type):
accel_key = child.get_data('accel_key')
if accel_key:
accel_path = "<Actions>/%s/%s" % (parent.get_property('name'),
child.get_name())
accel_mod = child.get_data('accel_mod')
gtk.accel_map_add_entry(accel_path, accel_key, accel_mod)
child.set_accel_path(accel_path)
child.set_accel_group(self._build.ensure_accel())
parent.add_action(child)
def _add_accelerator_bindings(self):
gtk.accel_map_add_entry("<Virtaal>/Navigation/Up", gtk.accelerator_parse("Up")[0], gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<Virtaal>/Navigation/Down", gtk.accelerator_parse("Down")[0], gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<Virtaal>/Navigation/PgUp", gtk.accelerator_parse("Page_Up")[0], gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<Virtaal>/Navigation/PgDown", gtk.accelerator_parse("Page_Down")[0], gtk.gdk.CONTROL_MASK)
self.accel_group = gtk.AccelGroup()
self.accel_group.connect_by_path("<Virtaal>/Navigation/Up", self._treeview._move_up)
self.accel_group.connect_by_path("<Virtaal>/Navigation/Down", self._treeview._move_down)
self.accel_group.connect_by_path("<Virtaal>/Navigation/PgUp", self._treeview._move_pgup)
self.accel_group.connect_by_path("<Virtaal>/Navigation/PgDown", self._treeview._move_pgdown)
mainview = self.controller.main_controller.view
mainview.add_accel_group(self.accel_group)
mainview.gui.get_object('menu_navigation').set_accel_group(self.accel_group)
self.mnu_up = mainview.gui.get_object('mnu_up')
self.mnu_down = mainview.gui.get_object('mnu_down')
self.mnu_pageup = mainview.gui.get_object('mnu_pageup')
self.mnu_pagedown = mainview.gui.get_object('mnu_pagedown')
self.mnu_up.set_accel_path('<Virtaal>/Navigation/Up')
self.mnu_down.set_accel_path('<Virtaal>/Navigation/Down')
self.mnu_pageup.set_accel_path('<Virtaal>/Navigation/PgUp')
self.mnu_pagedown.set_accel_path('<Virtaal>/Navigation/PgDown')
self._set_menu_items_sensitive(False)
def __init__(self, plugin, window): self._window = window self._plugin = plugin self._entry = None accel_path = '<gedit>/plugins/commander/activate' accel = gtk.accel_map_lookup_entry(accel_path) if accel == None: gtk.accel_map_add_entry(accel_path, gtk.keysyms.period, gtk.gdk.CONTROL_MASK) self._accel = gtk.AccelGroup() self._accel.connect_by_path(accel_path, self._do_command) self._window.add_accel_group(self._accel)
def _setup_key_bindings(self):
"""Setup Gtk+ key bindings (accelerators).
This method *may* need to be moved into a view object, but if it is,
it will be the only functionality in such a class. Therefore, it
is done here. At least for now."""
gtk.accel_map_add_entry("<Virtaal>/Edit/Undo", gtk.keysyms.z, gdk.CONTROL_MASK)
self.accel_group = gtk.AccelGroup()
# The following line was commented out, because it caused a double undo when pressing
# Ctrl+Z, but only one if done through the menu item. This way it all works as expected.
#self.accel_group.connect_by_path("<Virtaal>/Edit/Undo", self._on_undo_activated)
mainview = self.main_controller.view # FIXME: Is this acceptable?
mainview.add_accel_group(self.accel_group)
def __init__(self, label, keypresses):
_all_actions_list.append(self)
for i in range(len(keypresses)/2):
keyval, mod_mask = keypresses[i*2:(i+1)*2]
#register this keypress
if _actions_keypress_dict.has_key((keyval, mod_mask)):
raise KeyError('keyval/mod_mask pair already registered "%s"'%str((keyval, mod_mask)))
_actions_keypress_dict[(keyval, mod_mask)] = self
#set the accelerator group, and accelerator path
#register the key name and mod mask with the accelerator path
if label is None: continue #dont register accel
accel_path = '<main>/'+self.get_name()
self.set_accel_group(get_accel_group())
self.set_accel_path(accel_path)
gtk.accel_map_add_entry(accel_path, keyval, mod_mask)
def _setup_menu_item(self):
self.menu = self.main_controller.view.gui.get_widget('menu_view')
self.menuitem = gtk.MenuItem(label=_('P_ython Console'))
self.menuitem.show()
self.menu.append(self.menuitem)
gtk.accel_map_add_entry("<Virtaal>/View/Python Console", gtk.keysyms.F9, 0)
accel_group = self.menu.get_accel_group()
if accel_group is None:
accel_group = self.accel_group
self.menu.set_accel_group(self.accel_group)
self.menuitem.set_accel_path("<Virtaal>/View/Python Console")
self.menu.set_accel_group(accel_group)
self.menuitem.connect('activate', self._on_menuitem_activated)
def _setup_key_bindings(self):
"""Setup Gtk+ key bindings (accelerators)."""
gtk.accel_map_add_entry("<Virtaal>/TM/Hide TM", gtk.keysyms.Escape, 0)
self.accel_group = gtk.AccelGroup()
self.accel_group.connect_by_path("<Virtaal>/TM/Hide TM", self._on_hide_tm)
# Connect Ctrl+n (1 <= n <= 9) to select match n.
for i in range(1, 10):
numstr = str(i)
numkey = gtk.keysyms._0 + i
gtk.accel_map_add_entry("<Virtaal>/TM/Select match " + numstr, numkey, gdk.CONTROL_MASK)
self.accel_group.connect_by_path("<Virtaal>/TM/Select match " + numstr, self._on_select_match)
mainview = self.controller.main_controller.view
mainview.add_accel_group(self.accel_group)
def _setup_menu_items(self):
mainview = self.controller.main_controller.view
menubar = mainview.menubar
self.mnui_view = mainview.gui.get_widget('menuitem_view')
self.menu = self.mnui_view.get_submenu()
self.mnu_suggestions = gtk.CheckMenuItem(label=_('Translation _Suggestions'))
self.mnu_suggestions.show()
self.menu.append(self.mnu_suggestions)
gtk.accel_map_add_entry("<Virtaal>/TM/Toggle Show TM", gtk.keysyms.F9, 0)
accel_group = self.menu.get_accel_group()
if accel_group is None:
accel_group = self.accel_group
self.menu.set_accel_group(self.accel_group)
self.mnu_suggestions.set_accel_path("<Virtaal>/TM/Toggle Show TM")
self.menu.set_accel_group(accel_group)
self.mnu_suggestions.connect('toggled', self._on_toggle_show_tm)
self.mnu_suggestions.set_active(True)
def _setup_accel(widget, name, shortcut=None):
"""Setup accelerators for a menu item.
This method sets an accel path for the widget and optionally connects a
shortcut to that accel path.
"""
# The GTK docs say that we should set the path using this form:
# <Window-Name>/Menu/Submenu/MenuItem
# ...but this is hard to do because we don't yet know what window/menu
# this menu item is going to be added to. gtk.Action and gtk.ActionGroup
# don't follow the above suggestion, so we don't need to either.
path = "<MiroActions>/MenuBar/%s" % name
widget.set_accel_path(path)
if shortcut is not None:
accel_string = keymap.get_accel_string(shortcut)
key, mods = gtk.accelerator_parse(accel_string)
if gtk.accel_map_lookup_entry(path) is None:
gtk.accel_map_add_entry(path, key, mods)
else:
gtk.accel_map_change_entry(path, key, mods, True)
def _setup_key_bindings(self):
gtk.accel_map_add_entry("<Virtaal>/Edit/Search", gtk.keysyms.F3, 0)
gtk.accel_map_add_entry("<Virtaal>/Edit/Search Ctrl+F", gtk.keysyms.F, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<Virtaal>/Edit/Search: Next", gtk.keysyms.G, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<Virtaal>/Edit/Search: Previous", gtk.keysyms.G, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
self.accel_group = gtk.AccelGroup()
self.accel_group.connect_by_path("<Virtaal>/Edit/Search", self._on_start_search)
self.accel_group.connect_by_path("<Virtaal>/Edit/Search Ctrl+F", self._on_start_search)
self.accel_group.connect_by_path("<Virtaal>/Edit/Search: Next", self._on_search_next)
self.accel_group.connect_by_path("<Virtaal>/Edit/Search: Previous", self._on_search_prev)
self.controller.main_controller.view.add_accel_group(self.accel_group)
def __init__(self):
gtk.HBox.__init__(self, False, 4)
gconf_client.add_dir(self.GCONF_PROFILE_DIR,
gconf.CLIENT_PRELOAD_RECURSIVE)
self._vte = vte.Terminal()
self.reconfigure_vte()
self._vte.set_size(self._vte.get_column_count(), 5)
self._vte.set_size_request(200, 50)
self._vte.show()
self.pack_start(self._vte)
self._scrollbar = gtk.VScrollbar(self._vte.get_adjustment())
self._scrollbar.show()
self.pack_start(self._scrollbar, False, False, 0)
gconf_client.notify_add(self.GCONF_PROFILE_DIR,
self.on_gconf_notification)
# we need to reconf colors if the style changes
self._vte.connect("style-set", lambda term, oldstyle: self.reconfigure_vte())
self._vte.connect("key-press-event", self.on_vte_key_press)
self._vte.connect("button-press-event", self.on_vte_button_press)
self._vte.connect("popup-menu", self.on_vte_popup_menu)
self._vte.connect("child-exited", lambda term: term.fork_command())
self._accel_base = '<gedit>/plugins/terminal'
self._accels = {
'copy-clipboard': [gtk.keysyms.C, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK, self.copy_clipboard],
'paste-clipboard': [gtk.keysyms.V, gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK, self.paste_clipboard]
}
for name in self._accels:
path = self._accel_base + '/' + name
accel = gtk.accel_map_lookup_entry(path)
if accel == None:
gtk.accel_map_add_entry(path, self._accels[name][0], self._accels[name][1])
self._vte.fork_command()
def _setup_menus(self):
def get_focused(widgets):
for textview in widgets:
if textview.is_focus():
return textview
return None
clipboard = gtk.Clipboard(selection=gtk.gdk.SELECTION_CLIPBOARD)
def on_cut(menuitem):
focused = get_focused(self.targets)
if focused is not None:
focused.get_buffer().cut_clipboard(clipboard, True)
def on_copy(menuitem):
focused = get_focused(self.targets + self.sources)
if focused is not None:
focused.get_buffer().copy_clipboard(clipboard)
def on_paste(menuitem):
focused = get_focused(self.targets)
if focused is not None:
focused.get_buffer().paste_clipboard(clipboard, None, True)
maingui = self.controller.main_controller.view.gui
self.mnu_cut = maingui.get_object('mnu_cut')
self.mnu_copy = maingui.get_object('mnu_copy')
self.mnu_paste = maingui.get_object('mnu_paste')
self.mnu_cut.connect('activate', on_cut)
self.mnu_copy.connect('activate', on_copy)
self.mnu_paste.connect('activate', on_paste)
# And now for the "Transfer from source" and placeable selection menu items
mnu_next = maingui.get_object('mnu_placnext')
mnu_prev = maingui.get_object('mnu_placprev')
mnu_transfer = maingui.get_object('mnu_transfer')
self.mnu_next = mnu_next
self.mnu_prev = mnu_prev
self.mnu_transfer = mnu_transfer
menu_edit = maingui.get_object('menu_edit')
def on_next(*args):
self.targets[self.focused_target_n].move_elem_selection(1)
def on_prev(*args):
self.targets[self.focused_target_n].move_elem_selection(-1)
def on_transfer(*args):
ev = gtk.gdk.Event(gtk.gdk.KEY_PRESS)
ev.state = gtk.gdk.MOD1_MASK
ev.keyval = gtk.keysyms.Down
ev.window = self.targets[self.focused_target_n].get_window(
gtk.TEXT_WINDOW_WIDGET)
ev.put()
mnu_next.connect('activate', on_next)
mnu_prev.connect('activate', on_prev)
mnu_transfer.connect('activate', on_transfer)
gtk.accel_map_add_entry("<Virtaal>/Edit/Next Placeable",
gtk.keysyms.Right, gtk.gdk.MOD1_MASK)
gtk.accel_map_add_entry("<Virtaal>/Edit/Prev Placeable",
gtk.keysyms.Left, gtk.gdk.MOD1_MASK)
gtk.accel_map_add_entry("<Virtaal>/Edit/Transfer", gtk.keysyms.Down,
gtk.gdk.MOD1_MASK)
accel_group = menu_edit.get_accel_group()
if not accel_group:
accel_group = gtk.AccelGroup()
self.controller.main_controller.view.add_accel_group(accel_group)
menu_edit.set_accel_group(accel_group)
mnu_next.set_accel_path("<Virtaal>/Edit/Next Placeable")
mnu_prev.set_accel_path("<Virtaal>/Edit/Prev Placeable")
mnu_transfer.set_accel_path("<Virtaal>/Edit/Transfer")
# Disable the menu items to start with, because we can't assume that a
# store is loaded. See _set_menu_items_sensitive() for more activation.
self._set_menu_items_sensitive(False)
def on_store_closed(*args):
mnu_next.set_sensitive(False)
mnu_prev.set_sensitive(False)
mnu_transfer.set_sensitive(False)
self.mnu_cut.set_sensitive(False)
self.mnu_copy.set_sensitive(False)
self.mnu_paste.set_sensitive(False)
def on_store_loaded(*args):
mnu_next.set_sensitive(True)
mnu_prev.set_sensitive(True)
mnu_transfer.set_sensitive(True)
self.mnu_cut.set_sensitive(True)
self.mnu_copy.set_sensitive(True)
self.mnu_paste.set_sensitive(True)
self.controller.main_controller.store_controller.connect(
'store-closed', on_store_closed)
self.controller.main_controller.store_controller.connect(
'store-loaded', on_store_loaded)
def __init__(self):
# initialize the window. explicitly set it to None first, so that the
# creator knows it doesn't yet exist.
self.window = None
self.create_hamster_window()
self.new_name.grab_focus()
# configuration
self.workspace_tracking = conf.get("workspace_tracking")
conf.connect('conf-changed', self.on_conf_changed)
# Load today's data, activities and set label
self.last_activity = None
self.todays_facts = None
runtime.storage.connect('activities-changed',self.after_activity_update)
runtime.storage.connect('facts-changed',self.after_fact_update)
runtime.storage.connect('toggle-called', self.on_toggle_called)
self.screen = None
if self.workspace_tracking:
self.init_workspace_tracking()
# refresh hamster every 60 seconds
gobject.timeout_add_seconds(60, self.refresh_hamster)
self.prev_size = None
# bindings
self.accel_group = self.get_widget("accelgroup")
self.window.add_accel_group(self.accel_group)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/add", gtk.keysyms.n, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/overview", gtk.keysyms.o, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/stats", gtk.keysyms.i, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/close", gtk.keysyms.Escape, 0)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/quit", gtk.keysyms.q, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/edit/prefs", gtk.keysyms.p, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/help/contents", gtk.keysyms.F1, 0)
# create the status icon
self.statusicon = ProjectHamsterStatusIcon(self)
self.reposition_hamster_window()
self.show_hamster_window()
self.show_in_tray()
def _setup_key_bindings(self):
gtk.accel_map_add_entry("<Virtaal>/Edit/Preferences", gtk.keysyms.p, gtk.gdk.CONTROL_MASK)
def _setup_menus(self):
def get_focused(widgets):
for textview in widgets:
if textview.is_focus():
return textview
return None
clipboard = gtk.Clipboard(selection=gtk.gdk.SELECTION_CLIPBOARD)
def on_cut(menuitem):
focused = get_focused(self.targets)
if focused is not None:
focused.get_buffer().cut_clipboard(clipboard, True)
def on_copy(menuitem):
focused = get_focused(self.targets + self.sources)
if focused is not None:
focused.get_buffer().copy_clipboard(clipboard)
def on_paste(menuitem):
focused = get_focused(self.targets)
if focused is not None:
focused.get_buffer().paste_clipboard(clipboard, None, True)
maingui = self.controller.main_controller.view.gui
self.mnu_cut = maingui.get_object('mnu_cut')
self.mnu_copy = maingui.get_object('mnu_copy')
self.mnu_paste = maingui.get_object('mnu_paste')
self.mnu_cut.connect('activate', on_cut)
self.mnu_copy.connect('activate', on_copy)
self.mnu_paste.connect('activate', on_paste)
# And now for the "Transfer from source" and placeable selection menu items
mnu_next = maingui.get_object('mnu_placnext')
mnu_prev = maingui.get_object('mnu_placprev')
mnu_transfer = maingui.get_object('mnu_transfer')
self.mnu_next = mnu_next
self.mnu_prev = mnu_prev
self.mnu_transfer = mnu_transfer
menu_edit = maingui.get_object('menu_edit')
def on_next(*args):
self.targets[self.focused_target_n].move_elem_selection(1)
def on_prev(*args):
self.targets[self.focused_target_n].move_elem_selection(-1)
def on_transfer(*args):
ev = gtk.gdk.Event(gtk.gdk.KEY_PRESS)
ev.state = gtk.gdk.MOD1_MASK
ev.keyval = gtk.keysyms.Down
ev.window = self.targets[self.focused_target_n].get_window(gtk.TEXT_WINDOW_WIDGET)
ev.put()
mnu_next.connect('activate', on_next)
mnu_prev.connect('activate', on_prev)
mnu_transfer.connect('activate', on_transfer)
gtk.accel_map_add_entry("<Virtaal>/Edit/Next Placeable", gtk.keysyms.Right, gtk.gdk.MOD1_MASK)
gtk.accel_map_add_entry("<Virtaal>/Edit/Prev Placeable", gtk.keysyms.Left, gtk.gdk.MOD1_MASK)
gtk.accel_map_add_entry("<Virtaal>/Edit/Transfer", gtk.keysyms.Down, gtk.gdk.MOD1_MASK)
accel_group = menu_edit.get_accel_group()
if not accel_group:
accel_group = gtk.AccelGroup()
self.controller.main_controller.view.add_accel_group(accel_group)
menu_edit.set_accel_group(accel_group)
mnu_next.set_accel_path("<Virtaal>/Edit/Next Placeable")
mnu_prev.set_accel_path("<Virtaal>/Edit/Prev Placeable")
mnu_transfer.set_accel_path("<Virtaal>/Edit/Transfer")
# Disable the menu items to start with, because we can't assume that a
# store is loaded. See _set_menu_items_sensitive() for more activation.
self._set_menu_items_sensitive(False)
def on_store_closed(*args):
mnu_next.set_sensitive(False)
mnu_prev.set_sensitive(False)
mnu_transfer.set_sensitive(False)
self.mnu_cut.set_sensitive(False)
self.mnu_copy.set_sensitive(False)
self.mnu_paste.set_sensitive(False)
def on_store_loaded(*args):
mnu_next.set_sensitive(True)
mnu_prev.set_sensitive(True)
mnu_transfer.set_sensitive(True)
self.mnu_cut.set_sensitive(True)
self.mnu_copy.set_sensitive(True)
self.mnu_paste.set_sensitive(True)
self.controller.main_controller.store_controller.connect('store-closed', on_store_closed)
self.controller.main_controller.store_controller.connect('store-loaded', on_store_loaded)
"""
To make shortcuts work both AccelMap and AccelGroup have to know about them.
"""
import gtk
key, mod = gtk.accelerator_parse("<ctrl>s")
assert gtk.accelerator_valid(key, mod)
PATH = "<MyApp-MainWindow>/Save"
gtk.accel_map_add_entry(PATH, key, mod)
group = gtk.AccelGroup()
group.connect_by_path(PATH, gtk.main_quit)
window = gtk.Window()
assert not gtk.accel_groups_from_object(window)
window.add_accel_group(group)
window.show_all()
gtk.main()
)
def get_all_actions(): return _actions_list
_actions_dict = dict((action.get_name(), action) for action in _actions_list)
def get_action_from_name(action_name):
"""
Retrieve the action from the action list.
Search the list and find an action with said name.
@param action_name the action name(string)
@throw KeyError bad action name
@return a gtk action object
"""
if action_name in _actions_dict: return _actions_dict[action_name]
raise KeyError('Action Name: "%s" does not exist'%action_name)
######################################################################################################
# Accelerators
######################################################################################################
_accel_group = gtk.AccelGroup()
def get_accel_group(): return _accel_group
#set the accelerator group, and accelerator path
#register the key name and mod mask with the accelerator path
for action_name, key_name, mod_mask in _actions_key_list:
try:
accel_path = '<main>/'+action_name
get_action_from_name(action_name).set_accel_group(get_accel_group())
get_action_from_name(action_name).set_accel_path(accel_path)
gtk.accel_map_add_entry(accel_path, gtk.gdk.keyval_from_name(key_name), mod_mask)
except KeyError: pass #no action was created for this action name
def __init__(self):
# initialize the window. explicitly set it to None first, so that the
# creator knows it doesn't yet exist.
self.window = None
self.create_hamster_window()
self.new_name.grab_focus()
# configuration
self.workspace_tracking = conf.get("workspace_tracking")
conf.connect('conf-changed', self.on_conf_changed)
# Load today's data, activities and set label
self.last_activity = None
self.todays_facts = None
runtime.storage.connect('activities-changed',self.after_activity_update)
runtime.storage.connect('facts-changed',self.after_fact_update)
runtime.storage.connect('toggle-called', self.on_toggle_called)
self.screen = None
if self.workspace_tracking:
self.init_workspace_tracking()
# refresh hamster every 60 seconds
gobject.timeout_add_seconds(60, self.refresh_hamster)
self.prev_size = None
# bindings
self.accel_group = self.get_widget("accelgroup")
self.window.add_accel_group(self.accel_group)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/add", gtk.keysyms.n, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/overview", gtk.keysyms.o, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/stats", gtk.keysyms.i, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/close", gtk.keysyms.Escape, 0)
gtk.accel_map_add_entry("<hamster-time-tracker>/tracking/quit", gtk.keysyms.q, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/edit/prefs", gtk.keysyms.p, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-time-tracker>/help/contents", gtk.keysyms.F1, 0)
# create the status icon
self.statusicon = ProjectHamsterStatusIcon(self)
self.reposition_hamster_window()
self.show_hamster_window()
self.show_in_tray()
def _setup_key_bindings(self):
import gtk.gdk
gtk.accel_map_add_entry("<Virtaal>/File/Properties", gtk.keysyms.Return, gtk.gdk.MOD1_MASK)
def __init__(self, config, filename):
self.log = logging.getLogger('main')
self.cursor_create()
self.consumers = []
self.dataset = {}
self.filename = filename
# config defaults
rows = config.getint('general/rows', 3)
self.fullscreen = config.getboolean('general/fullscreen', False)
# Create window and get widget handles.
builder = gtk.Builder()
builder.add_from_file(join(dirname(__file__),'main.ui'))
builder.connect_signals(self)
self.window = builder.get_object('main')
self.notebook = builder.get_object('notebook1')
self.area = builder.get_object('area')
# Setup keyboard shortcuts
gtk.accel_map_add_entry("<visualizer>/quit", gtk.accelerator_parse("q")[0], gtk.gdk.CONTROL_MASK)
self.accel_group = gtk.AccelGroup()
self.accel_group.connect_by_path("<visualizer>/quit", self.quit)
self.window.add_accel_group(self.accel_group)
# guess resolution
size = (800,600)
if self.fullscreen:
dgd = gtk.gdk.display_get_default()
gsd = dgd.get_default_screen()
size = (gsd.get_width(), gsd.get_height())
# setup visualizer
self.log.debug('Creating canvas')
self.visualizer = Canvas(size=size, rows=rows)
self.visualizer.connect('motion_notify_event', self.cursor_show)
self.area.pack_start(self.visualizer)
self.window.show_all()
if self.fullscreen:
self.window.fullscreen()
self.notebook.set_show_tabs(False)
self.visualizer.window.set_cursor(self.cursor)
# Process events so window is fully created after this point.
gtk.main_iteration(True)
while gtk.events_pending():
gtk.main_iteration(False)
# parse rest of config.
self.log.debug('Parsing config')
self.parse_config(config)
# Setup statistics
self.stats = Statistics()
self.add_consumer(self.stats)
gobject.timeout_add(1000, self.update_stats)
# retrieve datasets from consumers
self.load_dataset()
if len(self.consumers) > 0:
print 'Available consumers'
print '-------------------'
for con in self.consumers:
print ' *', con
print
if len(self.dataset) > 0:
print 'Available datasets'
print '------------------'
for k,v in self.dataset.iteritems():
print ' * %s: %s' % (k, v)
print
# Initialize plugins. Must be done after fullscreen-mode so variables depending on size will work.
self.visualizer.dataset = self.dataset # fulhack
self.visualizer.init_all_plugins()
# Setup signal and event handling
signal(SIGHUP, self.handle_sighup)
signal(SIGINT, self.handle_sigint)
gobject.idle_add(self.expire)
def _setup_key_bindings(self):
import gtk.gdk
gtk.accel_map_add_entry("<Virtaal>/File/Properties",
gtk.keysyms.Return, gtk.gdk.MOD1_MASK)
class DailyView(object):
def __init__(self):
# initialize the window. explicitly set it to None first, so that the
# creator knows it doesn't yet exist.
self.window = None
self.create_hamster_window()
self.new_name.grab_focus()
# DBus Setup
try:
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
# Set up connection to the screensaver
self.dbusIdleListener = idle.DbusIdleListener()
self.dbusIdleListener.connect('idle-changed', self.on_idle_changed)
except dbus.DBusException, e:
logging.error("Can't init dbus: %s" % e)
# configuration
self.timeout_enabled = conf.get("enable_timeout")
self.notify_on_idle = conf.get("notify_on_idle")
self.notify_interval = conf.get("notify_interval")
self.workspace_tracking = conf.get("workspace_tracking")
conf.connect('conf-changed', self.on_conf_changed)
# Load today's data, activities and set label
self.last_activity = None
self.todays_facts = None
runtime.storage.connect('activities-changed',self.after_activity_update)
runtime.storage.connect('facts-changed',self.after_fact_update)
runtime.storage.connect('toggle-called', self.on_toggle_called)
self.screen = None
if self.workspace_tracking:
self.init_workspace_tracking()
self.notification = None
if pynotify:
self.notification = pynotify.Notification("Oh hi",
"Greetings from hamster!")
self.notification.set_urgency(pynotify.URGENCY_LOW) # lower than grass
# refresh hamster every 60 seconds
gobject.timeout_add_seconds(60, self.refresh_hamster)
self.prev_size = None
# bindings
self.accel_group = self.get_widget("accelgroup")
self.window.add_accel_group(self.accel_group)
gtk.accel_map_add_entry("<hamster-applet>/tracking/add", gtk.keysyms.n, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/tracking/overview", gtk.keysyms.o, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/tracking/stats", gtk.keysyms.i, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/tracking/close", gtk.keysyms.Escape, 0)
gtk.accel_map_add_entry("<hamster-applet>/tracking/quit", gtk.keysyms.q, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/edit/prefs", gtk.keysyms.p, gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry("<hamster-applet>/help/contents", gtk.keysyms.F1, 0)
# create the status icon
self.statusicon = ProjectHamsterStatusIcon(self)
self.reposition_hamster_window()
self.show_hamster_window()
self.show_in_tray()
def do_activate(self):
if self.window:
self.window.present()
return
self.window = Gtk.ApplicationWindow(application=self, title="Tryton")
self.window.set_default_size(960, 720)
self.window.maximize()
self.window.set_position(Gtk.WIN_POS_CENTER)
self.window.set_resizable(True)
self.window.set_icon(TRYTON_ICON)
self.window.connect("destroy", self.on_quit)
self.window.connect("delete_event", self.on_quit)
self.header = Gtk.HeaderBar.new()
self.header.set_show_close_button(True)
self.window.set_titlebar(self.header)
self.set_title()
menu = Gtk.Button.new()
menu.set_relief(Gtk.ReliefStyle.NONE)
menu.set_image(
common.IconFactory.get_image('tryton-menu', Gtk.IconSize.BUTTON))
menu.connect('clicked', self.menu_toggle)
self.header.pack_start(menu)
favorite = Gtk.MenuButton.new()
favorite.set_relief(Gtk.ReliefStyle.NONE)
favorite.set_image(
common.IconFactory.get_image('tryton-bookmarks',
Gtk.IconSize.BUTTON))
self.menu_favorite = Gtk.Menu.new()
favorite.set_popup(self.menu_favorite)
favorite.connect('clicked', self.favorite_set)
self.header.pack_start(favorite)
self.set_global_search()
self.header.pack_start(self.global_search_entry)
self.accel_group = Gtk.AccelGroup()
self.window.add_accel_group(self.accel_group)
gtk.accel_map_add_entry('<tryton>/Form/New', gtk.keysyms.N,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Save', gtk.keysyms.S,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Duplicate', gtk.keysyms.D,
gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Delete', gtk.keysyms.D,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Next', gtk.keysyms.Page_Down, 0)
gtk.accel_map_add_entry('<tryton>/Form/Previous', gtk.keysyms.Page_Up,
0)
gtk.accel_map_add_entry('<tryton>/Form/Switch View', gtk.keysyms.L,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Close', gtk.keysyms.W,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Reload', gtk.keysyms.R,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Attachments', gtk.keysyms.T,
gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Notes', gtk.keysyms.O,
gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Relate', gtk.keysyms.R,
gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Actions', gtk.keysyms.E,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Report', gtk.keysyms.P,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_add_entry('<tryton>/Form/Search', gtk.keysyms.F,
gtk.gdk.CONTROL_MASK)
gtk.accel_map_load(os.path.join(get_config_dir(), 'accel.map'))
self.tooltips = common.Tooltips()
self.vbox = gtk.VBox()
self.window.add(self.vbox)
self.buttons = {}
self.info = gtk.VBox()
self.vbox.pack_start(self.info, expand=False)
if CONFIG['client.check_version']:
common.check_version(self.info)
GLib.timeout_add_seconds(int(CONFIG['download.frequency']),
common.check_version, self.info)
self.pane = gtk.HPaned()
self.vbox.pack_start(self.pane, True, True)
self.pane.set_position(int(CONFIG['menu.pane']))
self.menu_screen = None
self.menu = gtk.VBox()
self.menu.set_vexpand(True)
self.pane.add1(self.menu)
self.notebook = gtk.Notebook()
self.notebook.popup_enable()
self.notebook.set_scrollable(True)
self.notebook.connect_after('switch-page', self._sig_page_changt)
self.pane.add2(self.notebook)
self.window.show_all()
self.pages = []
self.previous_pages = {}
self.current_page = 0
self.last_page = 0
self.dialogs = []
self._global_run = False
self._global_check_timeout_id = None
self._global_update_timeout_id = None
# Register plugins
tryton.plugins.register()
self.set_title() # Adds username/profile while password is asked
try:
common.Login()
except Exception as exception:
if (not isinstance(exception, TrytonError)
or exception.faultCode != 'QueryCanceled'):
common.error(str(exception), traceback.format_exc())
return self.quit()
self.get_preferences()
def __init__(self, branch, start_revs, maxnum, parent=None):
"""Create a new BranchWindow.
:param branch: Branch object for branch to show.
:param start_revs: Revision ids of top revisions.
:param maxnum: Maximum number of revisions to display,
None for no limit.
"""
Window.__init__(self, parent=parent)
self.set_border_width(0)
self.branch = branch
self.start_revs = start_revs
self.maxnum = maxnum
self.config = GlobalConfig()
if self.config.get_user_option('viz-compact-view') == 'yes':
self.compact_view = True
else:
self.compact_view = False
self.set_title(branch._get_nick(local=True) + " - revision history")
# user-configured window size
size = self._load_size('viz-window-size')
if size:
width, height = size
else:
# Use three-quarters of the screen by default
screen = self.get_screen()
monitor = screen.get_monitor_geometry(0)
width = int(monitor.width * 0.75)
height = int(monitor.height * 0.75)
self.set_default_size(width, height)
self.set_size_request(width/3, height/3)
self._save_size_on_destroy(self, 'viz-window-size')
# FIXME AndyFitz!
icon = self.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_BUTTON)
self.set_icon(icon)
gtk.accel_map_add_entry("<viz>/Go/Next Revision", gtk.keysyms.Up, gtk.gdk.MOD1_MASK)
gtk.accel_map_add_entry("<viz>/Go/Previous Revision", gtk.keysyms.Down, gtk.gdk.MOD1_MASK)
gtk.accel_map_add_entry("<viz>/View/Refresh", gtk.keysyms.F5, 0)
self.accel_group = gtk.AccelGroup()
self.add_accel_group(self.accel_group)
if getattr(gtk.Action, 'set_tool_item_type', None) is not None:
# Not available before PyGtk-2.10
gtk.Action.set_tool_item_type(gtk.MenuToolButton)
self.prev_rev_action = gtk.Action("prev-rev", "_Previous Revision", "Go to the previous revision", gtk.STOCK_GO_DOWN)
self.prev_rev_action.set_accel_path("<viz>/Go/Previous Revision")
self.prev_rev_action.set_accel_group(self.accel_group)
self.prev_rev_action.connect("activate", self._back_clicked_cb)
self.prev_rev_action.connect_accelerator()
self.next_rev_action = gtk.Action("next-rev", "_Next Revision", "Go to the next revision", gtk.STOCK_GO_UP)
self.next_rev_action.set_accel_path("<viz>/Go/Next Revision")
self.next_rev_action.set_accel_group(self.accel_group)
self.next_rev_action.connect("activate", self._fwd_clicked_cb)
self.next_rev_action.connect_accelerator()
self.refresh_action = gtk.Action("refresh", "_Refresh", "Refresh view", gtk.STOCK_REFRESH)
self.refresh_action.set_accel_path("<viz>/View/Refresh")
self.refresh_action.set_accel_group(self.accel_group)
self.refresh_action.connect("activate", self._refresh_clicked)
self.refresh_action.connect_accelerator()
self.construct()
def _setup_key_bindings(self):
gtk.accel_map_add_entry("<Virtaal>/Edit/Preferences", gtk.keysyms.p,
gtk.gdk.CONTROL_MASK)
