def _create_edit_menu(self, accel_group, parent):
menu = gtk.MenuItem("_Edit")
menu_content = gtk.Menu()
menu.set_submenu(menu_content)
# Manufacturers
menu_item = gtk.MenuItem("_Manufacturers...")
key_value, modifier = gtk.accelerator_parse("<Control>M")
menu_item.add_accelerator("activate", accel_group, key_value, modifier, gtk.ACCEL_VISIBLE)
menu_item.connect("activate", MenuBar.__run_edit_dialog, parent, MenuBar.MANUFACTURERS)
menu_content.append(menu_item)
# Devices
menu_item = gtk.MenuItem("_Devices...")
key_value, modifier = gtk.accelerator_parse("<Control>D")
menu_item.add_accelerator("activate", accel_group, key_value, modifier, gtk.ACCEL_VISIBLE)
menu_item.connect("activate", MenuBar.__run_edit_dialog, parent, MenuBar.DEVICES)
menu_content.append(menu_item)
# Folders
menu_item = gtk.MenuItem("_Folders...")
key_value, modifier = gtk.accelerator_parse("<Control>F")
menu_item.add_accelerator("activate", accel_group, key_value, modifier, gtk.ACCEL_VISIBLE)
menu_item.connect("activate", MenuBar.__run_edit_dialog, parent, MenuBar.FOLDERS)
menu_content.append(menu_item)
menu_content.append(gtk.SeparatorMenuItem())
# Preferences
menu_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES, accel_group)
key_value, modifier = gtk.accelerator_parse("<Control>P")
menu_item.add_accelerator("activate", accel_group, key_value, modifier, gtk.ACCEL_VISIBLE)
menu_item.connect("activate", gtk.main_quit)
menu_content.append(menu_item)
self.append(menu)
def __init__(self):
#Propiedades de la Ventana
Window.set_title("Untitled - DevEditor")
Window.set_default_size(750,450)
Window.set_position(gtk.WIN_POS_CENTER)
Window.connect("destroy", self.destroy)
#Creo Barra de Menus
self.MenuBar = gtk.MenuBar()
agr = gtk.AccelGroup()
Window.add_accel_group(agr)
#Creo subMenus
self.filemenu = gtk.Menu()
self.openM = gtk.ImageMenuItem(gtk.STOCK_OPEN, agr)
self.sepM = gtk.SeparatorMenuItem()
self.saveM = gtk.ImageMenuItem(gtk.STOCK_SAVE, agr)
self.saveAsM = gtk.ImageMenuItem(gtk.STOCK_SAVE_AS, agr)
key,mod = gtk.accelerator_parse("<Control>O")
self.openM.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
key,mod = gtk.accelerator_parse("<Control>S")
self.saveM.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
self.filemenu.append(self.openM)
self.filemenu.append(self.sepM)
self.filemenu.append(self.saveM)
self.filemenu.append(self.saveAsM)
self.openM.connect("activate", self.open_file)
self.saveM.connect("activate", self.save_file)
self.saveAsM.connect("activate", self.save_fileas)
self.fileM = gtk.MenuItem("File")
self.fileM.set_submenu(self.filemenu)
self.vbox = gtk.VBox(False, 0)
Window.add(self.vbox)
self.menub = gtk.MenuBar()
self.vbox.pack_start(self.menub, False, False, 0)
#Propiedades del TextView
TextView.set_editable(True)
TextView.set_cursor_visible(True)
TextView.set_border_window_size(gtk.TEXT_WINDOW_LEFT,1)
TextView.set_border_window_size(gtk.TEXT_WINDOW_RIGHT,1)
TextView.set_border_window_size(gtk.TEXT_WINDOW_TOP,1)
TextView.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM,1)
fontdesc = pango.FontDescription("monospace 9")
TextView.modify_font(fontdesc)
TextView.connect("key_release_event", self.hightlighting)
self.menub.append(self.fileM)
self.sw = gtk.ScrolledWindow()
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.sw.add(TextView)
self.vbox.pack_start(self.sw, True, True, 0)
self.vbox.pack_end(StatusBar, False, True, 8)
Window.add(TextView)
TextView.show()
Window.show()
Window.show_all()
def _p_updateCollisions(self): # Start with empty string text = '' # If there is a current shortcut selected if self._currentItem is not None: # Get the key combo for it currentItemKey = gtk.accelerator_parse( self._currentItem.accelString ) # Check that a shortcut key has been assigned if currentItemKey != ( 0, 0 ): # Get all shortcuts allShortcuts = self._shortcutTable.getShortcuts() # For each shortcut.... for shortcut in allShortcuts: # ... that is not the current shortcut, and has the same shortcut key assigned: if shortcut is not self._currentItem and gtk.accelerator_parse( shortcut.accelString ) == currentItemKey: # Get the action action = None try: action = UIAction._pathToActionTable[shortcut.path] except KeyError: pass else: # Append a line of text identifying it to the text buffer text += '.'.join( action.humanReadablePathTuple ) + '\n' textBuffer = self._collisions.get_buffer() textBuffer.set_text( text )
def __init__(self):
super(MenuTest, self).__init__()
self.set_title("Menu")
self.set_size_request(300,250)
self.set_position(gtk.WIN_POS_CENTER)
mb = gtk.MenuBar()
filemenu = gtk.Menu()
filem = gtk.MenuItem("_File")
filem.set_submenu(filemenu)
agr = gtk.AccelGroup()
self.add_accel_group(agr)
exit = gtk.MenuItem("_Exit", agr)
key = gtk.accelerator_parse("<Control>Q")
key, mod = gtk.accelerator_parse("<Control>Q")
print key
print mod
print key, mod
exit.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
exit.connect("activate", gtk.main_quit)
filemenu.append(exit)
mb.append(filem)
vbox = gtk.VBox(False, 2)
vbox.pack_start(mb, False, False, 0)
self.add(vbox)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self, datadir, version, argv):
self.file_path = datadir
self.version = version
self.editor = MenuEditor()
gtk.window_set_default_icon_name("mozo")
self.tree = gtk.Builder()
self.tree.set_translation_domain(config.GETTEXT_PACKAGE)
self.tree.add_from_file(os.path.join(self.file_path, "mozo.ui"))
self.tree.connect_signals(self)
self.setupMenuTree()
self.setupItemTree()
self.tree.get_object("edit_delete").set_sensitive(False)
self.tree.get_object("edit_revert_to_original").set_sensitive(False)
self.tree.get_object("edit_properties").set_sensitive(False)
self.tree.get_object("move_up_button").set_sensitive(False)
self.tree.get_object("move_down_button").set_sensitive(False)
self.tree.get_object("new_separator_button").set_sensitive(False)
accelgroup = gtk.AccelGroup()
keyval, modifier = gtk.accelerator_parse("<Ctrl>Z")
accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_undo)
keyval, modifier = gtk.accelerator_parse("<Ctrl><Shift>Z")
accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_redo)
keyval, modifier = gtk.accelerator_parse("F1")
accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_help_button_clicked)
self.tree.get_object("mainwindow").add_accel_group(accelgroup)
def create_menu(self):
"""
Tworzy menu, podpina akcje i skróty klawiszowe
"""
agr = gtk.AccelGroup()
self.add_accel_group(agr)
self.menu_bar = gtk.MenuBar()
menu = gtk.Menu()
clear_database_item = gtk.ImageMenuItem(gtk.STOCK_CLEAR, agr)
key, mod = gtk.accelerator_parse("<Control>D")
clear_database_item.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
about_item = gtk.ImageMenuItem(gtk.STOCK_ABOUT, agr)
key, mod = gtk.accelerator_parse("<Control>O")
about_item.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
quit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
clear_database_item.connect("activate", self.clear_database)
about_item.connect("activate", self.show_about)
quit_item.connect("activate", gtk.main_quit)
menu.append(clear_database_item)
menu.append(gtk.SeparatorMenuItem())
menu.append(about_item)
menu.append(quit_item)
menu_item = gtk.MenuItem("Program")
menu_item.set_submenu(menu)
self.menu_bar.append(menu_item)
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 _generate_file_menu(self):
"""
Generate the file menu.
"""
menu_bar = gtk.MenuBar()
menu_acc = gtk.AccelGroup()
self.add_accel_group(menu_acc)
###############################################################
# FILE #
###############################################################
file_menu = gtk.Menu()
file_sub = gtk.MenuItem("_File")
file_sub.set_submenu(file_menu)
exit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
key, modifier = gtk.accelerator_parse("<alt>F4")
exit_item.add_accelerator(accel_signal="activate", accel_group=menu_acc, accel_key=key,
accel_mods=modifier, accel_flags=gtk.ACCEL_VISIBLE)
exit_item.connect("activate", gtk.main_quit)
file_menu.append(exit_item)
menu_bar.append(file_sub)
###############################################################
# SETTINGS #
###############################################################
settings_menu = gtk.Menu()
settings_sub = gtk.MenuItem("_Settings")
settings_sub.set_submenu(settings_menu)
settings_item = gtk.MenuItem("Settings")
key, modifier = gtk.accelerator_parse("<alt>p")
settings_item.add_accelerator(accel_signal="activate", accel_group=menu_acc, accel_key=key,
accel_mods=modifier, accel_flags=gtk.ACCEL_VISIBLE)
# settings_item.connect("activate", NotImplementedError)
settings_menu.append(settings_item)
# ----------------------------------------------------------- #
separator = gtk.SeparatorMenuItem()
settings_menu.append(separator)
# ----------------------------------------------------------- #
timer_enable_item = gtk.CheckMenuItem("Timer")
# timer_enable_item.set_active(True)
key, modifier = gtk.accelerator_parse("<alt>t")
timer_enable_item.add_accelerator(accel_signal="activate", accel_group=menu_acc,
accel_key=key, accel_mods=modifier,
accel_flags=gtk.ACCEL_VISIBLE)
timer_enable_item.connect("toggled", self._timer_enabled_checkbutton_toggled)
settings_menu.append(timer_enable_item)
menu_bar.append(settings_sub)
self._content_area.pack_start(child=menu_bar, fill=False, expand=False, padding=0)
def preference_init(self):
self.preferences_load()
self.builder = gtk.Builder()
self.builder.add_from_file(os.path.dirname(os.path.abspath(__file__)) + '/reminder.ui')
self.preferences_dialog = self.builder.get_object('preferences_dialog')
self.treeview = self.builder.get_object('treeview')
self.liststore = self.builder.get_object('liststore')
self.liststoretype = self.builder.get_object('liststoretype')
self.button_apply = self.builder.get_object('button2')
self.button_add = self.builder.get_object('add')
self.button_delete = self.builder.get_object('delete')
self.button_find = self.builder.get_object('find')
self.button_cancel = self.builder.get_object('button1')
self.button_link = self.builder.get_object('linkbutton1')
self.button_command_open = self.builder.get_object('filechooserbutton1')
self.accelgroup = self.builder.get_object('accelgroup1')
self.builder.get_object('typecol').set_cell_data_func(self.builder.get_object('typeimage'), self.set_grid_status_icon)
SIGNAL_CONNECTIONS_DIC = {
'on_preferences_dialog_delete_event':
self.on_toolbar_cancel,
'on_btn_preferences_cancel_clicked':
self.on_toolbar_cancel,
'on_btn_preferences_ok_clicked':
self.on_toolbar_ok,
'on_btn_preferences_add_clicked':
self.on_toolbar_add,
'on_btn_preferences_del_clicked':
self.on_toolbar_del,
'on_btn_preferences_find_clicked':
self.on_toolbar_find,
'on_tag_name_changed':
self.on_grid_name_changed,
'on_tag_name_changing':
self.on_grid_name_changing,
'on_tag_type_changed':
self.on_grid_type_changed,
'on_tag_type_changing':
self.on_grid_type_changing,
'on_tag_arg_changed':
self.on_grid_arg_changed,
'on_tag_arg_changing':
self.on_grid_arg_changing,
'on_grid_stop_editing':
self.on_grid_stop_editing
}
self.builder.connect_signals(SIGNAL_CONNECTIONS_DIC)
(key, mod) = gtk.accelerator_parse("Escape")
self.accelgroup.connect_group(key, mod, gtk.ACCEL_VISIBLE, self.on_accel_cancel)
(key, mod) = gtk.accelerator_parse("Return")
self.accelgroup.connect_group(key, mod, gtk.ACCEL_VISIBLE, self.on_accel_apply)
if self.preferences.has_key('alarmtags'):
self.liststore.clear()
for row in self.preferences['alarmtags']:
self.liststore.append(row)
self.preferences_apply()
self.button_command_open.set_filename(self.command_open)
def load_accelerators(self):
"""Reads all gconf paths under /apps/guake/keybindings/local
and adds to the main accel_group.
"""
gets = lambda x:self.client.get_string(LKEY(x))
key, mask = gtk.accelerator_parse(gets('quit'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_quit)
key, mask = gtk.accelerator_parse(gets('new_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_add)
key, mask = gtk.accelerator_parse(gets('close_tab'))
if key > 0:
self.accel_group.connect_group(
key, mask, gtk.ACCEL_VISIBLE,
self.guake.close_tab)
key, mask = gtk.accelerator_parse(gets('reset_terminal'))
if key > 0:
self.accel_group.connect_group(
key, mask, gtk.ACCEL_VISIBLE,
self.guake.reset_terminal)
key, mask = gtk.accelerator_parse(gets('previous_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_prev)
key, mask = gtk.accelerator_parse(gets('next_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_next)
key, mask = gtk.accelerator_parse(gets('rename_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_rename)
key, mask = gtk.accelerator_parse(gets('clipboard_copy'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_copy_clipboard)
key, mask = gtk.accelerator_parse(gets('clipboard_paste'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_paste_clipboard)
key, mask = gtk.accelerator_parse(gets('toggle_fullscreen'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_toggle_fullscreen)
def _set_bindings(self):
items = [
('<Control>F4', self.database_close),
]
self._bindings = dict([(gtk.accelerator_parse(name), func)
for name, func in items])
# Hack to support these with CapsLock on.
for name, func in items:
keyval, mod = gtk.accelerator_parse(name)
mod = mod | gtk.gdk.LOCK_MASK
self._bindings[(keyval, mod)] = func
def menubar(self):
mb = gtk.MenuBar()
filemenu = gtk.Menu()
filem = gtk.MenuItem("_File")
filem.set_submenu(filemenu)
agr = gtk.AccelGroup()
self.window.add_accel_group(agr)
newi = gtk.ImageMenuItem(gtk.STOCK_NEW, agr)
key, mod = gtk.accelerator_parse("<Control>N")
newi.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
newi.connect("activate", self.new_file)
filemenu.append(newi)
openi = gtk.ImageMenuItem(gtk.STOCK_OPEN, agr)
key, mod = gtk.accelerator_parse("<Control>O")
newi.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
openi.connect("activate", self.open_file)
filemenu.append(openi)
savei = gtk.ImageMenuItem(gtk.STOCK_SAVE, agr)
key, mod = gtk.accelerator_parse("<Control>S")
savei.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
savei.connect("activate", self.save)
filemenu.append(savei)
save_asi = gtk.ImageMenuItem(gtk.STOCK_SAVE_AS, agr)
key, mod = gtk.accelerator_parse("<Control><Shift>S")
save_asi.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
save_asi.connect("activate", self.save_as)
filemenu.append(save_asi)
sep = gtk.SeparatorMenuItem()
filemenu.append(sep)
quiti = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
key, mod = gtk.accelerator_parse("<Control>Q")
quiti.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
quiti.connect("activate", self.delete_event)
filemenu.append(quiti)
helpmenu = gtk.Menu()
helpm = gtk.MenuItem("_Help")
helpm.set_submenu(helpmenu)
about = gtk.ImageMenuItem(gtk.STOCK_ABOUT, agr)
about.connect("activate", self.about_dialog)
helpmenu.append(about)
mb.append(filem)
mb.append(helpm)
self.hbox.pack_start(mb, False, False, 0)
def create_group(self):
accel_group = gtk.AccelGroup()
for shortcut, action in shortcuts.items():
shortcut = self.config.opts.get(action, shortcut)
keyval, modifier = gtk.accelerator_parse(shortcut)
accel_group.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE,
self.accel_callback(action))
for shortcut, custom in self.get_customs():
keyval, modifier = gtk.accelerator_parse(shortcut)
accel_group.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE,
self.custom_callback(custom))
return accel_group
def __init__(self, bus=None, uri=None, profile='default', width=1213,
height=628):
""" Browser(bus=None, uri=None, profile='default', width=1213,
height=628) ->
Main browser window of size 'width'x'height' embed browser tab 'pid'
and use dbus 'bus' to communicate with the external tabs.
"""
super(Browser, self).__init__(uri=uri, profile=profile, width=width,
height=height)
# Connect the dbus receiver to allow opening new tabs from external
# tabs.
if bus:
self._receiver = BrowserReceiver(bus, '/main_browser%s' % id(self))
self._receiver.connect('get-socket-id', self._get_socket_id)
# Connect dbus to bus.
self._connect_dbus(bus)
self._bus = bus
# Should we use a proxy.
self._no_proxy = True
self._proxy = os.environ.get('http_proxy', '')
os.environ['http_proxy'] = ''
# This dictionary is used to keep track of which tabs have died
# so it can restart connected tabs properly.
self._died_dict = {}
# A dictionary to match closed pids with their replacement pid.
self._closed_pid_dict = {}
# Add an extra keyboard shortcut to open alternative tabs
keyval, modifier = gtk.accelerator_parse('<Control><Alt>t')
self._accels.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE,
self._new_tab_key_pressed)
keyval, modifier = gtk.accelerator_parse('<Control><Shift><Alt>t')
self._accels.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE,
self._new_tab_key_pressed)
keyval, modifier = gtk.accelerator_parse('<Control><Mod4>t')
self._accels.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE,
self._new_tab_key_pressed)
# Setup the python executable to use for external tabs.
#self._pyexec = subprocess.Popen(['which', 'python2'],
#stdout=subprocess.PIPE).communicate()[0].strip()
self._pyexec = sys.executable
if uri:
# Open a tab if there was a uri given.
self.do_open_tab(uri=uri)
def __init__(self, undo_stack, redo_stack, undo_func):
"""Load a view of the stack."""
log_text = ''
super(StackViewer, self).__init__()
self.set_title(rose.config_editor.STACK_VIEW_TITLE)
self.action_colour_map = {
rose.config_editor.STACK_ACTION_ADDED:
rose.config_editor.COLOUR_STACK_ADDED,
rose.config_editor.STACK_ACTION_APPLIED:
rose.config_editor.COLOUR_STACK_APPLIED,
rose.config_editor.STACK_ACTION_CHANGED:
rose.config_editor.COLOUR_STACK_CHANGED,
rose.config_editor.STACK_ACTION_CHANGED_COMMENTS:
rose.config_editor.COLOUR_STACK_CHANGED_COMMENTS,
rose.config_editor.STACK_ACTION_ENABLED:
rose.config_editor.COLOUR_STACK_ENABLED,
rose.config_editor.STACK_ACTION_IGNORED:
rose.config_editor.COLOUR_STACK_IGNORED,
rose.config_editor.STACK_ACTION_REMOVED:
rose.config_editor.COLOUR_STACK_REMOVED,
rose.config_editor.STACK_ACTION_REVERSED:
rose.config_editor.COLOUR_STACK_REVERSED}
self.undo_func = undo_func
self.undo_stack = undo_stack
self.redo_stack = redo_stack
self.set_border_width(rose.config_editor.SPACING_SUB_PAGE)
self.main_vbox = gtk.VPaned()
accelerators = gtk.AccelGroup()
accel_key, accel_mods = gtk.accelerator_parse("<Ctrl>Z")
accelerators.connect_group(accel_key, accel_mods, gtk.ACCEL_VISIBLE,
lambda a, b, c, d: self.undo_from_log())
accel_key, accel_mods = gtk.accelerator_parse("<Ctrl><Shift>Z")
accelerators.connect_group(accel_key, accel_mods, gtk.ACCEL_VISIBLE,
lambda a, b, c, d:
self.undo_from_log(redo_mode_on=True))
self.add_accel_group(accelerators)
self.set_default_size(*rose.config_editor.SIZE_STACK)
self.undo_view = self.get_stack_view(redo_mode_on=False)
self.redo_view = self.get_stack_view(redo_mode_on=True)
undo_vbox = self.get_stack_view_box(self.undo_view,
redo_mode_on=False)
redo_vbox = self.get_stack_view_box(self.redo_view,
redo_mode_on=True)
self.main_vbox.pack1(undo_vbox, resize=True, shrink=True)
self.main_vbox.show()
self.main_vbox.pack2(redo_vbox, resize=False, shrink=True)
self.main_vbox.show()
self.undo_view.connect('size-allocate', self.scroll_view)
self.redo_view.connect('size-allocate', self.scroll_view)
self.add(self.main_vbox)
self.show()
def _set_bindings(self):
items = [
('Insert', self.select_create_action),
('<Control><Shift>Return', self.select_create_action),
('<Control>Return', self.select_update_action),
('Delete', self.select_delete_action),
]
self._bindings = dict([(gtk.accelerator_parse(name), func)
for name, func in items])
# Hack to support these with CapsLock on.
for name, func in items:
keyval, mod = gtk.accelerator_parse(name)
mod = mod | gtk.gdk.LOCK_MASK
self._bindings[(keyval, mod)] = func
def __init__(self):
super(PyApp, self).__init__()
self.set_title("Image menu")
self.set_size_request(250, 200)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(6400, 6400, 6440))
self.set_position(gtk.WIN_POS_CENTER)
mb = gtk.MenuBar()
filemenu = gtk.Menu()
filem = gtk.MenuItem("_File")
filem.set_submenu(filemenu)
agr = gtk.AccelGroup()
self.add_accel_group(agr)
newi = gtk.ImageMenuItem(gtk.STOCK_NEW, agr)
key, mod = gtk.accelerator_parse("<Control>N")
newi.add_accelerator("activate", agr, key,
mod, gtk.ACCEL_VISIBLE)
filemenu.append(newi)
openm = gtk.ImageMenuItem(gtk.STOCK_OPEN, agr)
key, mod = gtk.accelerator_parse("<Control>O")
openm.add_accelerator("activate", agr, key,
mod, gtk.ACCEL_VISIBLE)
filemenu.append(openm)
sep = gtk.SeparatorMenuItem()
filemenu.append(sep)
exit = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
key, mod = gtk.accelerator_parse("<Control>Q")
exit.add_accelerator("activate", agr, key,
mod, gtk.ACCEL_VISIBLE)
exit.connect("activate", gtk.main_quit)
filemenu.append(exit)
mb.append(filem)
vbox = gtk.VBox(False, 2)
vbox.pack_start(mb, False, False, 0)
self.add(vbox)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self, library, player=None, update=False):
super(SongList, self).__init__()
self._register_instance(SongList)
self.set_model(PlaylistModel())
self.set_size_request(200, 150)
self.set_rules_hint(True)
self.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.set_fixed_height_mode(True)
self.__csig = self.connect('columns-changed', self.__columns_changed)
self.set_column_headers(self.headers)
librarian = library.librarian or library
sigs = []
# The player needs to be called first so it can ge the next song
# in case the current one gets deleted and the order gets reset.
if player:
s = librarian.connect_object('removed', map, player.remove)
sigs.append(s)
sigs.extend([librarian.connect('changed', self.__song_updated),
librarian.connect('removed', self.__song_removed)])
if update:
sigs.append(librarian.connect('added', self.__song_added))
for sig in sigs:
self.connect_object('destroy', librarian.disconnect, sig)
if player:
sigs = [player.connect('paused', self.__redraw_current),
player.connect('unpaused', self.__redraw_current)]
for sig in sigs:
self.connect_object('destroy', player.disconnect, sig)
self.connect('button-press-event', self.__button_press, librarian)
self.connect('key-press-event', self.__key_press, librarian)
self.disable_drop()
self.connect('drag-motion', self.__drag_motion)
self.connect('drag-leave', self.__drag_leave)
self.connect('drag-data-get', self.__drag_data_get)
self.connect('drag-data-received', self.__drag_data_received, library)
self.set_search_equal_func(self.__search_func)
self.accelerators = gtk.AccelGroup()
key, mod = gtk.accelerator_parse("<alt>Return")
self.accelerators.connect_group(
key, mod, 0, lambda *args: self.__song_properties(librarian))
key, mod = gtk.accelerator_parse("<control>I")
self.accelerators.connect_group(
key, mod, 0, lambda *args: self.__information(librarian))
self.connect('destroy', self.__destroy)
def __init__(self, inputs=[], ui_file="ui.glade"):
self.__gobject_init__()
self.inputs = inputs
self.ui_file = ui_file
self.conf = {"examination_time": 15, "player_container_maxcols": 3}
# init main window
self.builder = self.create_builder()
self.main_window = self.builder.get_object("main_window")
self.player_container = self.builder.get_object("player_container")
self.main_window.show()
# init hotkeys and players
self.players = []
self.hotkey_map = {}
# set up keyboard shortcuts
self.accel_group = gtk.AccelGroup()
(key, mod) = gtk.accelerator_parse("F2")
self.hotkey_map[(key, mod)] = False
self.accel_group.connect_group(key, mod, 0, self.on_start_action_activate)
(key, mod) = gtk.accelerator_parse("F5")
self.hotkey_map[(key, mod)] = False
self.accel_group.connect_group(key, mod, 0, self.on_reset_action_activate)
(key, mod) = gtk.accelerator_parse("F10")
self.hotkey_map[(key, mod)] = False
self.accel_group.connect_group(key, mod, 0, self.on_add_player_action_activate)
(key, mod) = gtk.accelerator_parse("<Control>F10")
self.hotkey_map[(key, mod)] = False
self.accel_group.connect_group(key, mod, 0, self.on_clear_action_activate)
self.main_window.add_accel_group(self.accel_group)
self.builder.connect_signals(self)
self.tick()
gobject.timeout_add(10, self.tick)
# intialize inputs
for i in xrange(len(self.inputs)):
gobject.io_add_watch(self.inputs[i], gobject.IO_IN | gobject.IO_PRI, self.input_data_available, i)
self.connect("external_input", self.on_external_input)
def create_menubar(self, window, menubar):
# Setup shortcuts
agr = gtk.AccelGroup()
window.add_accel_group(agr)
# File menu
filemenu = gtk.Menu()
filem = gtk.MenuItem(_("_File"))
filem.set_submenu(filemenu)
open = gtk.ImageMenuItem(gtk.STOCK_OPEN, agr)
open.get_child().set_text(_("Open..."))
key, mod = gtk.accelerator_parse(_("O"))
open.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
open.connect("activate", self.menu_file_open)
filemenu.append(open)
quit = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
quit.get_child().set_text(_("Quit"))
key, mod = gtk.accelerator_parse(_("Q"))
quit.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
quit.connect("activate", gtk.main_quit)
filemenu.append(quit)
menubar.append(filem)
# Edit menu
editMenu = gtk.MenuItem(_("_Edit"))
editSubmenu = gtk.Menu()
editMenu.set_submenu(editSubmenu)
prefsMenuItem = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
prefsMenuItem.get_child().set_text(_("Services"))
prefsMenuItem.connect("activate", self.menu_edit_services, self.wTree.get_widget("combo"))
editSubmenu.append(prefsMenuItem)
menubar.append(editMenu)
# Help menu
helpMenu = gtk.MenuItem(_("_Help"))
helpSubmenu = gtk.Menu()
helpMenu.set_submenu(helpSubmenu)
aboutMenuItem = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
aboutMenuItem.get_child().set_text(_("About"))
aboutMenuItem.connect("activate", self.menu_help_about)
helpSubmenu.append(aboutMenuItem)
menubar.append(helpMenu)
menubar.show_all()
def __init__(self, app, accels):
gtk.Toolbar.__init__(self)
self.app = app
self.set_data('id', "toolbar_search")
# Search entry
t = gtk.ToolItem()
t.set_expand(True)
self.searchtxt = gtk.Entry()
self.searchtxt.set_icon_from_stock(gtk.ENTRY_ICON_PRIMARY, gtk.STOCK_FIND)
self.searchtxt.set_icon_activatable(gtk.ENTRY_ICON_PRIMARY, False)
self.searchtxt.set_icon_from_stock(gtk.ENTRY_ICON_SECONDARY, gtk.STOCK_CLEAR)
self.searchtxt.set_icon_activatable(gtk.ENTRY_ICON_SECONDARY, True)
self.searchtxt.connect('changed', lambda w: self.ev_search(w, 0))
self.searchtxt.connect('icon-release', self.ev_clear)
t.add(self.searchtxt)
self.insert(t, -1)
# Search directions
t = gtk.ToolButton(gtk.STOCK_GO_BACK)
t.connect('clicked', lambda w: self.ev_search(w, -1))
ak, am = gtk.accelerator_parse("<Shift>F3")
t.add_accelerator('clicked', accels, ak, am, gtk.ACCEL_VISIBLE)
self.insert(t, -1)
t = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
t.connect('clicked', lambda w: self.ev_search(w, 1))
ak, am = gtk.accelerator_parse("F3")
t.add_accelerator('clicked', accels, ak, am, gtk.ACCEL_VISIBLE)
self.insert(t, -1)
# Case sensitivity button
t = gtk.ToolItem()
self.case = gtk.CheckButton(_("Case sensitive"))
self.case.set_focus_on_click(False)
self.case.connect('toggled', lambda w: self.ev_search(w, 0))
t.add(self.case)
self.insert(t, -1)
# Space
t = gtk.ToolItem()
t.add(gtk.Label())
t.set_expand(True)
self.insert(t, -1)
# Close button
t = gtk.ToolButton(gtk.STOCK_CLOSE)
t.connect('clicked', lambda w: self.hide())
self.insert(t, -1)
# Display
self.show_all()
self.hide()
self.connect('show', self.ev_show)
self.connect('hide', self.ev_hide)
def _is_good_keystr(self, keystr): # Reject single letters so you can't bind 'A' etc if keystr is None: return label = gtk.accelerator_get_label(*gtk.accelerator_parse(keystr)) ulabel = kupferstring.tounicode(label) return not (len(ulabel) == 1 and ulabel.isalnum())
def factory(menu_, parent, context):
item = gtk.CheckMenuItem(_("Enable audioscrobbling"))
item.set_active(self.submit)
key, mods = gtk.accelerator_parse("<Control>B")
item.add_accelerator("activate", menu.FAKEACCELGROUP, key, mods, gtk.ACCEL_VISIBLE)
item.connect("toggled", self._menu_entry_toggled)
return item
def _show_keybindings(self, setctl): names = self.KEYBINDING_NAMES self.keybind_store.clear() for binding in sorted(names, key=lambda k: names[k]): accel = setctl.get_global_keybinding(binding) label = gtk.accelerator_get_label(*gtk.accelerator_parse(accel)) self.keybind_store.append((names[binding], label, binding))
def _build_menu(self):
menu = gtk.Menu()
item_tup = (
('_export_list_item', ('gtk-save', '_Export List', False,
None, self._export_list_button_released)),
gtk.SeparatorMenuItem(),
('_add_uri_item', ('gtk-add', '_Add Uri', True, None,
self._add_uri_button_released)),
gtk.SeparatorMenuItem(),
('_start_item', ('gtk-media-play-ltr', '_Start', False,
None, self._start_button_released)),
('_pause_item', ('gtk-media-pause', '_Pause', False, None,
self._pause_button_released)),
gtk.SeparatorMenuItem(),
('_rename_item', ('gtk-edit', '_Rename', False, None,
self._rename_button_released)),
('_copy_uri_item', ('edit-copy', '_Copy Uri', False, None,
self._copy_uri_button_released)),
gtk.SeparatorMenuItem(),
('_clear_item', ('gtk-clear', 'C_lear List', False, None,
self._clear_button_released)),
('_clear_completed_item', ('gtk-clear',
'Clear Completed Downloads', True, None,
self._clear_completed_button_released)),
('_remove_download_item', ('list-remove', 'Remove _Selected',
False, 'Delete', self._remove_download_button_released)),
gtk.SeparatorMenuItem(),
('_restart_server_item', ('gtk-refresh',
'Rest_art Aria2c Server', True, None,
self._restart_server_button_released)),
)
accel_group = gtk.AccelGroup()
menu.set_accel_group(accel_group)
for menu_item in item_tup:
if type(menu_item) == tuple:
item_name, (icon_name, label_text, is_sensitive, accel,
clicked_callback) = menu_item
icon = gtk.Image()
icon.set_from_icon_name(icon_name, gtk.ICON_SIZE_MENU)
item = gtk.ImageMenuItem()
item.set_image(icon)
item.set_label(label_text)
item.set_use_underline(True)
item.set_sensitive(is_sensitive)
item.connect('button-release-event', clicked_callback)
self.__setattr__(item_name, item)
if accel:
keyval, modifier = gtk.accelerator_parse(accel)
item.add_accelerator('activate', accel_group, keyval,
modifier, gtk.ACCEL_VISIBLE)
else:
item = menu_item
menu.add(item)
menu.show_all()
return menu
def add_button(self, key, icon=None, stock=None, tooltip=None, accel=None):
''' Add a new selector button '''
if len(self._buttons) == 0:
button = gtk.RadioButton(None)
self._first = button
else:
button = gtk.RadioButton(self._first)
button.connect("clicked", self.on_button_clicked, key)
if accel:
keyval, mask = gtk.accelerator_parse(accel)
button.add_accelerator("clicked", self.key_bindings, keyval, mask, 0)
button.set_relief(gtk.RELIEF_NONE)
button.set_mode(False)
if stock:
pix = gtk.image_new_from_stock(stock, gtk.ICON_SIZE_MENU)
else:
pb = gtk.gdk.pixbuf_new_from_file(icon)
pix = gtk.Image()
pix.set_from_pixbuf(pb)
pix.show()
button.add(pix)
if tooltip:
button.set_tooltip_text(tooltip)
button.show()
self.content.pack_start(button, False)
self._buttons[key] = button
def _show_gkeybindings(self, setctl): names = self.ACCELERATOR_NAMES self.gkeybind_store.clear() for binding in sorted(names, key=lambda k: names[k]): accel = setctl.get_accelerator(binding) label = gtk.accelerator_get_label(*gtk.accelerator_parse(accel)) self.gkeybind_store.append((names[binding], label, binding))
def register(self, name, bindings, callback, args=[], kwargs={}):
""" Registers an action for a predefined keybinding name.
@param name: Action name, defined in L{BINDING_INFO}.
@param bindings: List of keybinding strings, as understood
by L{gtk.accelerator_parse}. Only used if no
bindings were loaded for this action.
@param callback: Function callback
@param args: List of arguments to pass to the callback
@param kwargs: List of keyword arguments to pass to the callback.
"""
global BINDING_INFO
assert name in BINDING_INFO, "'%s' isn't a valid keyboard action." % name
# Load stored keybindings, or fall back to passed arguments
keycodes = self._action_to_bindings[name]
if keycodes == []:
keycodes = [gtk.accelerator_parse(binding) for binding in bindings ]
for keycode in keycodes:
if keycode in self._binding_to_action.keys():
if self._binding_to_action[keycode] != name:
log.warning(_('Keybinding for "%(action)s" overrides hotkey for another action.'),
{"action": name})
log.warning('Binding %s overrides %r' % (keycode, self._binding_to_action[keycode]))
else:
self._binding_to_action[keycode] = name
self._action_to_bindings[name].append(keycode)
# Add gtk accelerator for labels in menu
if len(self._action_to_bindings[name]) > 0:
key, mod = self._action_to_bindings[name][0]
gtk.accel_map_change_entry('<Actions>/mcomix-main/%s' % name, key, mod, True)
self._action_to_callback[name] = (callback, args, kwargs)
def add_accelerator(self, widget, accelerator, signal="activate"):
"""
Adds a keyboard shortcut
to a widget
"""
key, mod = gtk.accelerator_parse(accelerator)
widget.add_accelerator(signal, self.my_accelerators, key, mod, gtk.ACCEL_VISIBLE)
def reload_global(self, client, connection_id, entry, data):
"""Unbind all global hotkeys and rebind the show_hide
method. If more global hotkeys should be added, just connect
the gconf key to the watch system and add.
"""
gkey = entry.get_key()
key = entry.get_value().get_string()
if key == 'disabled':
return
try:
self.guake.hotkeys.unbind(self.globalhotkeys[gkey])
except KeyError:
pass
self.globalhotkeys[gkey] = key
if not self.guake.hotkeys.bind(key, self.guake.show_hide):
keyval, mask = gtk.accelerator_parse(key)
label = gtk.accelerator_get_label(keyval, mask)
filename = pixmapfile('guake-notification.png')
guake.notifier.show_message(
_('Guake Terminal'),
_('A problem happened when binding <b>%s</b> key.\n'
'Please use Guake Preferences dialog to choose another '
'key') % xml_escape(label), filename)
def __init__(self):
super(AgendaWindow, self).__init__()
self.set_title("Agenda")
self.set_size_request(500, 400)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("destroy", gtk.main_quit)
# Database parameters
self.page_limit = setup_options.getLimit()
self.current_page = 1
self.items_quantity = 0
self.db = BasicDb()
#Contact id
self.contact_id = 0
# Menu bar
mb = gtk.MenuBar()
filemenu = gtk.Menu()
filem = gtk.MenuItem("_File")
filem.set_submenu(filemenu)
agr = gtk.AccelGroup()
self.add_accel_group(agr)
newi = gtk.ImageMenuItem(gtk.STOCK_NEW, agr)
key, mod = gtk.accelerator_parse("<Control>N")
newi.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
filemenu.append(newi)
sep = gtk.SeparatorMenuItem()
filemenu.append(sep)
exit = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
key, mod = gtk.accelerator_parse("<Control>Q")
exit.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
exit.connect("activate", gtk.main_quit)
newi.connect("activate", self.add_contact)
filemenu.append(exit)
mb.append(filem)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
newtb = gtk.ToolButton(gtk.STOCK_NEW)
self.back = gtk.ToolButton(gtk.STOCK_GO_BACK)
self.back.set_sensitive(False)
self.next = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self.next.set_sensitive(False)
sep = gtk.SeparatorToolItem()
quittb = gtk.ToolButton(gtk.STOCK_QUIT)
toolbar.insert(newtb, 0)
toolbar.insert(self.back, 1)
toolbar.insert(self.next, 2)
toolbar.insert(sep, 3)
toolbar.insert(quittb, 4)
newtb.connect("clicked", self.add_contact)
quittb.connect("clicked", gtk.main_quit)
self.back.connect("clicked", self.previous_page)
self.next.connect("clicked", self.next_page)
vbox = gtk.VBox(False, 3)
vbox.pack_start(mb, False, False, 0)
vbox.pack_start(toolbar, False, False, 0)
vbox.pack_start(sw, True, True, 0)
self.store = self.create_model()
self.treeView = gtk.TreeView(self.store)
self.treeView.connect("row-activated", self.on_activated)
self.treeView.set_rules_hint(True)
self.populate_model()
self.selected = self.treeView.get_selection()
self.selected.connect("changed", self.on_changed)
sw.add(self.treeView)
self.create_columns(self.treeView)
self.enable_next_previous()
hbox = gtk.HBox(True, 3)
self.edit = gtk.Button("Edit")
self.edit.set_size_request(70, 30)
self.edit.set_sensitive(False)
self.edit.connect("clicked", self.edit_contact)
self.label = gtk.Label(" - ")
self.delete = gtk.Button("Delete")
self.delete.set_size_request(70, 30)
self.delete.set_sensitive(False)
self.delete.connect("clicked", self.delete_contact)
hbox.add(self.label)
hbox.add(self.edit)
hbox.add(self.delete)
halign = gtk.Alignment(1, 0, 0, 0)
halign.add(hbox)
vbox.pack_start(halign, False, False, 3)
self.add(vbox)
self.show_all()
def on_provider_added(self, provider):
key, mod = gtk.accelerator_parse(provider.keys)
self.accelgroup.connect_group(key, mod, gtk.ACCEL_VISIBLE,
provider.callback)
def __init__(self, emma, mainwindow):
"""
@param emma: Emma
"""
super(MainMenu, self).__init__()
self.emma = emma
#
# FILE
#
self.file_menu = gtk.MenuItem('_File')
file_menu_submenu = gtk.Menu()
self.execute_query_from_disk = gtk.MenuItem('Execute Query From Disk')
self.execute_query_from_disk.show()
file_menu_submenu.append(self.execute_query_from_disk)
sep1 = gtk.SeparatorMenuItem()
sep1.show()
file_menu_submenu.append(sep1)
self.reload_plugins = gtk.MenuItem('Reload Plugins')
self.reload_plugins.show()
file_menu_submenu.append(self.reload_plugins)
self.reread_config = gtk.MenuItem('Reload Config')
self.reread_config.show()
file_menu_submenu.append(self.reread_config)
# sep2 = gtk.SeparatorMenuItem()
# sep2.show()
# file_menu_submenu.append(sep2)
#
# save_workspace = gtk.MenuItem('Save Workspace')
# save_workspace.show()
# file_menu_submenu.append(save_workspace)
#
# restore_workspace = gtk.MenuItem('Restore Workspace')
# restore_workspace.show()
# file_menu_submenu.append(restore_workspace)
sep3 = gtk.SeparatorMenuItem()
sep3.show()
file_menu_submenu.append(sep3)
self.quit_button = gtk.ImageMenuItem(gtk.STOCK_QUIT)
self.quit_button.show()
file_menu_submenu.append(self.quit_button)
file_menu_submenu.show()
self.file_menu.set_submenu(file_menu_submenu)
self.file_menu.show()
self.append(self.file_menu)
#
# VIEW
#
self.view_menu = gtk.MenuItem('_View')
view_menu_submenu = gtk.Menu()
self.show_connections_tree = gtk.CheckMenuItem('Show Connections')
key, mod = gtk.accelerator_parse("<Control>H")
self.show_connections_tree.add_accelerator("activate",
mainwindow.accel_group, key,
mod, gtk.ACCEL_VISIBLE)
self.show_connections_tree.connect(
"activate", self.emma.key_map.toggle_connections_tv, mainwindow)
self.show_connections_tree.set_active(True)
self.show_connections_tree.show()
view_menu_submenu.append(self.show_connections_tree)
self.show_message_notebook = gtk.CheckMenuItem('Show Messages Bar')
key, mod = gtk.accelerator_parse("<Control>M")
self.show_message_notebook.add_accelerator("activate",
mainwindow.accel_group, key,
mod, gtk.ACCEL_VISIBLE)
self.show_message_notebook.connect(
"activate", self.emma.key_map.toggle_message_notebook, mainwindow)
self.show_message_notebook.set_active(True)
self.show_message_notebook.show()
view_menu_submenu.append(self.show_message_notebook)
view_menu_submenu.show()
self.view_menu.set_submenu(view_menu_submenu)
self.append(self.view_menu)
#
# HELP
#
self.help_menu = gtk.MenuItem('_Help')
help_menu_submenu = gtk.Menu()
self.changelog = gtk.MenuItem('Changelog')
self.changelog.show()
help_menu_submenu.append(self.changelog)
self.about = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
self.about.show()
help_menu_submenu.append(self.about)
help_menu_submenu.show()
self.help_menu.set_right_justified(True)
self.help_menu.set_submenu(help_menu_submenu)
self.help_menu.show()
self.append(self.help_menu)
self.show()
self.execute_query_from_disk.connect(
'activate', self.emma.on_execute_query_from_disk_activate)
self.reload_plugins.connect('activate',
self.on_reload_plugins_activate)
self.reread_config.connect('activate', self.on_reread_config_activate)
#self.save_workspace.connect('activate', self.on_save_workspace_activate)
#self.restore_workspace.connect('activate', self.on_restore_workspace_activate)
self.quit_button.connect('activate', self.on_quit_activate)
self.changelog.connect('activate', self.on_changelog_activate)
self.about.connect('activate', self.on_about_activate)
def add_keybinding(accel_group, widget, accel_str, signal="activate"):
keyval, mods = gtk.accelerator_parse(accel_str)
widget.add_accelerator(signal, accel_group,
def split_accelerator(self, accelerator):
key, mod = gtk.accelerator_parse(accelerator)
return key, mod
def __init__(self, core):
super(reportWin, self).__init__()
self.TITLE = "Report"
self.uicore = core
# Window properties
self.connect("destroy", self.win_destroy)
self.set_size_request(800, 600)
self.set_position(gtk.WIN_POS_CENTER)
self.set_title(self.TITLE)
# VBox for Menu and Textview
self.vbox = gtk.VBox()
# Menu
self.mb = gtk.MenuBar()
agr = gtk.AccelGroup()
self.add_accel_group(agr)
filemenu = gtk.Menu()
filem = gtk.MenuItem("_File")
filem.set_submenu(filemenu)
savi = gtk.ImageMenuItem(gtk.STOCK_SAVE, agr)
key, mod = gtk.accelerator_parse("S")
savi.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
filemenu.append(savi)
savi.connect("activate", self.save_report)
sep = gtk.SeparatorMenuItem()
filemenu.append(sep)
exit = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
key, mod = gtk.accelerator_parse("Q")
exit.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
filemenu.append(exit)
exit.connect("activate", self.win_destroy)
self.mb.append(filem)
# Add Menu to VBox
self.vbox.pack_start(self.mb, False, False, 0)
# Textview
self.reporttv = gtk.TextView()
self.reporttv.set_wrap_mode(gtk.WRAP_NONE)
self.reporttv.set_editable(False)
#self.reporttv.set_cursor_visible(False)
# Change text font
fontdesc = pango.FontDescription("MonoSpace 10")
#fontdesc = pango.FontDescription("Purisa 10")
self.reporttv.modify_font(fontdesc)
# Scrolled Window for Textview
self.sw = gtk.ScrolledWindow(hadjustment=None, vadjustment=None)
self.sw.add_with_viewport(self.reporttv)
# Get KB to parse for report
self.textbuffer = self.reporttv.get_buffer()
self.report_data = generateReport(self.uicore.get_kbList())
self.textbuffer.set_text(self.report_data)
# Add Textview to VBox
self.vbox.pack_start(self.sw, True, True, 0)
# Show all
self.add(self.vbox)
self.show_all()
def __init__(self):
# Get interfaces for D-Bus services
session = self.__connect_session_options()
system = self.__connect_system_options()
# Setup GUI
self.builder = gtk.Builder()
self.builder.set_translation_domain("samsung-tools")
self.builder.add_from_file(os.path.join(
WORK_DIRECTORY, "gui/glade/samsung-tools-preferences.glade"))
###
# Main widgets
###
self.mainWindow = self.builder.get_object("mainWindow")
self.mainWindow.set_icon_from_file(SAMSUNG_TOOLS_ICON)
self.mainWindow.connect("delete-event", self.quit)
self.closeButton = self.builder.get_object("closeButton")
self.closeButton.connect("clicked", self.quit)
self.aboutButton = self.builder.get_object("aboutButton")
self.aboutButton.connect("clicked", self.about)
###
# Session service configuration
###
self.sessionTable = self.builder.get_object("sessionTable")
# Set backlight hotkey grabber
self.backlightHotkeyButton = KeyGrabber(
popup_title=unicode(_("Backlight"), "utf-8"))
hotkey = session.GetBacklightHotkey()
(key, mods) = gtk.accelerator_parse(
self.__convert_xbindkeys_to_gtk(hotkey))
self.backlightHotkeyButton.set_label(key, mods, True)
self.backlightHotkeyButton.set_tooltip_text(
self.builder.get_object("backlightHotkeyLabel").get_tooltip_text())
self.sessionTable.attach(
self.backlightHotkeyButton, 1, 2, 2, 3, yoptions=0)
self.backlightHotkeyButton.connect(
"changed", self.on_backlightHotkeyButton_changed)
self.backlightHotkeyButton.show()
# Set bluetooth hotkey grabber
self.bluetoothHotkeyButton = KeyGrabber(
popup_title=unicode(_("Bluetooth"), "utf-8"))
hotkey = session.GetBluetoothHotkey()
(key, mods) = gtk.accelerator_parse(
self.__convert_xbindkeys_to_gtk(hotkey))
self.bluetoothHotkeyButton.set_label(key, mods, True)
self.bluetoothHotkeyButton.set_tooltip_text(
self.builder.get_object("bluetoothHotkeyLabel").get_tooltip_text())
self.sessionTable.attach(
self.bluetoothHotkeyButton, 1, 2, 3, 4, yoptions=0)
self.bluetoothHotkeyButton.connect(
"changed", self.on_bluetoothHotkeyButton_changed)
self.bluetoothHotkeyButton.show()
# Set cpu hotkey grabber
self.cpuHotkeyButton = KeyGrabber(
popup_title=unicode(_("CPU fan"), "utf-8"))
hotkey = session.GetCpuHotkey()
(key, mods) = gtk.accelerator_parse(
self.__convert_xbindkeys_to_gtk(hotkey))
self.cpuHotkeyButton.set_label(key, mods, True)
self.cpuHotkeyButton.set_tooltip_text(
self.builder.get_object("cpuHotkeyLabel").get_tooltip_text())
self.sessionTable.attach(self.cpuHotkeyButton, 1, 2, 4, 5, yoptions=0)
self.cpuHotkeyButton.connect(
"changed", self.on_cpuHotkeyButton_changed)
self.cpuHotkeyButton.show()
# Set webcam hotkey grabber
self.webcamHotkeyButton = KeyGrabber(
popup_title=unicode(_("Webcam"), "utf-8"))
hotkey = session.GetWebcamHotkey()
(key, mods) = gtk.accelerator_parse(
self.__convert_xbindkeys_to_gtk(hotkey))
self.webcamHotkeyButton.set_label(key, mods, True)
self.webcamHotkeyButton.set_tooltip_text(
self.builder.get_object("webcamHotkeyLabel").get_tooltip_text())
self.sessionTable.attach(
self.webcamHotkeyButton, 1, 2, 5, 6, yoptions=0)
self.webcamHotkeyButton.connect(
"changed", self.on_webcamHotkeyButton_changed)
self.webcamHotkeyButton.show()
# Set wireless hotkey grabber
self.wirelessHotkeyButton = KeyGrabber(
popup_title=unicode(_("Wireless"), "utf-8"))
hotkey = session.GetWirelessHotkey()
(key, mods) = gtk.accelerator_parse(
self.__convert_xbindkeys_to_gtk(hotkey))
self.wirelessHotkeyButton.set_label(key, mods, True)
self.wirelessHotkeyButton.set_tooltip_text(
self.builder.get_object("wirelessHotkeyLabel").get_tooltip_text())
self.sessionTable.attach(
self.wirelessHotkeyButton, 1, 2, 6, 7, yoptions=0)
self.wirelessHotkeyButton.connect(
"changed", self.on_wirelessHotkeyButton_changed)
self.wirelessHotkeyButton.show()
# Set clean buttons for keygrabbers
self.backlightHotkeyCleanButton = self.builder.get_object(
"backlightHotkeyCleanButton")
self.backlightHotkeyCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_MENU))
self.backlightHotkeyCleanButton.connect(
"clicked", self.on_backlightHotkeyCleanButton_clicked)
self.bluetoothHotkeyCleanButton = self.builder.get_object(
"bluetoothHotkeyCleanButton")
self.bluetoothHotkeyCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_MENU))
self.bluetoothHotkeyCleanButton.connect(
"clicked", self.on_bluetoothHotkeyCleanButton_clicked)
self.cpuHotkeyCleanButton = self.builder.get_object(
"cpuHotkeyCleanButton")
self.cpuHotkeyCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_MENU))
self.cpuHotkeyCleanButton.connect(
"clicked", self.on_cpuHotkeyCleanButton_clicked)
self.webcamHotkeyCleanButton = self.builder.get_object(
"webcamHotkeyCleanButton")
self.webcamHotkeyCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_MENU))
self.webcamHotkeyCleanButton.connect(
"clicked", self.on_webcamHotkeyCleanButton_clicked)
self.wirelessHotkeyCleanButton = self.builder.get_object(
"wirelessHotkeyCleanButton")
self.wirelessHotkeyCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_MENU))
self.wirelessHotkeyCleanButton.connect(
"clicked", self.on_wirelessHotkeyCleanButton_clicked)
# Set default buttons for keygrabbers
self.backlightHotkeyDefaultButton = self.builder.get_object(
"backlightHotkeyDefaultButton")
self.backlightHotkeyDefaultButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.backlightHotkeyDefaultButton.connect(
"clicked", self.on_backlightHotkeyDefaultButton_clicked)
self.bluetoothHotkeyDefaultButton = self.builder.get_object(
"bluetoothHotkeyDefaultButton")
self.bluetoothHotkeyDefaultButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.bluetoothHotkeyDefaultButton.connect(
"clicked", self.on_bluetoothHotkeyDefaultButton_clicked)
self.cpuHotkeyDefaultButton = self.builder.get_object(
"cpuHotkeyDefaultButton")
self.cpuHotkeyDefaultButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.cpuHotkeyDefaultButton.connect(
"clicked", self.on_cpuHotkeyDefaultButton_clicked)
self.webcamHotkeyDefaultButton = self.builder.get_object(
"webcamHotkeyDefaultButton")
self.webcamHotkeyDefaultButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.webcamHotkeyDefaultButton.connect(
"clicked", self.on_webcamHotkeyDefaultButton_clicked)
self.wirelessHotkeyDefaultButton = self.builder.get_object(
"wirelessHotkeyDefaultButton")
self.wirelessHotkeyDefaultButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.wirelessHotkeyDefaultButton.connect(
"clicked", self.on_wirelessHotkeyDefaultButton_clicked)
# Set enable hotkeys checkbutton
self.backlightHotkeyLabel = self.builder.get_object(
"backlightHotkeyLabel")
self.bluetoothHotkeyLabel = self.builder.get_object(
"bluetoothHotkeyLabel")
self.cpuHotkeyLabel = self.builder.get_object("cpuHotkeyLabel")
self.webcamHotkeyLabel = self.builder.get_object("webcamHotkeyLabel")
self.wirelessHotkeyLabel = self.builder.get_object(
"wirelessHotkeyLabel")
self.useHotkeysCheckbutton = self.builder.get_object(
"useHotkeysCheckbutton")
if session.GetUseHotkeys() == "true":
self.useHotkeysCheckbutton.set_active(True)
else:
self.useHotkeysCheckbutton.set_active(False)
self.useHotkeysCheckbutton.connect(
"toggled", self.on_useHotkeysCheckbutton_toggled)
self.on_useHotkeysCheckbutton_toggled(self.useHotkeysCheckbutton, True)
###
# System service configuration
###
# Bluetooth initial status
self.bluetoothInitialStatusCombobox = self.builder.get_object(
"bluetoothInitialStatusCombobox")
# Set cell renderer for 'bluetooth initial status' combobox
self.bluetoothInitialStatusComboboxCR = gtk.CellRendererText()
self.bluetoothInitialStatusCombobox.pack_start(
self.bluetoothInitialStatusComboboxCR)
self.bluetoothInitialStatusCombobox.add_attribute(
self.bluetoothInitialStatusComboboxCR, 'text', 0)
status = system.GetBluetoothInitialStatus()
if status == "last":
self.bluetoothInitialStatusCombobox.set_active(0)
elif status == "on":
self.bluetoothInitialStatusCombobox.set_active(1)
else: # status == "off"
self.bluetoothInitialStatusCombobox.set_active(2)
self.bluetoothInitialStatusCombobox.connect(
"changed", self.on_bluetoothInitialStatusCombobox_changed)
# Webcam initial status
self.webcamInitialStatusCombobox = self.builder.get_object(
"webcamInitialStatusCombobox")
# Set cell renderer for 'webcam initial status' combobox
self.webcamInitialStatusComboboxCR = gtk.CellRendererText()
self.webcamInitialStatusCombobox.pack_start(
self.webcamInitialStatusComboboxCR)
self.webcamInitialStatusCombobox.add_attribute(
self.webcamInitialStatusComboboxCR, 'text', 0)
status = system.GetWebcamInitialStatus()
if status == "last":
self.webcamInitialStatusCombobox.set_active(0)
elif status == "on":
self.webcamInitialStatusCombobox.set_active(1)
else: # status == "off"
self.webcamInitialStatusCombobox.set_active(2)
self.webcamInitialStatusCombobox.connect(
"changed", self.on_webcamInitialStatusCombobox_changed)
# Wireless initial status
self.wirelessInitialStatusCombobox = self.builder.get_object(
"wirelessInitialStatusCombobox")
# Set cell renderer for 'wireless initial status' combobox
self.wirelessInitialStatusComboboxCR = gtk.CellRendererText()
self.wirelessInitialStatusCombobox.pack_start(
self.wirelessInitialStatusComboboxCR)
self.wirelessInitialStatusCombobox.add_attribute(
self.wirelessInitialStatusComboboxCR, 'text', 0)
status = system.GetWirelessInitialStatus()
if status == "last":
self.wirelessInitialStatusCombobox.set_active(0)
elif status == "on":
self.wirelessInitialStatusCombobox.set_active(1)
else: # status == "off"
self.wirelessInitialStatusCombobox.set_active(2)
self.wirelessInitialStatusCombobox.connect(
"changed", self.on_wirelessInitialStatusCombobox_changed)
# CPU fan initial status
self.cpufanInitialStatusCombobox = self.builder.get_object(
"cpufanInitialStatusCombobox")
# Set cell renderer for 'cpufan initial status' combobox
self.cpufanInitialStatusComboboxCR = gtk.CellRendererText()
self.cpufanInitialStatusCombobox.pack_start(
self.cpufanInitialStatusComboboxCR)
self.cpufanInitialStatusCombobox.add_attribute(
self.cpufanInitialStatusComboboxCR, 'text', 0)
status = system.GetCpufanInitialStatus()
if status == "normal":
self.cpufanInitialStatusCombobox.set_active(0)
elif status == "silent":
self.cpufanInitialStatusCombobox.set_active(1)
elif status == "overclock":
self.cpufanInitialStatusCombobox.set_active(2)
else: # status == "last"
self.cpufanInitialStatusCombobox.set_active(3)
self.cpufanInitialStatusCombobox.connect(
"changed", self.on_cpufanInitialStatusCombobox_changed)
# Set clean buttons
self.bluetoothInitialStatusCleanButton = self.builder.get_object(
"bluetoothInitialStatusCleanButton")
self.bluetoothInitialStatusCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.bluetoothInitialStatusCleanButton.connect(
"clicked", self.on_bluetoothInitialStatusCleanButton_clicked)
self.webcamInitialStatusCleanButton = self.builder.get_object(
"webcamInitialStatusCleanButton")
self.webcamInitialStatusCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.webcamInitialStatusCleanButton.connect(
"clicked", self.on_webcamInitialStatusCleanButton_clicked)
self.wirelessInitialStatusCleanButton = self.builder.get_object(
"wirelessInitialStatusCleanButton")
self.wirelessInitialStatusCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.wirelessInitialStatusCleanButton.connect(
"clicked", self.on_wirelessInitialStatusCleanButton_clicked)
self.cpufanInitialStatusCleanButton = self.builder.get_object(
"cpufanInitialStatusCleanButton")
self.cpufanInitialStatusCleanButton.set_image(
gtk.image_new_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_MENU))
self.cpufanInitialStatusCleanButton.connect(
"clicked", self.on_cpufanInitialStatusCleanButton_clicked)
# Disable widgets for devices not available
# Get remaining widgets
self.bluetoothInitialStatusLabel = self.builder.get_object(
"bluetoothInitialStatusLabel")
self.webcamInitialStatusLabel = self.builder.get_object(
"webcamInitialStatusLabel")
self.wirelessInitialStatusLabel = self.builder.get_object(
"wirelessInitialStatusLabel")
self.cpufanInitialStatusLabel = self.builder.get_object(
"cpufanInitialStatusLabel")
conn = self.__connect_session_bluetooth()
if not conn.IsAvailable():
self.bluetoothInitialStatusLabel.set_sensitive(False)
self.bluetoothInitialStatusCombobox.set_sensitive(False)
self.bluetoothInitialStatusCleanButton.set_sensitive(False)
conn = self.__connect_session_webcam()
if not conn.IsAvailable():
self.webcamInitialStatusLabel.set_sensitive(False)
self.webcamInitialStatusCombobox.set_sensitive(False)
self.webcamInitialStatusCleanButton.set_sensitive(False)
conn = self.__connect_session_wireless()
if not conn.IsAvailable():
self.wirelessInitialStatusLabel.set_sensitive(False)
self.wirelessInitialStatusCombobox.set_sensitive(False)
self.wirelessInitialStatusCleanButton.set_sensitive(False)
conn = self.__connect_session_cpu()
if not conn.IsFanAvailable():
self.cpufanInitialStatusLabel.set_sensitive(False)
self.cpufanInitialStatusCombobox.set_sensitive(False)
self.cpufanInitialStatusCleanButton.set_sensitive(False)
# Set control interface
self.controlInterfaceValueLabel = self.builder.get_object(
"controlInterfaceValueLabel")
ci = system.GetControlInterface()
if ci == "esdm":
self.controlInterfaceValueLabel.set_label("easy-slow-down-manager")
elif ci == "sl":
self.controlInterfaceValueLabel.set_label("samsung-laptop")
else:
self.controlInterfaceValueLabel.set_label("-")
###
# Advanced power management configuration
###
# Kernel parameters
self.sysCtlButton = self.builder.get_object("sysCtlButton")
conn = self.__connect_system_sysctl()
if not conn.IsAvailable():
self.sysCtlButton.set_sensitive(False)
else:
self.sysCtlButton.set_sensitive(True)
self.sysCtlButton.connect("clicked", self.on_sysCtlButton_clicked)
# Power management
self.powerManagementButton = self.builder.get_object(
"powerManagementButton")
self.powerManagementButton.set_sensitive(True)
self.powerManagementButton.connect(
"clicked", self.on_powerManagementButton_clicked)
# PHC
self.phcButton = self.builder.get_object("phcButton")
conn = self.__connect_system_cpu()
if not conn.IsPHCAvailable():
self.phcButton.set_sensitive(False)
self.phcButton.set_has_tooltip(True)
tooltip = unicode(
_("You need a PHC enabled kernel to use this feature"),
"utf-8")
self.phcButton.set_tooltip_text(tooltip)
else:
self.phcButton.set_sensitive(True)
self.phcButton.connect("clicked", self.on_phcButton_clicked)
# Enable click on website url in about dialog
def about_dialog_url_clicked(dialog, link, user_data):
import webbrowser
webbrowser.open(link)
gtk.about_dialog_set_url_hook(about_dialog_url_clicked, None)
# All ready
self.mainWindow.show()
def set_accel(self, accel_string):
self.set_accel_key(*gtk.accelerator_parse(accel_string))
def bind(self, accel, callback, *args):
key, modifier = gtk.accelerator_parse(accel)
self.shortcuts[(key, modifier)] = callback, args
self.accel_group.connect_group(key, modifier, gtk.ACCEL_VISIBLE,
self.activate)
def load_accelerators(self):
"""Reads all gconf paths under /apps/guake/keybindings/local
and adds to the main accel_group.
"""
gets = lambda x: self.client.get_string(LKEY(x))
key, mask = gtk.accelerator_parse(gets('reset_terminal'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_reset_terminal)
key, mask = gtk.accelerator_parse(gets('quit'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_quit)
key, mask = gtk.accelerator_parse(gets('new_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_add)
key, mask = gtk.accelerator_parse(gets('close_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.close_tab)
key, mask = gtk.accelerator_parse(gets('previous_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_prev)
key, mask = gtk.accelerator_parse(gets('next_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_next)
key, mask = gtk.accelerator_parse(gets('move_tab_left'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_move_tab_left)
key, mask = gtk.accelerator_parse(gets('move_tab_right'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_move_tab_right)
key, mask = gtk.accelerator_parse(gets('rename_current_tab'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_rename_current_tab)
key, mask = gtk.accelerator_parse(gets('clipboard_copy'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_copy_clipboard)
key, mask = gtk.accelerator_parse(gets('clipboard_paste'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_paste_clipboard)
key, mask = gtk.accelerator_parse(gets('toggle_fullscreen'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_toggle_fullscreen)
key, mask = gtk.accelerator_parse(gets('toggle_hide_on_lose_focus'))
if key > 0:
self.accel_group.connect_group(
key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_toggle_hide_on_lose_focus)
key, mask = gtk.accelerator_parse(gets('zoom_in'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_zoom_in)
key, mask = gtk.accelerator_parse(gets('zoom_in_alt'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_zoom_in)
key, mask = gtk.accelerator_parse(gets('zoom_out'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_zoom_out)
key, mask = gtk.accelerator_parse(gets('increase_height'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_increase_height)
key, mask = gtk.accelerator_parse(gets('decrease_height'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_decrease_height)
key, mask = gtk.accelerator_parse(gets('increase_transparency'))
if key > 0:
self.accel_group.connect_group(
key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_increase_transparency)
key, mask = gtk.accelerator_parse(gets('decrease_transparency'))
if key > 0:
self.accel_group.connect_group(
key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_decrease_transparency)
key, mask = gtk.accelerator_parse(gets('toggle_transparency'))
if key > 0:
self.accel_group.connect_group(
key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_toggle_transparency)
for tab in xrange(1, 11):
key, mask = gtk.accelerator_parse(gets('switch_tab%d' % tab))
if key > 0:
self.accel_group.connect_group(
key, mask, gtk.ACCEL_VISIBLE,
self.guake.gen_accel_switch_tabN(tab - 1))
key, mask = gtk.accelerator_parse(gets('switch_tab_last'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.accel_switch_tab_last)
try:
key, mask = gtk.accelerator_parse(gets('search_on_web'))
if key > 0:
self.accel_group.connect_group(key, mask, gtk.ACCEL_VISIBLE,
self.guake.search_on_web)
except Exception:
log.exception("Exception occured")
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 get_items(self):
for target, (keystr, name, id_) in self.trigger_table.iteritems():
label = gtk.accelerator_get_label(*gtk.accelerator_parse(keystr))
yield Trigger(target, u"%s (%s)" % (label or keystr, name))
def __init__(self, acct, type_, parent_window=None, parent_paned=None):
# A dictionary of dictionaries
# where _contacts[account][jid] == A MessageControl
self._controls = {}
# If None, the window is not tied to any specific account
self.account = acct
# If None, the window is not tied to any specific type
self.type_ = type_
# dict { handler id: widget}. Keeps callbacks, which
# lead to cylcular references
self.handlers = {}
# Don't show warning dialogs when we want to delete the window
self.dont_warn_on_delete = False
self.widget_name = 'message_window'
self.xml = gtkgui_helpers.get_glade('%s.glade' % self.widget_name)
self.window = self.xml.get_widget(self.widget_name)
self.notebook = self.xml.get_widget('notebook')
self.parent_paned = None
if parent_window:
orig_window = self.window
self.window = parent_window
self.parent_paned = parent_paned
self.notebook.reparent(self.parent_paned)
self.parent_paned.pack2(self.notebook, resize=True, shrink=True)
orig_window.destroy()
del orig_window
# NOTE: we use 'connect_after' here because in
# MessageWindowMgr._new_window we register handler that saves window
# state when closing it, and it should be called before
# MessageWindow._on_window_delete, which manually destroys window
# through win.destroy() - this means no additional handlers for
# 'delete-event' are called.
id = self.window.connect_after('delete-event', self._on_window_delete)
self.handlers[id] = self.window
id = self.window.connect('destroy', self._on_window_destroy)
self.handlers[id] = self.window
id = self.window.connect('focus-in-event', self._on_window_focus)
self.handlers[id] = self.window
keys=['<Control>f', '<Control>g', '<Control>h', '<Control>i',
'<Control>l', '<Control>L', '<Control>n', '<Control>t', '<Control>u',
'<Control>v', '<Control>b', '<Control><Shift>Tab', '<Control>Tab',
'<Control>F4', '<Control>w', '<Control>Page_Up', '<Control>Page_Down',
'<Alt>Right', '<Alt>Left', '<Alt>a', '<Alt>c', '<Alt>m', 'Escape'] + \
['<Alt>'+str(i) for i in xrange(10)]
accel_group = gtk.AccelGroup()
for key in keys:
keyval, mod = gtk.accelerator_parse(key)
accel_group.connect_group(keyval, mod, gtk.ACCEL_VISIBLE,
self.accel_group_func)
self.window.add_accel_group(accel_group)
# gtk+ doesn't make use of the motion notify on gtkwindow by default
# so this line adds that
self.window.add_events(gtk.gdk.POINTER_MOTION_MASK)
self.alignment = self.xml.get_widget('alignment')
id = self.notebook.connect('switch-page',
self._on_notebook_switch_page)
self.handlers[id] = self.notebook
id = self.notebook.connect('key-press-event',
self._on_notebook_key_press)
self.handlers[id] = self.notebook
# Remove the glade pages
while self.notebook.get_n_pages():
self.notebook.remove_page(0)
# Tab customizations
pref_pos = gajim.config.get('tabs_position')
if pref_pos == 'bottom':
nb_pos = gtk.POS_BOTTOM
elif pref_pos == 'left':
nb_pos = gtk.POS_LEFT
elif pref_pos == 'right':
nb_pos = gtk.POS_RIGHT
else:
nb_pos = gtk.POS_TOP
self.notebook.set_tab_pos(nb_pos)
window_mode = gajim.interface.msg_win_mgr.mode
if gajim.config.get('tabs_always_visible') or \
window_mode == MessageWindowMgr.ONE_MSG_WINDOW_ALWAYS_WITH_ROSTER:
self.notebook.set_show_tabs(True)
self.alignment.set_property('top-padding', 2)
else:
self.notebook.set_show_tabs(False)
self.notebook.set_show_border(gajim.config.get('tabs_border'))
# if GTK+ version < 2.10, use OUR way to reorder tabs (set up DnD)
if gtk.pygtk_version < (2, 10, 0) or gtk.gtk_version < (2, 10, 0):
self.hid = self.notebook.connect(
'drag_data_received', self.on_tab_label_drag_data_received_cb)
self.handlers[self.hid] = self.notebook
self.notebook.drag_dest_set(gtk.DEST_DEFAULT_ALL, self.DND_TARGETS,
gtk.gdk.ACTION_MOVE)
def ReorderKeyString(self, accel):
key, mods = gtk.accelerator_parse(accel)
return GetAcceleratorName(key, mods)
def valid_for_item(self, leaf):
text = leaf.object
keys, mods = gtk.accelerator_parse(text)
return keys
class _KeybindingManager(object):
def __init__(self, window):
#: Main window instance
self._window = window
self._action_to_callback = {} # action name => (func, args, kwargs)
self._action_to_bindings = defaultdict(
list) # action name => [ (key code, key modifier), ]
self._binding_to_action = {} # (key code, key modifier) => action name
self._migrate_from_old_bindings()
self._initialize()
def register(self, name, bindings, callback, args=[], kwargs={}):
""" Registers an action for a predefined keybinding name.
@param name: Action name, defined in L{BINDING_INFO}.
@param bindings: List of keybinding strings, as understood
by L{gtk.accelerator_parse}. Only used if no
bindings were loaded for this action.
@param callback: Function callback
@param args: List of arguments to pass to the callback
@param kwargs: List of keyword arguments to pass to the callback.
"""
global BINDING_INFO
assert name in BINDING_INFO, "'%s' isn't a valid keyboard action." % name
# Load stored keybindings, or fall back to passed arguments
keycodes = self._action_to_bindings[name]
if keycodes == []:
keycodes = [gtk.accelerator_parse(binding) for binding in bindings]
for keycode in keycodes:
if keycode in self._binding_to_action.keys():
if self._binding_to_action[keycode] != name:
log.warning(
_('Keybinding for "%(action)s" overrides hotkey for another action.'
), {"action": name})
log.warning('Binding %s overrides %r' %
(keycode, self._binding_to_action[keycode]))
else:
self._binding_to_action[keycode] = name
self._action_to_bindings[name].append(keycode)
# Add gtk accelerator for labels in menu
if len(self._action_to_bindings[name]) > 0:
key, mod = self._action_to_bindings[name][0]
gtk.accel_map_change_entry('<Actions>/mcomix-main/%s' % name, key,
mod, True)
self._action_to_callback[name] = (callback, args, kwargs)
def edit_accel(self, name, new_binding, old_binding):
""" Changes binding for an action
@param name: Action name
@param new_binding: Binding to be assigned to action
@param old_binding: Binding to be removed from action [ can be empty: "" ]
@return None: new_binding wasn't in any action
action name: where new_binding was before
"""
global BINDING_INFO
assert name in BINDING_INFO, "'%s' isn't a valid keyboard action." % name
nb = gtk.accelerator_parse(new_binding)
old_action_with_nb = self._binding_to_action.get(nb)
if old_action_with_nb is not None:
# The new key is already bound to an action, erase the action
self._binding_to_action.pop(nb)
self._action_to_bindings[old_action_with_nb].remove(nb)
if old_binding and name != old_action_with_nb:
# The action already had a key that is now being replaced
ob = gtk.accelerator_parse(old_binding)
self._binding_to_action[nb] = name
# Remove action bound to the key.
if ob in self._binding_to_action:
self._binding_to_action.pop(ob)
if ob in self._action_to_bindings[name]:
idx = self._action_to_bindings[name].index(ob)
self._action_to_bindings[name].pop(idx)
self._action_to_bindings[name].insert(idx, nb)
else:
self._binding_to_action[nb] = name
self._action_to_bindings[name].append(nb)
self.save()
return old_action_with_nb
def clear_accel(self, name, binding):
""" Remove binding for an action """
global BINDING_INFO
assert name in BINDING_INFO, "'%s' isn't a valid keyboard action." % name
ob = gtk.accelerator_parse(binding)
self._action_to_bindings[name].remove(ob)
self._binding_to_action.pop(ob)
self.save()
def clear_all(self):
""" Removes all keybindings. The changes are only persisted if
save() is called afterwards. """
self._action_to_callback = {}
self._action_to_bindings = defaultdict(list)
self._binding_to_action = {}
def execute(self, keybinding):
""" Executes an action that has been registered for the
passed keyboard event. If no action is bound to the passed key, this
method is a no-op. """
if keybinding in self._binding_to_action:
action = self._binding_to_action[keybinding]
func, args, kwargs = self._action_to_callback[action]
self._window.emit_stop_by_name('key_press_event')
return func(*args, **kwargs)
# Some keys enable additional modifiers (NumLock enables GDK_MOD2_MASK),
# which prevent direct lookup simply by being pressed.
# XXX: Looking up by key/modifier probably isn't the best implementation,
# so limit possible states to begin with?
for stored_binding, action in self._binding_to_action.iteritems():
stored_keycode, stored_flags = stored_binding
if stored_keycode == keybinding[0] and stored_flags & keybinding[1]:
func, args, kwargs = self._action_to_callback[action]
self._window.emit_stop_by_name('key_press_event')
return func(*args, **kwargs)
def save(self):
""" Stores the keybindings that have been set to disk. """
# Collect keybindings for all registered actions
action_to_keys = {}
for action, bindings in self._action_to_bindings.iteritems():
if bindings is not None:
action_to_keys[action] = [
gtk.accelerator_name(keyval, modifiers)
for (keyval, modifiers) in bindings
]
fp = file(constants.KEYBINDINGS_CONF_PATH, "w")
json.dump(action_to_keys, fp, indent=2)
fp.close()
def _initialize(self):
""" Restore keybindings from disk. """
try:
fp = file(constants.KEYBINDINGS_CONF_PATH, "r")
stored_action_bindings = json.load(fp)
fp.close()
except Exception, e:
log.error(_("Couldn't load keybindings: %s"), e)
stored_action_bindings = {}
for action in BINDING_INFO.iterkeys():
if action in stored_action_bindings:
bindings = [
gtk.accelerator_parse(keyname)
for keyname in stored_action_bindings[action]
]
self._action_to_bindings[action] = bindings
for binding in bindings:
self._binding_to_action[binding] = action
else:
self._action_to_bindings[action] = []
def __init__(self):
gtk.ToggleButton.__init__(self)
BaseControl.__init__(self)
QueueAdapter.__init__(self, player.QUEUE)
self.set_focus_on_click(False)
self.set_size_request(200, -1)
box = gtk.HBox()
self.arrow = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_OUT)
box.pack_start(self.arrow, expand=False)
self.label = gtk.Label('')
self.label.props.ellipsize = pango.ELLIPSIZE_END
box.pack_start(self.label)
self.add(box)
self.formatter = TrackFormatter(
settings.get_option('plugin/minimode/track_title_format',
'$tracknumber - $title'))
self.view = PlaylistView(player.QUEUE.current_playlist, player.PLAYER)
self.popup = AttachedWindow(self)
self.popup.set_default_size(
settings.get_option(
'plugin/minimode/'
'playlist_button_popup_width', 350),
settings.get_option(
'plugin/minimode/'
'playlist_button_popup_height', 400))
scrollwindow = gtk.ScrolledWindow()
scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrollwindow.set_shadow_type(gtk.SHADOW_IN)
scrollwindow.add(self.view)
self.popup.add(scrollwindow)
self.popup.connect('configure-event', self.on_popup_configure_event)
accel_group = gtk.AccelGroup()
key, modifier = gtk.accelerator_parse('<Control>J')
accel_group.connect_group(key, modifier, gtk.ACCEL_VISIBLE,
self.on_accelerator_activate)
self.popup.add_accel_group(accel_group)
self.tooltip = TrackToolTip(self, player.PLAYER)
self.tooltip.set_auto_update(True)
if player.PLAYER.current is not None:
self.label.set_text(self.formatter.format(player.PLAYER.current))
self._drag_motion_timeout_id = None
self._drag_leave_timeout_id = None
self._toplevel_hide_id = None
self._toplevel_window_state_event_id = None
self.drag_dest_set(
gtk.DEST_DEFAULT_ALL, self.view.targets,
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_MOVE)
self.connect('drag-motion', self.on_drag_motion)
self.connect('drag-leave', self.on_drag_leave)
self.connect('drag-data-received', self.on_drag_data_received)
self.view.connect('drag-motion', self.on_drag_motion)
self.view.connect('drag-leave', self.on_drag_leave)
event.add_callback(self.on_track_tags_changed, 'track_tags_changed')
event.add_callback(self.on_option_set, 'plugin_minimode_option_set')
self.on_option_set('plugin_minimode_option_set', settings,
'plugin/minimode/track_title_format')
def __init__(self, parent):
self.db = parent.db
parent_window = parent._main_window
self.view_star = parent.view_star # LEMONJuicerGUI.view_star()
self.toggle_toolbar_button = parent.set_finding_chart_button_active
self.builder = gtk.Builder()
self.builder.add_from_file(glade.FINDING_CHART_DIALOG)
self.dialog = self.builder.get_object('finding-chart-dialog')
self.dialog.set_resizable(True)
self.dialog.set_title("Finding Chart: %s" % self.db.field_name)
# gtk.RESPONSE_PREFERENCES doesn't exist: use gtk.RESPONSE_OK
self.dialog.add_button(gtk.STOCK_PREFERENCES, gtk.RESPONSE_OK)
self.dialog.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
self.dialog.set_default_response(gtk.RESPONSE_CLOSE)
# Connect to the accelerators of the parent window
self.dialog.add_accel_group(parent.global_accelators)
# This private variable stores whether the gtk.Dialog is currently
# visible or not. It is update to True and False when the show() and
# hide() methods are called, respectively.
self._currently_shown = False
# The matplotlib figure...
matplotlib_container = self.builder.get_object('matplotlib-container')
self.image_box = self.builder.get_object('image-container-box')
self.figure = matplotlib.figure.Figure()
canvas = FigureCanvas(self.figure)
self.image_box.pack_start(canvas)
# ... and the navigation toolbar
self.navigation_box = self.builder.get_object('navigation-toolbar-box')
self.navig = NavigationToolbar(canvas, self.image_box.get_window())
self.navigation_box.pack_start(self.navig)
matplotlib_container.show_all()
# Use the field name as the suggested filename of the FileChooserDialog
# when the user clicks on the 'Save' button on the navigation toolbar.
# See the docstring of app.StarDetailsGUI.update_file_selector_name()
# for an explanation on why we are monkey-patching this method.
canvas.get_window_title = lambda: self.db.field_name
self.dialog.set_transient_for(parent_window)
self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
ax1 = self.figure.add_subplot(111)
ax1.get_xaxis().set_visible(False)
ax1.get_yaxis().set_visible(False)
# Temporarily save to disk the FITS file used as a reference frame
path = self.db.mosaic
atexit.register(methods.clean_tmp_files, path)
self.wcs = astropy.wcs.WCS(path)
with pyfits.open(path) as hdu:
data = hdu[0].data
# Ignore any NaN pixels
self.data_min = numpy.nanmin(data)
self.data_max = numpy.nanmax(data)
self.aplpy_plot = aplpy.FITSFigure(path, figure = self.figure)
self.figure.canvas.mpl_connect('button_press_event', self.mark_closest_star)
self.aplpy_plot.show_grayscale()
self.aplpy_plot.add_grid()
self.aplpy_plot.grid.set_alpha(0.2)
# Create a PreferencesDialog object, whose __init__() method reads Vmin
# and Vmax from the LEMONdB or, in case these values are not stored in
# the database, uses the values computed by FITSFigure.show_grayscale()
# and stored in the APLpyNormalize object. After the PreferencesDialog
# is created we can call its normalize_plot() method for the first time
# in order to apply the normalization parameters to the finding chart.
#
# Note: we must create the PreferencesDialog *after* show_grayscale()
# has been called, because until then the underlying APLpyNormalize
# object (i.e., aplpy.FITSFigure.image.norm) does not exist, and the
# __init__() method of the PreferencesDialog class needs to access to
# it if the values of Vmin and Vmax cannot be read from the LEMONdB.
assert hasattr(self.aplpy_plot.image, 'norm')
self.preferences_dialog = PreferencesDialog(self)
self.preferences_dialog.normalize_plot()
# The dialog has always the same width; the height is adjusted
# proportionally depending on the dimensions of the FITS image.
size = data.shape[::-1]
size_ratio = size[1] / size[0]
new_size = self.WIDTH, int(self.WIDTH * size_ratio)
self.dialog.resize(*new_size)
# We cannot run() the dialog because it blocks in a recursive main
# loop, while we want it to be non-modal. Therefore, we need to show()
# it. But this means that we cannot get the response ID directly from
# run(), so we have to connect to the dialog 'response' event.
self.dialog.connect('response', self.handle_response)
# Don't destroy the gtk.Dialog if we click on the window's close button
self.dialog.connect('delete-event', self.on_delete_event)
# Button to, when a star is selected, view its details. We want to
# render a stock button, STOCK_GO_FORWARD, but with a different label.
# In order to achieve this, we register our own stock icon, reusing
# the image from the existing stock item, as seen in the PyGTK FAQ:
# http://faq.pygtk.org/index.py?req=show&file=faq09.005.htp
STOCK_GOTO_STAR = 'goto-star-custom'
gtk.stock_add([(STOCK_GOTO_STAR, '_Go to Star', 0, 0, None)])
factory = gtk.IconFactory()
factory.add_default()
style = self.dialog.get_style()
icon_set = style.lookup_icon_set(gtk.STOCK_GO_FORWARD)
factory.add(STOCK_GOTO_STAR, icon_set)
args = STOCK_GOTO_STAR, gtk.RESPONSE_APPLY
self.goto_button = self.dialog.add_button(*args)
self.goto_button.set_sensitive(False)
# <Ctrl>G also activates the 'Go to Star' button
accelerators = gtk.AccelGroup()
self.dialog.add_accel_group(accelerators)
key, modifier = gtk.accelerator_parse('<Control>G')
args = 'activate', accelerators, key, modifier, gtk.ACCEL_VISIBLE
self.goto_button.add_accelerator(*args)
def _build_menu(self):
menu = gtk.Menu()
item_tup = (
('_export_list_item', ('gtk-save', '_Export List', False, None,
self._export_list_button_released)),
gtk.SeparatorMenuItem(),
('_add_uri_item', ('gtk-add', '_Add Uri', True, None,
self._add_uri_button_released)),
gtk.SeparatorMenuItem(),
('_start_item', ('gtk-media-play-ltr', '_Start', False, None,
self._start_button_released)),
('_pause_item', ('gtk-media-pause', '_Pause', False, None,
self._pause_button_released)),
gtk.SeparatorMenuItem(),
('_rename_item', ('gtk-edit', '_Rename', False, None,
self._rename_button_released)),
('_copy_uri_item', ('edit-copy', '_Copy Uri', False, None,
self._copy_uri_button_released)),
gtk.SeparatorMenuItem(),
('_clear_item', ('gtk-clear', 'C_lear List', False, None,
self._clear_button_released)),
('_clear_completed_item',
('gtk-clear', 'Clear Completed Downloads', True, None,
self._clear_completed_button_released)),
('_remove_download_item',
('list-remove', 'Remove _Selected', False, 'Delete',
self._remove_download_button_released)),
gtk.SeparatorMenuItem(),
('_restart_server_item',
('gtk-refresh', 'Rest_art Aria2c Server', True, None,
self._restart_server_button_released)),
)
accel_group = gtk.AccelGroup()
menu.set_accel_group(accel_group)
for menu_item in item_tup:
if type(menu_item) == tuple:
item_name, (icon_name, label_text, is_sensitive, accel,
clicked_callback) = menu_item
icon = gtk.Image()
icon.set_from_icon_name(icon_name, gtk.ICON_SIZE_MENU)
item = gtk.ImageMenuItem()
item.set_image(icon)
item.set_label(label_text)
item.set_use_underline(True)
item.set_sensitive(is_sensitive)
item.connect('button-release-event', clicked_callback)
self.__setattr__(item_name, item)
if accel:
keyval, modifier = gtk.accelerator_parse(accel)
item.add_accelerator('activate', accel_group, keyval,
modifier, gtk.ACCEL_VISIBLE)
else:
item = menu_item
menu.add(item)
menu.show_all()
return menu
def _popup_tree_menu(self, path, col, event):
"""Launch a menu for this main treeview row (single selection)."""
shortcuts = []
menu = gtk.Menu()
menu.show()
model = self._view.get_model()
row_iter = model.get_iter(path)
sect_index = self.get_section_column_index()
this_section = model.get_value(row_iter, sect_index)
if this_section is not None:
# Jump to section.
menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_JUMP_TO)
label = rose.config_editor.SUMMARY_DATA_PANEL_MENU_GO_TO.format(
this_section.replace("_", "__"))
menuitem.set_label(label)
menuitem._section = this_section
menuitem.connect("activate",
lambda i: self.search_function(i._section))
menuitem.show()
menu.append(menuitem)
sep = gtk.SeparatorMenuItem()
sep.show()
menu.append(sep)
extra_menuitems = self._get_custom_menu_items(path, col, event)
if extra_menuitems:
for extra_menuitem in extra_menuitems:
menu.append(extra_menuitem)
if this_section is not None:
sep = gtk.SeparatorMenuItem()
sep.show()
menu.append(sep)
if self.is_duplicate:
# A section is currently selected
if this_section is not None:
# Add section.
add_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_ADD)
add_menuitem.set_label(
rose.config_editor.SUMMARY_DATA_PANEL_MENU_ADD)
add_menuitem.connect("activate", lambda i: self.add_section())
add_menuitem.show()
menu.append(add_menuitem)
# Copy section.
copy_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_COPY)
copy_menuitem.set_label(
rose.config_editor.SUMMARY_DATA_PANEL_MENU_COPY)
copy_menuitem.connect(
"activate", lambda i: self.copy_section(this_section))
copy_menuitem.show()
menu.append(copy_menuitem)
if (rose.variable.IGNORED_BY_USER
in self.sections[this_section].ignored_reason):
# Enable section.
enab_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_YES)
enab_menuitem.set_label(
rose.config_editor.SUMMARY_DATA_PANEL_MENU_ENABLE)
enab_menuitem.connect(
"activate", lambda i: self.sub_ops.ignore_section(
this_section, False))
enab_menuitem.show()
menu.append(enab_menuitem)
shortcuts.append(
(rose.config_editor.ACCEL_IGNORE, enab_menuitem))
else:
# Ignore section.
ign_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_NO)
ign_menuitem.set_label(
rose.config_editor.SUMMARY_DATA_PANEL_MENU_IGNORE)
ign_menuitem.connect(
"activate", lambda i: self.sub_ops.ignore_section(
this_section, True))
ign_menuitem.show()
menu.append(ign_menuitem)
shortcuts.append(
(rose.config_editor.ACCEL_IGNORE, ign_menuitem))
# Remove section.
rem_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_REMOVE)
rem_menuitem.set_label(
rose.config_editor.SUMMARY_DATA_PANEL_MENU_REMOVE)
rem_menuitem.connect(
"activate", lambda i: self.remove_section(this_section))
rem_menuitem.show()
menu.append(rem_menuitem)
shortcuts.append(
(rose.config_editor.ACCEL_REMOVE, rem_menuitem))
else: # A group is currently selected.
# Ignore all
ign_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_NO)
ign_menuitem.set_label(
rose.config_editor.SUMMARY_DATA_PANEL_MENU_IGNORE)
ign_menuitem.connect("activate",
self._ignore_selected_sections, True)
ign_menuitem.show()
menu.append(ign_menuitem)
shortcuts.append(
(rose.config_editor.ACCEL_IGNORE, ign_menuitem))
# Enable all
ign_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_YES)
ign_menuitem.set_label(
rose.config_editor.SUMMARY_DATA_PANEL_MENU_ENABLE)
ign_menuitem.connect("activate",
self._ignore_selected_sections, False)
ign_menuitem.show()
menu.append(ign_menuitem)
shortcuts.append(
(rose.config_editor.ACCEL_IGNORE, ign_menuitem))
# Delete all.
rem_menuitem = gtk.ImageMenuItem(stock_id=gtk.STOCK_REMOVE)
rem_menuitem.set_label(
rose.config_editor.SUMMARY_DATA_PANEL_MENU_REMOVE)
rem_menuitem.connect("activate",
self._remove_selected_sections)
rem_menuitem.show()
menu.append(rem_menuitem)
shortcuts.append(
(rose.config_editor.ACCEL_REMOVE, rem_menuitem))
# list shortcut keys
accel = gtk.AccelGroup()
menu.set_accel_group(accel)
for key_press, menuitem in shortcuts:
key, mod = gtk.accelerator_parse(key_press)
menuitem.add_accelerator('activate', accel, key, mod,
gtk.ACCEL_VISIBLE)
menu.popup(None, None, None, event.button, event.time)
return False
def RunKeySelector(self, widget):
def ShowHideBox(button, box, dialog):
if button.get_active():
box.show()
else:
box.hide()
dialog.resize(1, 1)
def HandleGrabberChanged(grabber, key, mods, label, selector):
new = GetAcceleratorName(key, mods)
mods = ""
for mod in KeyModifier:
if "%s_L" % mod in new:
new = new.replace("%s_L" % mod, "<%s>" % mod)
if "%s_R" % mod in new:
new = new.replace("%s_R" % mod, "<%s>" % mod)
if "<%s>" % mod in new:
mods += "%s|" % mod
mods.rstrip("|")
label.set_text(self.GetLabelText(new))
selector.current = mods
def HandleModifierAdded(selector, modifier, label):
current = label.get_text()
if current == _("Disabled"):
current = "<%s>" % modifier
else:
current = ("<%s>" % modifier) + current
label.set_text(self.ReorderKeyString(current))
def HandleModifierRemoved(selector, modifier, label):
current = label.get_text()
if "<%s>" % modifier in current:
new = current.replace("<%s>" % modifier, "")
elif "%s_L" % modifier in current:
new = current.replace("%s_L" % modifier, "")
elif "%s_R" % modifier in current:
new = current.replace("%s_R" % modifier, "")
label.set_text(self.GetLabelText(new))
dlg = gtk.Dialog(_("Edit %s") % self.Setting.ShortDesc)
dlg.set_position(gtk.WIN_POS_CENTER_ALWAYS)
dlg.set_transient_for(self.Widget.get_toplevel())
dlg.set_icon(self.Widget.get_toplevel().get_icon())
dlg.set_modal(True)
dlg.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dlg.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK).grab_default()
dlg.set_default_response(gtk.RESPONSE_OK)
mainBox = gtk.VBox()
alignment = gtk.Alignment()
alignment.set_padding(10, 10, 10, 10)
alignment.add(mainBox)
dlg.vbox.pack_start(alignment)
checkButton = gtk.CheckButton(_("Enabled"))
active = len (self.current) \
and self.current.lower () not in ("disabled", "none")
checkButton.set_active(active)
checkButton.set_tooltip_text(self.Setting.LongDesc)
mainBox.pack_start(checkButton)
box = gtk.VBox()
checkButton.connect("toggled", ShowHideBox, box, dlg)
mainBox.pack_start(box)
currentMods = ""
for mod in KeyModifier:
if "<%s>" % mod in self.current:
currentMods += "%s|" % mod
currentMods.rstrip("|")
modifierSelector = ModifierSelector(currentMods)
modifierSelector.set_tooltip_text(self.Setting.LongDesc)
alignment = gtk.Alignment(0.5)
alignment.add(modifierSelector)
box.pack_start(alignment)
key, mods = gtk.accelerator_parse(self.current)
grabber = KeyGrabber(key=key,
mods=mods,
label=_("Grab key combination"))
grabber.set_tooltip_text(self.Setting.LongDesc)
box.pack_start(grabber)
label = gtk.Label(self.current)
label.set_tooltip_text(self.Setting.LongDesc)
alignment = gtk.Alignment(0.5, 0.5)
alignment.set_padding(15, 0, 0, 0)
alignment.add(label)
box.pack_start(alignment)
modifierSelector.connect("added", HandleModifierAdded, label)
modifierSelector.connect("removed", HandleModifierRemoved, label)
grabber.connect("changed", HandleGrabberChanged, label,
modifierSelector)
grabber.connect("current-changed", HandleGrabberChanged, label,
modifierSelector)
dlg.vbox.show_all()
ShowHideBox(checkButton, box, dlg)
ret = dlg.run()
dlg.destroy()
if ret != gtk.RESPONSE_OK:
return
if not checkButton.get_active():
self.BindingEdited("Disabled")
return
new = label.get_text()
new = self.ReorderKeyString(new)
self.BindingEdited(new)
def __init__(self, no_dialog=False):
self.settings = EventCore()
self.gui_is_active = False
# during initialization any dialog (e.g. "Unit change") is not allowed
# we set the final value later
self.no_dialog = True
self._batch_queue = []
self._undo_states = []
self.gui = gtk.Builder()
gtk_build_file = get_ui_file_location(GTKBUILD_FILE)
if gtk_build_file is None:
gtk.main_quit()
self.gui.add_from_file(gtk_build_file)
if pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS:
gtkrc_file = get_ui_file_location(GTKRC_FILE_WINDOWS)
if gtkrc_file:
gtk.rc_add_default_file(gtkrc_file)
gtk.rc_reparse_all_for_settings(gtk.settings_get_default(),
True)
self.window = self.gui.get_object("ProjectWindow")
self.settings.set("main_window", self.window)
# show stock items on buttons
# increase the initial width of the window (due to hidden elements)
self.window.set_default_size(400, -1)
# initialize the RecentManager (TODO: check for Windows)
if False and pycam.Utils.get_platform(
) == pycam.Utils.PLATFORM_WINDOWS:
# The pyinstaller binary for Windows fails mysteriously when trying
# to display the stock item.
# Error message: Gtk:ERROR:gtkrecentmanager.c:1942:get_icon_fallback:
# assertion failed: (retval != NULL)
self.recent_manager = None
else:
try:
self.recent_manager = gtk.recent_manager_get_default()
except AttributeError:
# GTK 2.12.1 seems to have problems with "RecentManager" on
# Windows. Sadly this is the version, that is shipped with the
# "appunti" GTK packages for Windows (April 2010).
# see http://www.daa.com.au/pipermail/pygtk/2009-May/017052.html
self.recent_manager = None
# file loading
self.last_dirname = None
self.last_task_settings_uri = None
self.last_model_uri = None
# define callbacks and accelerator keys for the menu actions
for objname, callback, data, accel_key in (
("OpenModel", self.load_model_file, None,
"<Control>o"), ("Quit", self.destroy, None, "<Control>q"),
("GeneralSettings", self.toggle_preferences_window, None,
"<Control>p"), ("UndoButton", self._restore_undo_state, None,
"<Control>z"), ("HelpUserManual", self.show_help,
"User_Manual", "F1"),
("HelpIntroduction", self.show_help, "Introduction", None),
("HelpSupportedFormats", self.show_help, "SupportedFormats",
None), ("HelpModelTransformations", self.show_help,
"ModelTransformations",
None), ("HelpToolTypes", self.show_help, "ToolTypes",
None), ("HelpProcessSettings", self.show_help,
"ProcessSettings", None),
("HelpBoundsSettings", self.show_help, "BoundsSettings",
None), ("HelpTaskSetup", self.show_help, "TaskSetup", None),
("HelpGCodeExport", self.show_help, "GCodeExport",
None), ("HelpTouchOff", self.show_help, "TouchOff",
None), ("HelpSimulation", self.show_help, "Simulation",
None), ("Help3DView", self.show_help, "3D_View",
None), ("HelpServerMode", self.show_help,
"ServerMode", None),
("HelpCommandLine", self.show_help, "CommandlineExamples",
None), ("HelpHotkeys", self.show_help, "KeyboardShortcuts",
None), ("ProjectWebsite", self.show_help,
"http://pycam.sourceforge.net",
None), ("DevelopmentBlog", self.show_help,
"http://fab.senselab.org/pycam", None),
("Forum", self.show_help,
"http://sourceforge.net/projects/pycam/forums", None),
("BugTracker", self.show_help,
"http://sourceforge.net/tracker/?group_id=237831&atid=1104176",
None),
("FeatureRequest", self.show_help,
"http://sourceforge.net/tracker/?group_id=237831&atid=1104179",
None)):
item = self.gui.get_object(objname)
action = "activate"
if data is None:
item.connect(action, callback)
else:
item.connect(action, callback, data)
if accel_key:
key, mod = gtk.accelerator_parse(accel_key)
accel_path = "<pycam>/%s" % objname
item.set_accel_path(accel_path)
gtk.accel_map_change_entry(accel_path, key, mod, True)
# LinkButton does not work on Windows: https://bugzilla.gnome.org/show_bug.cgi?id=617874
if pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS:
def open_url(widget, data=None):
webbrowser.open(widget.get_uri())
gtk.link_button_set_uri_hook(open_url)
# no undo is allowed at the beginning
self.gui.get_object("UndoButton").set_sensitive(False)
self.settings.register_event("model-change-before",
self._store_undo_state)
self.settings.register_event(
"model-change-after",
lambda: self.settings.emit_event("visual-item-updated"))
# configure drag-n-drop for config files and models
self.settings.set("configure-drag-drop-func",
self.configure_drag_and_drop)
self.settings.get("configure-drag-drop-func")(self.window)
# other events
self.window.connect("destroy", self.destroy)
self.window.connect("delete-event", self.destroy)
# the settings window
self.gui.get_object("CloseSettingsWindow").connect(
"clicked", self.toggle_preferences_window, False)
self.gui.get_object("ResetPreferencesButton").connect(
"clicked", self.reset_preferences)
self.preferences_window = self.gui.get_object("GeneralSettingsWindow")
self.preferences_window.connect("delete-event",
self.toggle_preferences_window, False)
self._preferences_window_position = None
self._preferences_window_visible = False
# "about" window
self.about_window = self.gui.get_object("AboutWindow")
self.about_window.set_version(VERSION)
self.gui.get_object("About").connect("activate",
self.toggle_about_window, True)
# we assume, that the last child of the window is the "close" button
# TODO: fix this ugly hack!
self.gui.get_object("AboutWindowButtons").get_children()[-1].connect(
"clicked", self.toggle_about_window, False)
self.about_window.connect("delete-event", self.toggle_about_window,
False)
# menu bar
uimanager = gtk.UIManager()
self.settings.set("gtk-uimanager", uimanager)
self._accel_group = uimanager.get_accel_group()
# send a "delete" event on "CTRL-w" for every window
def handle_window_close(accel_group, window, *args):
window.emit("delete-event", gtk.gdk.Event(gtk.gdk.DELETE))
self._accel_group.connect_group(ord('w'), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_LOCKED, handle_window_close)
self.settings.add_item("gtk-accel-group", lambda: self._accel_group)
for obj in self.gui.get_objects():
if isinstance(obj, gtk.Window):
obj.add_accel_group(self._accel_group)
# preferences tab
preferences_book = self.gui.get_object("PreferencesNotebook")
def clear_preferences():
for child in preferences_book.get_children():
preferences_book.remove(child)
def add_preferences_item(item, name):
preferences_book.append_page(item, gtk.Label(name))
self.settings.register_ui_section("preferences", add_preferences_item,
clear_preferences)
for obj_name, label, priority in (("GeneralSettingsPrefTab", "General",
-50), ("ProgramsPrefTab",
"Programs", 50)):
obj = self.gui.get_object(obj_name)
obj.unparent()
self.settings.register_ui("preferences", label, obj, priority)
# general preferences
general_prefs = self.gui.get_object("GeneralPreferencesBox")
def clear_general_prefs():
for item in general_prefs.get_children():
general_prefs.remove(item)
def add_general_prefs_item(item, name):
general_prefs.pack_start(item, expand=False, padding=3)
self.settings.register_ui_section("preferences_general",
add_general_prefs_item,
clear_general_prefs)
# defaults settings file
obj = self.gui.get_object("TaskSettingsDefaultFileBox")
obj.unparent()
self.settings.register_ui("preferences_general", None, obj, 30)
# set defaults
self.cutter = None
# add some dummies - to be implemented later ...
self.settings.add_item("cutter", lambda: self.cutter)
main_tab = self.gui.get_object("MainTabs")
def clear_main_tab():
while main_tab.get_n_pages() > 0:
main_tab.remove_page(0)
def add_main_tab_item(item, name):
main_tab.append_page(item, gtk.Label(name))
# TODO: move these to plugins, as well
self.settings.register_ui_section("main", add_main_tab_item,
clear_main_tab)
main_window = self.gui.get_object("WindowBox")
def clear_main_window():
main_window.foreach(main_window.remove)
def add_main_window_item(item, name, **extra_args):
# some widgets may want to override the defaults
args = {"expand": False, "fill": False}
args.update(extra_args)
main_window.pack_start(item, **args)
main_tab.unparent()
self.settings.register_ui_section("main_window", add_main_window_item,
clear_main_window)
self.settings.register_ui("main_window",
"Tabs",
main_tab,
-20,
args_dict={
"expand": True,
"fill": True
})
def disable_gui():
self.menubar.set_sensitive(False)
main_tab.set_sensitive(False)
def enable_gui():
self.menubar.set_sensitive(True)
main_tab.set_sensitive(True)
self.settings.register_event("gui-disable", disable_gui)
self.settings.register_event("gui-enable", enable_gui)
# configure locations of external programs
for auto_control_name, location_control_name, browse_button, key in (
("ExternalProgramInkscapeAuto", "ExternalProgramInkscapeControl",
"ExternalProgramInkscapeBrowse", "inkscape"),
("ExternalProgramPstoeditAuto", "ExternalProgramPstoeditControl",
"ExternalProgramPstoeditBrowse", "pstoedit")):
self.gui.get_object(auto_control_name).connect(
"clicked", self._locate_external_program, key)
location_control = self.gui.get_object(location_control_name)
self.settings.add_item("external_program_%s" % key,
location_control.get_text,
location_control.set_text)
self.gui.get_object(browse_button).connect(
"clicked", self._browse_external_program_location, key)
# set the icons (in different sizes) for all windows
gtk.window_set_default_icon_list(*get_icons_pixbuffers())
# load menu data
gtk_menu_file = get_ui_file_location(GTKMENU_FILE)
if gtk_menu_file is None:
gtk.main_quit()
uimanager.add_ui_from_file(gtk_menu_file)
# make the actions defined in the GTKBUILD file available in the menu
actiongroup = gtk.ActionGroup("menubar")
for action in [
aobj for aobj in self.gui.get_objects()
if isinstance(aobj, gtk.Action)
]:
actiongroup.add_action(action)
# the "pos" parameter is optional since 2.12 - we can remove it later
uimanager.insert_action_group(actiongroup, pos=-1)
# the "recent files" sub-menu
if self.recent_manager is not None:
recent_files_menu = gtk.RecentChooserMenu(self.recent_manager)
recent_files_menu.set_name("RecentFilesMenu")
recent_menu_filter = gtk.RecentFilter()
case_converter = pycam.Utils.get_case_insensitive_file_pattern
for filter_name, patterns in FILTER_MODEL:
if not isinstance(patterns, (list, set, tuple)):
patterns = [patterns]
# convert it into a mutable list (instead of set/tuple)
patterns = list(patterns)
for index in range(len(patterns)):
patterns[index] = case_converter(patterns[index])
for pattern in patterns:
recent_menu_filter.add_pattern(pattern)
recent_files_menu.add_filter(recent_menu_filter)
recent_files_menu.set_show_numbers(True)
# non-local files (without "file://") are not supported. yet
recent_files_menu.set_local_only(False)
# most recent files to the top
recent_files_menu.set_sort_type(gtk.RECENT_SORT_MRU)
# show only ten files
recent_files_menu.set_limit(10)
uimanager.get_widget("/MenuBar/FileMenu/OpenRecentModelMenu"
).set_submenu(recent_files_menu)
recent_files_menu.connect("item-activated",
self.load_recent_model_file)
else:
self.gui.get_object("OpenRecentModel").set_visible(False)
# load the menubar and connect functions to its items
self.menubar = uimanager.get_widget("/MenuBar")
# dict of all merge-ids
menu_merges = {}
def clear_menu(menu_key):
for merge in menu_merges.get(menu_key, []):
uimanager.remove_ui(merge)
def append_menu_item(menu_key, base_path, widget, name):
merge_id = uimanager.new_merge_id()
if widget:
action_group = widget.props.action_group
if action_group not in uimanager.get_action_groups():
uimanager.insert_action_group(action_group, -1)
widget_name = widget.get_name()
item_type = gtk.UI_MANAGER_MENUITEM
else:
widget_name = name
item_type = gtk.UI_MANAGER_SEPARATOR
uimanager.add_ui(merge_id, base_path, name, widget_name, item_type,
False)
if menu_key not in menu_merges:
menu_merges[menu_key] = []
menu_merges[menu_key].append(merge_id)
def get_menu_funcs(menu_key, base_path):
return (lambda widget, name: append_menu_item(
menu_key, base_path, widget, name),
lambda: clear_menu(menu_key))
for ui_name, base_path in (("view_menu", "/MenuBar/ViewMenu"),
("file_menu", "/MenuBar/FileMenu"),
("edit_menu", "/MenuBar/EditMenu"),
("export_menu",
"/MenuBar/FileMenu/ExportMenu")):
append_func, clear_func = get_menu_funcs(ui_name, base_path)
self.settings.register_ui_section(ui_name, append_func, clear_func)
self.settings.register_ui("file_menu", "Quit",
self.gui.get_object("Quit"), 100)
self.settings.register_ui("file_menu", "QuitSeparator", None, 95)
self.settings.register_ui("main_window", "Main", self.menubar, -100)
# initialize plugins
self.plugin_manager = pycam.Plugins.PluginManager(core=self.settings)
self.plugin_manager.import_plugins()
# some more initialization
self.reset_preferences()
# TODO: preferences are not loaded until the new format is stable
# self.load_preferences()
# self.load_task_settings()
self.settings.register_event("notify-file-saved",
self.add_to_recent_file_list)
self.settings.register_event("notify-file-opened",
self.add_to_recent_file_list)
# Without this "gkt.main_iteration" loop the task settings file
# control would not be updated in time.
while gtk.events_pending():
gtk.main_iteration()
self.no_dialog = no_dialog
if not self.no_dialog:
# register a logging handler for displaying error messages
pycam.Utils.log.add_gtk_gui(self.window, logging.ERROR)
self.window.show()
self.settings.emit_event("notify-initialization-finished")
def __add_controls(self):
self.set_default_size(800, 600)
self.set_title("Diff View")
mainvbox = gtk.VBox()
menubar = gtk.MenuBar()
edititem = gtk.MenuItem("_Edit")
menubar.append(edititem)
agr = gtk.AccelGroup()
self.add_accel_group(agr)
self.popup = editmenu = gtk.Menu()
edititem.set_submenu(editmenu)
copyitem = gtk.MenuItem("Copy")
copyitem.connect("activate", self.on_copy)
key, mod = gtk.accelerator_parse("<Control>C")
copyitem.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
editmenu.append(copyitem)
mainvbox.pack_start(menubar, expand = False)
hpane = gtk.HPaned()
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.treeview = gtk.TreeView()
self.treeview.get_selection().set_mode(gtk.SELECTION_SINGLE)
self.treeview.get_selection().connect("changed", self.on_select_row)
# Node column
celltext = gtk.CellRendererText()
column = gtk.TreeViewColumn("Node", celltext)
column.set_cell_data_func(celltext, self.set_celltext)
self.treeview.append_column(column)
# 0: The node tag
# 1: The attributes dict
# 2: The value of the node if any
# 3: The old value of the node
# 4: "insert", "delete", "update", ""
self.treestore = gtk.TreeStore(gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)
self.treeview.set_enable_search(False)
self.treeview.connect("button_press_event", self.on_treeview_button_press)
self.treeview.connect("popup_menu", self.on_treeview_popup)
scrolledwindow.add(self.treeview)
hpane.pack1(scrolledwindow, True)
vpane = gtk.VPaned()
frame = gtk.Frame()
label = gtk.Label()
label.set_markup("<b>Attributes</b>")
frame.set_label_widget(label)
frame.set_shadow_type(gtk.SHADOW_NONE)
self.attribview = gtk.TreeView()
celltext = gtk.CellRendererText()
keycolumn = gtk.TreeViewColumn("Key", celltext)
keycolumn.set_cell_data_func(celltext, self.set_cellkey)
self.attribview.append_column(keycolumn)
celltext = gtk.CellRendererText()
valuecolumn = gtk.TreeViewColumn("Value", celltext)
valuecolumn.set_cell_data_func(celltext, self.set_cellvalue)
self.attribview.append_column(valuecolumn)
frame.add(self.attribview)
vpane.pack1(frame)
frame = gtk.Frame()
label = gtk.Label()
label.set_markup("<b>Data</b>")
frame.set_label_widget(label)
frame.set_shadow_type(gtk.SHADOW_NONE)
self.dataview = gtk.TextView()
self.dataview.set_cursor_visible(False)
self.dataview.set_editable(False)
self.__create_tags(self.dataview.get_buffer())
frame.add(self.dataview)
vpane.pack2(frame)
hpane.pack2(vpane)
mainvbox.pack_start(hpane)
self.add(mainvbox)
def __init__(self, plugin):
try:
self._instance, self._window = plugin.get_instance()
except:
pass
gladefile = os.path.join(os.path.dirname(__file__), "FindDialog.glade")
ui = gtk.Builder()
ui.set_translation_domain('advancedfind')
ui.add_from_file(gladefile)
ui.connect_signals({
"on_findDialog_destroy":
self.on_findDialog_destroy_action,
"on_findDialog_focus_in_event":
self.on_findDialog_focus_in_event_action,
"on_findDialog_focus_out_event":
self.on_findDialog_focus_out_event_action,
"on_findButton_clicked":
self.on_findButton_clicked_action,
"on_replaceButton_clicked":
self.on_replaceButton_clicked_action,
"on_findAllButton_clicked":
self.on_findAllButton_clicked_action,
"on_replaceAllButton_clicked":
self.on_replaceAllButton_clicked_action,
"on_closeButton_clicked":
self.on_closeButton_clicked_action,
"on_selectPathButton_clicked":
self.on_selectPathButton_clicked_action,
"on_selectPathDialogOkButton_clicked":
self.on_selectPathDialogOkButton_clicked_action,
"on_selectPathDialogCancelButton_clicked":
self.on_selectPathDialogCancelButton_clicked_action,
"on_matchWholeWordCheckbutton_toggled":
self.on_matchWholeWordCheckbutton_toggled_action,
"on_matchCaseCheckbutton_toggled":
self.on_matchCaseCheckbutton_toggled_action,
"on_wrapAroundCheckbutton_toggled":
self.on_wrapAroundCheckbutton_toggled_action,
"on_followCurrentDocCheckbutton_toggled":
self.on_followCurrentDocCheckbutton_toggled_action,
"on_includeSubfolderCheckbutton_toggled":
self.on_includeSubfolderCheckbutton_toggled_action,
"on_regexSearchCheckbutton_toggled":
self.on_regexSearchCheckbutton_toggled_action,
"on_forwardRadiobutton_toggled":
self.directionRadiobuttonGroup_action,
"on_backwardRadiobutton_toggled":
self.directionRadiobuttonGroup_action,
"on_currentFileRadiobutton_toggled":
self.scopeRadiobuttonGroup_action,
"on_allFilesRadiobutton_toggled":
self.scopeRadiobuttonGroup_action,
"on_allFilesInPathRadiobutton_toggled":
self.scopeRadiobuttonGroup_action,
"on_currentSelectionRadiobutton_toggled":
self.scopeRadiobuttonGroup_action
})
self.findDialog = ui.get_object("findDialog")
#self.findDialog.set_keep_above(True)
self.findDialog.set_transient_for(self._window)
accelgroup = gtk.AccelGroup()
#key, modifier = gtk.accelerator_parse('Escape')
#accelgroup.connect_group(key, modifier, gtk.ACCEL_VISIBLE, self.esc_accel_action)
key, modifier = gtk.accelerator_parse('Return')
accelgroup.connect_group(key, modifier, gtk.ACCEL_VISIBLE,
self.return_accel_action)
key, modifier = gtk.accelerator_parse('KP_Enter')
accelgroup.connect_group(key, modifier, gtk.ACCEL_VISIBLE,
self.return_accel_action)
self.findDialog.add_accel_group(accelgroup)
self.findTextEntry = ui.get_object("findTextComboboxentry")
#self.findTextListstore = ui.get_object("findTextListstore")
#find_cell = gtk.CellRendererText()
#self.findTextEntry.pack_start(find_cell, True)
#self.findTextEntry.add_attribute(find_cell, 'text', 0)
self.findTextEntry.set_text_column(0)
self.findTextEntry.child.set_icon_from_stock(1, "gtk-clear")
self.findTextEntry.child.connect('icon-press', self.findEntryIconPress)
try:
for find_text in self._instance.find_history:
self.findTextEntry.prepend_text(find_text)
except:
pass
self.replaceTextEntry = ui.get_object("replaceTextComboboxentry")
#self.replaceTextListstore = ui.get_object("replaceTextListstore")
#replace_cell = gtk.CellRendererText()
#self.replaceTextEntry.pack_start(replace_cell, True)
#self.replaceTextEntry.add_attribute(replace_cell, 'text', 0)
self.replaceTextEntry.set_text_column(0)
self.replaceTextEntry.child.set_icon_from_stock(1, "gtk-clear")
self.replaceTextEntry.child.connect('icon-press',
self.replaceEntryIconPress)
try:
for replace_text in self._instance.replace_history:
self.replaceTextEntry.prepend_text(replace_text)
except:
pass
self.filterComboboxentry = ui.get_object("filterComboboxentry")
self.filterComboboxentry.set_text_column(0)
self.filterComboboxentry.child.set_text("*")
#self.filterComboboxentry.prepend_text("*")
self.filterComboboxentry.child.set_icon_from_stock(1, "gtk-clear")
self.filterComboboxentry.child.connect('icon-press',
self.filterEntryIconPress)
try:
for file_filter in self._instance.file_type_history:
self.filterComboboxentry.prepend_text(file_filter)
except:
pass
self.selectPathFilechooserdialog = ui.get_object(
"selectPathFilechooserdialog")
self.pathComboboxentry = ui.get_object("pathComboboxentry")
self.pathComboboxentry.set_text_column(0)
self.pathComboboxentry.child.set_icon_from_stock(1, "gtk-clear")
self.pathComboboxentry.child.connect('icon-press',
self.pathEntryIconPress)
filebrowser_root = self.get_filebrowser_root()
if filebrowser_root != None and self._instance.find_options[
'ROOT_FOLLOW_FILEBROWSER'] == True:
self.pathComboboxentry.child.set_text(filebrowser_root)
else:
self.pathComboboxentry.child.set_text(
self.selectPathFilechooserdialog.get_filename())
try:
for path in self._instance.file_path_history:
self.pathComboboxentry.prepend_text(path)
except:
pass
self.pathExpander = ui.get_object("pathExpander")
self.pathExpander.set_expanded(
self._instance.find_dlg_setting['PATH_EXPANDED'])
self.matchWholeWordCheckbutton = ui.get_object(
"matchWholeWordCheckbutton")
self.matchCaseCheckbutton = ui.get_object("matchCaseCheckbutton")
self.wrapAroundCheckbutton = ui.get_object("wrapAroundCheckbutton")
self.followCurrentDocCheckbutton = ui.get_object(
"followCurrentDocCheckbutton")
self.includeSubfolderCheckbutton = ui.get_object(
"includeSubfolderCheckbutton")
self.regexSearchCheckbutton = ui.get_object("regexSearchCheckbutton")
self.optionsExpander = ui.get_object("optionsExpander")
self.optionsExpander.set_expanded(
self._instance.find_dlg_setting['OPTIONS_EXPANDED'])
self.forwardRadiobutton = ui.get_object("forwardRadiobutton")
self.backwardRadiobutton = ui.get_object("backwardRadiobutton")
if self._instance.forwardFlg == True:
self.forwardRadiobutton.set_active(True)
else:
self.backwardRadiobutton.set_active(True)
self.currentFileRadiobutton = ui.get_object("currentFileRadiobutton")
self.allFilesRadiobutton = ui.get_object("allFilesRadiobutton")
self.allFilesInPathRadiobutton = ui.get_object(
"allFilesInPathRadiobutton")
self.currentSelectionRadiobutton = ui.get_object(
"currentSelectionRadiobutton")
if self._instance.scopeFlg == 0:
self.currentFileRadiobutton.set_active(True)
elif self._instance.scopeFlg == 1:
self.allFilesRadiobutton.set_active(True)
elif self._instance.scopeFlg == 2:
self.allFilesInPathRadiobutton.set_active(True)
elif self._instance.scopeFlg == 3:
self.currentSelectionRadiobutton.set_active(True)
self.findButton = ui.get_object("findButton")
self.replaceButton = ui.get_object("replaceButton")
self.findAllButton = ui.get_object("findAllButton")
self.replaceAllButton = ui.get_object("replaceAllButton")
self.closeButton = ui.get_object("closeButton")
self.selectPathButton = ui.get_object("selectPathButton")
self.findDialog.show()
self.matchWholeWordCheckbutton.set_active(
self._instance.find_options['MATCH_WHOLE_WORD'])
self.matchCaseCheckbutton.set_active(
self._instance.find_options['MATCH_CASE'])
self.wrapAroundCheckbutton.set_active(
self._instance.find_options['WRAP_AROUND'])
self.followCurrentDocCheckbutton.set_active(
self._instance.find_options['FOLLOW_CURRENT_DOC'])
self.includeSubfolderCheckbutton.set_active(
self._instance.find_options['INCLUDE_SUBFOLDER'])
self.regexSearchCheckbutton.set_active(
self._instance.find_options['REGEX_SEARCH'])
if self._instance.find_options['FOLLOW_CURRENT_DOC'] == True:
self.pathComboboxentry.child.set_text(
os.path.dirname(self._instance._window.get_active_document().
get_uri_for_display()))
def __init__(self,
hosts=None,
patterns_name=None,
patterns_owner=None,
comms_timeout=None,
interval=None):
gobject.threads_init()
set_exception_hook_dialog("cylc gscan")
setup_icons()
self.window = gtk.Window()
title = "cylc gscan"
for opt, items in [("-n", patterns_name), ("-o", patterns_owner)]:
if items:
for pattern in items:
if pattern is not None:
title += " %s %s" % (opt, pattern)
self.window.set_title(title)
self.window.set_icon(get_icon())
self.vbox = gtk.VBox()
self.vbox.show()
self.warnings = {}
self.theme_name = gcfg.get(['use theme'])
self.theme = gcfg.get(['themes', self.theme_name])
suite_treemodel = gtk.TreeStore(
str, # group
str, # host
str, # owner
str, # suite
bool, # is_stopped
str, # title
int, # update_time
str, # states
str, # states_text
str) # warning_text
self._prev_tooltip_location_id = None
self.treeview = gtk.TreeView(suite_treemodel)
# Visibility of columns
vis_cols = gsfg.get(["columns"])
hide_main_menu_bar = gsfg.get(["hide main menubar"])
# Doesn't make any sense without suite name column
if gsfg.COL_SUITE not in vis_cols:
vis_cols.append(gsfg.COL_SUITE.lower())
# Construct the group, host, owner, suite, title, update time column.
for col_title, col_id, col_cell_text_setter in [
(gsfg.COL_GROUP, self.GROUP_COLUMN, self._set_cell_text_group),
(gsfg.COL_HOST, self.HOST_COLUMN, self._set_cell_text_host),
(gsfg.COL_OWNER, self.OWNER_COLUMN, self._set_cell_text_owner),
(gsfg.COL_SUITE, self.SUITE_COLUMN, self._set_cell_text_name),
(gsfg.COL_TITLE, self.TITLE_COLUMN, self._set_cell_text_title),
(gsfg.COL_UPDATED, self.UPDATE_TIME_COLUMN,
self._set_cell_text_time),
]:
column = gtk.TreeViewColumn(col_title)
cell_text = gtk.CellRendererText()
column.pack_start(cell_text, expand=False)
column.set_cell_data_func(cell_text, col_cell_text_setter)
column.set_sort_column_id(col_id)
column.set_visible(col_title.lower() in vis_cols)
column.set_resizable(True)
self.treeview.append_column(column)
# Construct the status column.
status_column = gtk.TreeViewColumn(gsfg.COL_STATUS)
status_column.set_sort_column_id(self.STATUS_COLUMN)
status_column.set_visible(gsfg.COL_STATUS.lower() in vis_cols)
status_column.set_resizable(True)
cell_text_cycle = gtk.CellRendererText()
status_column.pack_start(cell_text_cycle, expand=False)
status_column.set_cell_data_func(cell_text_cycle,
self._set_cell_text_cycle,
self.CYCLE_COLUMN)
self.treeview.append_column(status_column)
# Warning icon.
warn_icon = gtk.CellRendererPixbuf()
image = gtk.Image()
pixbuf = image.render_icon(gtk.STOCK_DIALOG_WARNING,
gtk.ICON_SIZE_LARGE_TOOLBAR)
self.warn_icon_colour = pixbuf.scale_simple( # colour warn icon pixbuf
self.ICON_SIZE, self.ICON_SIZE, gtk.gdk.INTERP_HYPER)
self.warn_icon_grey = pixbuf.scale_simple(self.ICON_SIZE,
self.ICON_SIZE,
gtk.gdk.INTERP_HYPER)
self.warn_icon_colour.saturate_and_pixelate(
self.warn_icon_grey, 0, False) # b&w warn icon pixbuf
status_column.pack_start(warn_icon, expand=False)
status_column.set_cell_data_func(warn_icon, self._set_error_icon_state)
self.warn_icon_blank = gtk.gdk.Pixbuf( # Transparent pixbuff.
gtk.gdk.COLORSPACE_RGB, True, 8, self.ICON_SIZE,
self.ICON_SIZE).fill(0x00000000)
# Task status icons.
for i in range(len(TASK_STATUSES_ORDERED)):
cell_pixbuf_state = gtk.CellRendererPixbuf()
status_column.pack_start(cell_pixbuf_state, expand=False)
status_column.set_cell_data_func(cell_pixbuf_state,
self._set_cell_pixbuf_state, i)
self.treeview.show()
if hasattr(self.treeview, "set_has_tooltip"):
self.treeview.set_has_tooltip(True)
try:
self.treeview.connect('query-tooltip', self._on_query_tooltip)
except TypeError:
# Lower PyGTK version.
pass
self.treeview.connect("button-press-event",
self._on_button_press_event)
patterns = {"name": None, "owner": None}
for label, items in [("owner", patterns_owner),
("name", patterns_name)]:
if items:
patterns[label] = r"\A(?:" + r")|(?:".join(items) + r")\Z"
try:
patterns[label] = re.compile(patterns[label])
except re.error:
raise ValueError("Invalid %s pattern: %s" % (label, items))
self.updater = ScanAppUpdater(self.window,
hosts,
suite_treemodel,
self.treeview,
comms_timeout=comms_timeout,
interval=interval,
group_column_id=self.GROUP_COLUMN,
name_pattern=patterns["name"],
owner_pattern=patterns["owner"])
self.updater.start()
self.dot_size = gcfg.get(['dot icon size'])
self.dots = None
self._set_dots()
self.menu_bar = None
self.create_menubar()
accelgroup = gtk.AccelGroup()
self.window.add_accel_group(accelgroup)
key, modifier = gtk.accelerator_parse('<Alt>m')
accelgroup.connect_group(key, modifier, gtk.ACCEL_VISIBLE,
self._toggle_hide_menu_bar)
self.tool_bar = None
self.create_tool_bar()
self.menu_hbox = gtk.HBox()
self.menu_hbox.pack_start(self.menu_bar, expand=True, fill=True)
self.menu_hbox.pack_start(self.tool_bar, expand=True, fill=True)
self.menu_hbox.show_all()
if hide_main_menu_bar:
self.menu_hbox.hide_all()
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add(self.treeview)
scrolled_window.show()
self.vbox.pack_start(self.menu_hbox, expand=False)
self.vbox.pack_start(scrolled_window, expand=True, fill=True)
self.window.add(self.vbox)
self.window.connect("destroy", self._on_destroy_event)
wsize = gsfg.get(['window size'])
self.window.set_default_size(*wsize)
self.treeview.grab_focus()
self.window.show()
self.theme_legend_window = None
self.warning_icon_shown = []
def _connect_accelerators(self, accelerator_list, callback_function):
"""Connects accelerators from a list to a callback."""
for accelerator in accelerator_list:
key, mod = gtk.accelerator_parse(accelerator)
self._accel_group.connect_group(key, mod, 0, callback_function)
def __init__(self, gconf_client, config_root):
gtk.Dialog.__init__(self, self.Title, None,
gtk.DIALOG_DESTROY_WITH_PARENT)
self.gconf_client = gconf_client
self.config_root = config_root
self.set_resizable(False)
mainbox = gtk.VBox()
mainbox.set_border_width(10)
mainbox.set_spacing(10)
close_button = self.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
close_button.grab_default()
close_button.connect('clicked', self.on_close, None)
# Scope configuration
frame = gtk.Frame(self.ScopeFrameText)
frame.set_shadow_type(gtk.SHADOW_NONE)
frame.get_label_widget().set_use_markup(True)
scope_box = gtk.VBox(False, 0)
scope_box.set_border_width(5)
def scope_radio(text, scope, group=None):
btn = gtk.RadioButton(group, text)
btn.set_data(self.ScopeKey, scope)
btn.connect('toggled', self.scope_configuration_change,
gconf_client)
btn.set_active(self._gconf_get_string(self.ScopeKey) == scope)
scope_box.pack_start(btn)
return btn
btn1 = scope_radio(self.ScopeDocText, 'document')
btn2 = scope_radio(self.ScopeWinText, 'window', btn1)
btn3 = scope_radio(self.ScopeAppText, 'application', btn2)
frame.add(scope_box)
mainbox.pack_start(frame)
# Order configuration
frame = gtk.Frame(self.OrderFrameText)
frame.set_shadow_type(gtk.SHADOW_NONE)
frame.get_label_widget().set_use_markup(True)
order_box = gtk.VBox(False, 0)
order_box.set_border_width(5)
def order_radio(text, order, group=None):
btn = gtk.RadioButton(group, text)
btn.set_data(self.OrderKey, order)
btn.connect('toggled', self.order_configuration_change,
gconf_client)
btn.set_active(self._gconf_get_string(self.OrderKey) == order)
order_box.pack_start(btn)
return btn
btn1 = order_radio(self.OrderAlphaText, 'alphabetical')
btn2 = order_radio(self.OrderProximityText, 'proximity', btn1)
btn3 = gtk.CheckButton(self.PromoteLastText)
btn3.connect('toggled', self.promote_configuration_change,
gconf_client)
btn3.set_active(self._gconf_get_bool(self.PromoteKey))
order_box.pack_start(btn3)
frame.add(order_box)
mainbox.pack_start(frame)
# Autocompletion trigger
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_NONE)
hbox = gtk.HBox()
hbox.set_spacing(10)
label = gtk.Label(self.TriggerText)
label.set_use_markup(True)
try:
accel = self._gconf_get_string(self.TriggerKey, 'Escape')
self.trigger = gtk.accelerator_parse(accel)
except:
self.trigger = DEFAULT_TRIGGER
entry = gtk.Entry()
entry.set_text(self.get_trigger_display_text())
entry.connect('key-press-event', self.on_trigger_entry_key_press)
entry.connect('focus-in-event', self.on_trigger_entry_focus_in)
entry.connect('focus-out-event', self.on_trigger_entry_focus_out)
hbox.pack_start(label)
hbox.pack_start(entry)
frame.add(hbox)
mainbox.pack_start(frame)
# Show
self.vbox.pack_start(mainbox)
self.vbox.show_all()
self.show()
def on_provider_removed(self, provider):
key, mod = gtk.accelerator_parse(provider.keys)
self.accelgroup.disconnect_key(key, mod)
def _generate_file_menu(self):
"""
Generate the file menu.
"""
menu_bar = gtk.MenuBar()
menu_acc = gtk.AccelGroup()
self.add_accel_group(menu_acc)
###############################################################
# FILE #
###############################################################
file_menu = gtk.Menu()
file_sub = gtk.MenuItem("_File")
file_sub.set_submenu(file_menu)
exit_item = gtk.ImageMenuItem(gtk.STOCK_QUIT)
key, modifier = gtk.accelerator_parse("<alt>F4")
exit_item.add_accelerator(accel_signal="activate",
accel_group=menu_acc,
accel_key=key,
accel_mods=modifier,
accel_flags=gtk.ACCEL_VISIBLE)
exit_item.connect("activate", gtk.main_quit)
file_menu.append(exit_item)
menu_bar.append(file_sub)
###############################################################
# SETTINGS #
###############################################################
settings_menu = gtk.Menu()
settings_sub = gtk.MenuItem("_Settings")
settings_sub.set_submenu(settings_menu)
settings_item = gtk.MenuItem("Settings")
key, modifier = gtk.accelerator_parse("<alt>p")
settings_item.add_accelerator(accel_signal="activate",
accel_group=menu_acc,
accel_key=key,
accel_mods=modifier,
accel_flags=gtk.ACCEL_VISIBLE)
# settings_item.connect("activate", NotImplementedError)
settings_menu.append(settings_item)
# ----------------------------------------------------------- #
separator = gtk.SeparatorMenuItem()
settings_menu.append(separator)
# ----------------------------------------------------------- #
timer_enable_item = gtk.CheckMenuItem("Timer")
# timer_enable_item.set_active(True)
key, modifier = gtk.accelerator_parse("<alt>t")
timer_enable_item.add_accelerator(accel_signal="activate",
accel_group=menu_acc,
accel_key=key,
accel_mods=modifier,
accel_flags=gtk.ACCEL_VISIBLE)
timer_enable_item.connect("toggled",
self._timer_enabled_checkbutton_toggled)
settings_menu.append(timer_enable_item)
menu_bar.append(settings_sub)
self._content_area.pack_start(child=menu_bar,
fill=False,
expand=False,
padding=0)
vbox = gtk.VBox()
vbox.pack_start(draw, expand=True, fill=True)
vbox.pack_start(hbox, expand=False, fill=False)
window.add(vbox)
font = pango.FontDescription()
font.set_family("sans-serif")
font.set_size(60*pango.SCALE)
layout = draw.create_pango_layout(get_text())
layout.set_font_description(font)
layout.set_alignment(pango.ALIGN_CENTER)
accel = gtk.AccelGroup()
key, mod = gtk.accelerator_parse("<Ctrl>Q")
accel.connect_group(key, mod, 0, gtk.main_quit)
key, mod = gtk.accelerator_parse("Escape")
#accel.connect_group(key, mod, 0, gtk.main_quit)
#key, mod = gtk.accelerator_parse("<Ctrl>C")
accel.connect_group(key, mod, 0, (lambda x,y,z,v: tb.set_text("")))
window.add_accel_group(accel)
window.connect("destroy", gtk.main_quit)
window.show_all()
need_resize=True
need_quick=True
def resize(w=None,rect=None):
