def _create_accelerators(self, primary=True): """Create accelerators from specified list""" accelerator_list = (self._secondary, self._primary)[primary] # connect all methods in list for method_name in self._methods.keys(): if method_name in self._disabled: continue # skip if method is disabled # try to get saved key combination from manager accelerator = self._manager.get_accelerator(self._name, method_name, primary) # if we don't have saved key combination, use default if accelerator is None and method_name in accelerator_list: accelerator = accelerator_list[method_name] # finally connect accelerator to specified method if accelerator is not None and accelerator[0] > 0: keyval = accelerator[0] modifier = accelerator[1] # create method name cache based on key combination label = Gtk.accelerator_get_label(keyval, modifier) self._method_names[label] = method_name # connect accelerator self._accel_group.connect(keyval, modifier, 0, self._handle_activate)
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 testAllMenuItemsAreDocumented(self):
def menuitems(parent, level=0):
for mi in parent.get_children():
if isinstance(mi, ImageMenuItem):
yield mi, level
sm = mi.get_submenu()
if sm:
for mi_sm in menuitems(sm, level + 1):
yield mi_sm
for menuitem, level in menuitems(self.mainwindow.menubar):
label = menuitem.get_label().replace('_', '').rstrip('.')
accel_path = menuitem.get_accel_path()
accel_label = Gtk.accelerator_get_label(
Gtk.AccelMap().lookup_entry(accel_path).key.accel_key,
Gtk.AccelMap().lookup_entry(accel_path).key.accel_mods)
if accel_label:
if '++' in accel_label:
label += ' <' + accel_label.replace('++', '><+') + '>'
else:
label += ' <' + accel_label.replace('+', '><') + '>'
if level:
label = '**' + label + '**'
else:
label = '===== ' + label + ' ====='
self.assertTrue(label in self.manual,
'Menu item "{}" not documented'.format(label))
def update_accelerator_label(self):
if self.current_node.shortcut:
key, mods = Gtk.accelerator_parse(self.current_node.shortcut)
label = Gtk.accelerator_get_label(key, mods)
self['accelerator'].set_text(label)
else:
self['accelerator'].set_text('')
def _init_from_accel_map(self):
"""Initializes from the app UIManager and the global AccelMap"""
if self.ui_manager is None:
import application
app = application.get_app()
self.ui_manager = app.ui_manager
assert self.ui_manager is not None
self._action_labels.clear()
self._store.clear()
accel_labels = {}
for path, key, mods, changed in self._get_accel_map_entries():
accel_labels[path] = Gtk.accelerator_get_label(key, mods)
for group in self.ui_manager.get_action_groups():
group_name = group.get_name()
for action in group.list_actions():
action_name = action.get_name()
path = "<Actions>/%s/%s" % (group_name, action_name)
action_label = action.get_label()
if not action_label:
continue
self._action_labels[path] = action_label
accel_label = accel_labels.get(path)
row = [None for t in self._COLUMN_TYPES]
row[self._PATH_COLUMN] = path
row[self._ACTION_LABEL_COLUMN] = action_label
row[self._ACCEL_LABEL_COLUMN] = accel_label
self._store.append(row)
def on_key_press(self, _, event):
# remove GDK_MOD2_MASK, because it seems unnecessary
mask = event.state
if mask & Gdk.ModifierType.MOD2_MASK:
mask ^= Gdk.ModifierType.MOD2_MASK
if mask & Gdk.ModifierType.MOD4_MASK:
mask ^= Gdk.ModifierType.MOD4_MASK
accel_name = Gtk.accelerator_name(event.keyval, mask)
display_name = Gtk.accelerator_get_label(event.keyval, mask)
if accel_name == 'Return':
# emit hotkey-set signal
self.emit('hotkey-set', self._accel_name, self._display_name)
self.hide()
if accel_name == 'Escape':
self.hide()
return
# do nothing for invalid hotkeys
if not self.is_valid_hotkey(display_name, accel_name):
logger.debug("Invalid hotkey '%s', ('%s') is not allowed",
display_name, accel_name)
return
self._accel_name = accel_name
self._display_name = display_name
self._hotkey_input.set_text(display_name)
def update_accelerator_label(self):
if self.current_node.shortcut:
key, mods = Gtk.accelerator_parse(self.current_node.shortcut)
label = Gtk.accelerator_get_label(key, mods)
self['accelerator'].set_text(label)
else:
self['accelerator'].set_text('')
def on_key_edited(self, renderer, path, keycode, mask, keyval, model):
"""Callback that handles key edition in cellrenderer. It makes
some tests to validate the key, like looking for already in
use keys and look for [A-Z][a-z][0-9] to avoid problems with
these common keys. If all tests are ok, the value will be
stored in gconf.
"""
giter = model.get_iter(path)
gconf_path = model.get_value(giter, 0)
oldkey = model.get_value(giter, 2)
hotkey = KeyEntry(keycode, mask)
key = Gtk.accelerator_name(keycode, mask)
keylabel = Gtk.accelerator_get_label(keycode, mask)
# we needn't to change anything, the user is trying to set the
# same key that is already set.
if oldkey == hotkey:
return False
# looking for already used keybindings
def each_key(model, path, subiter):
keyentry = model.get_value(subiter, 2)
if keyentry and keyentry == hotkey:
msg = _("The shortcut \"%s\" is already in use.") % keylabel
ShowableError(self.window, _('Error setting keybinding.'), msg,
-1)
raise Exception(
'This is ok, we just use it to break the foreach loop!')
model.foreach(each_key)
# avoiding problems with common keys
if ((mask == 0 and keycode != 0)
and ((keycode >= ord('a') and keycode <= ord('z')) or
(keycode >= ord('A') and keycode <= ord('Z')) or
(keycode >= ord('0') and keycode <= ord('9')))):
dialog = Gtk.MessageDialog(
self.get_widget('config-window'),
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
Gtk.MessageType.WARNING, Gtk.ButtonsType.OK,
_("The shortcut \"%s\" cannot be used "
"because it will become impossible to "
"type using this key.\n\n"
"Please try with a key such as "
"Control, Alt or Shift at the same "
"time.\n") % key)
dialog.run()
dialog.destroy()
return False
# setting new value in ui
giter = model.get_iter(path)
model.set_value(giter, 2, hotkey)
# setting the new value in gconf
if gconf_path == "show-hide":
self.settings.keybindingsGlobal.set_string(gconf_path, key)
else:
self.settings.keybindingsLocal.set_string(gconf_path, key)
def get_cell_data_cb(self, column, cell, model, piter, user_data=None):
tool = model.get_value(piter, self.TOOL_COLUMN)
if tool == None or not isinstance(tool, Tool):
if tool == None:
label = _('All Languages')
elif not isinstance(tool, GtkSource.Language):
label = _('Plain Text')
else:
label = tool.get_name()
markup = saxutils.escape(label)
editable = False
else:
escaped = saxutils.escape(tool.name)
if tool.shortcut:
key, mods = Gtk.accelerator_parse(tool.shortcut)
label = Gtk.accelerator_get_label(key, mods)
markup = '%s (<b>%s</b>)' % (escaped, label)
else:
markup = escaped
editable = True
cell.set_properties(markup=markup, editable=editable)
def on_key_press(self, target, event):
mod = Gtk.accelerator_get_label(event.keyval, event.state)
#name = Gdk.keyval_name(event.keyval)
if mod == "Strg+S":
self.save()
elif mod == "Umschalt+Strg+S":
self.save_as()
def reload_global(self, settings, key, user_data):
value = settings.get_string(key)
if value == 'disabled':
return
try:
self.guake.hotkeys.unbind(self.globalhotkeys[key])
except Exception as e:
pass
self.globalhotkeys[key] = value
if key == "show-hide":
log.debug("reload_global: %r", value)
if not self.guake.hotkeys.bind(value, self.guake.show_hide):
keyval, mask = Gtk.accelerator_parse(value)
label = Gtk.accelerator_get_label(keyval, mask)
filename = pixmapfile('guake-notification.png')
notifier.showMessage(
_('Guake Terminal'),
_(
'A problem happened when binding <b>%s</b> key.\n'
'Please use Guake Preferences dialog to choose another '
'key'
) % label, filename
)
elif key == "show-focus":
if not self.guake.hotkeys.bind(value, self.guake.show_focus):
log.warn("can't bind show-focus key")
return
def refresh_accel(self):
""" Refreshes the accelerator """
if not shortcut.is_gsettings_present():
self.button.set_sensitive(False)
iter1 = self.liststore.get_iter_first()
self.liststore.set_value(iter1, 1, "Disabled")
self.cell.set_sensitive(False)
if not self.gsettings_install_label_shown:
self._show_gsettings_install_label()
self.gsettings_install_label_shown = True
return
iter1 = self.liststore.get_iter_first()
self.new_task_binding = shortcut.get_saved_binding()
self.binding_backup = self.new_task_binding
if self.new_task_binding == "":
# User had set a shortcut, but has now disabled it
self.button.set_active(False)
self.liststore.set_value(iter1, 1, "Disabled")
return
elif self.new_task_binding is None:
# User hasn't set a shortcut ever
self.button.set_active(False)
self.new_task_binding = self.new_task_default_binding
self.binding_backup = self.new_task_binding
else:
# There exists a shortcut
self.button.set_active(True)
(accel_key, accel_mods) = Gtk.accelerator_parse(self.new_task_binding)
self.show_input = Gtk.accelerator_get_label(accel_key, accel_mods)
self.liststore.set_value(iter1, 1, self.show_input)
def button_press_displayname(button, mods, shorten=False):
"""Converts a button number & modifier mask to a localized unicode string.
"""
button = int(button)
mods = int(mods)
if button <= 0:
return None
mods = Gdk.ModifierType(mods)
modif_label = Gtk.accelerator_get_label(0, mods)
modif_label = unicode(modif_label)
separator = ""
if modif_label:
separator = u"+"
# TRANSLATORS: "Button" refers to a mouse button
# TRANSLATORS: It is part of a button map label.
mouse_button_label = _("Button")
if shorten:
# TRANSLATORS: abbreviated "Button <number>" for forms like "Alt+Btn1"
mouse_button_label = _("Btn")
return "{modifiers}{plus}{btn}{button_number}".format(
modifiers=modif_label,
plus=separator,
btn=mouse_button_label,
button_number=button,
)
def do_key_press_event(self, event):
"""Handles key press events and detects valid accelerators."""
keyval = event.keyval
mask = event.state
if keyval == Gdk.KEY_Escape:
self.destroy()
return
self.accelerator = Gtk.accelerator_name(keyval, mask)
accelerator = Gtk.accelerator_get_label(keyval, mask)
self.accelerator_label.set_markup(
"<span size='20000'><b>%s</b></span>" % accelerator)
valid = Gtk.accelerator_valid(keyval, mask)
self.conflicting_action = self.app.shortcuts.get_conflicting_action(
self.customised_item.action_name, keyval, mask)
if valid and self.conflicting_action:
title = self.app.shortcuts.titles[self.conflicting_action]
self.conflict_label.set_markup(
_("This key combination is already used by <b>%s</b>."
" Press Replace to use it for <b>%s</b> instead.") %
(title, self.customised_item.title))
# Set visibility according to the booleans set above.
self.apply_button.set_visible(valid
and not bool(self.conflicting_action))
self.accelerator_label.set_visible(valid)
self.conflict_label.set_visible(valid
and bool(self.conflicting_action))
self.replace_button.set_visible(valid
and bool(self.conflicting_action))
self.invalid_label.set_visible(not valid)
def reload_global(self, settings, key, user_data):
value = settings.get_string(key)
if value == 'disabled':
return
try:
self.guake.hotkeys.unbind(self.globalhotkeys[key])
except Exception as e:
pass
self.globalhotkeys[key] = value
if key == "show-hide":
log.debug("reload_global: %r", value)
if not self.guake.hotkeys.bind(value, self.guake.show_hide):
keyval, mask = Gtk.accelerator_parse(value)
label = Gtk.accelerator_get_label(keyval, mask)
filename = pixmapfile('guake-notification.png')
notifier.showMessage(
_('Guake Terminal'),
_('A problem happened when binding <b>%s</b> key.\n'
'Please use Guake Preferences dialog to choose another '
'key') % label, filename)
elif key == "show-focus":
if not self.guake.hotkeys.bind(value, self.guake.show_focus):
log.warn("can't bind show-focus key")
return
def _action_tooltip(self, action, tooltip):
action_id = action.get_id()
accels = self.get_application().get_accels_for_action(action_id)
if accels:
key, mods = Gtk.accelerator_parse(accels[0])
tooltip += ' ({})'.format(Gtk.accelerator_get_label(key, mods))
return tooltip
def get_all(self, _):
logger.info('API call /get/all')
settings = self.settings.get_all()
themes = [
dict(value=th.get_name(), text=th.get_display_name())
for th in load_available_themes().values()
]
hotkey_accelerator = settings.get('hotkey_show_app')
hotkey_caption = "Ctrl+Space"
try:
hotkey_caption = Gtk.accelerator_get_label(
*Gtk.accelerator_parse(hotkey_accelerator))
# pylint: disable=broad-except
except Exception:
logger.warning('Unable to parse accelerator "%s". Use Ctrl+Space',
hotkey_accelerator)
settings.update({
'autostart_allowed': self.autostart_pref.is_allowed(),
'autostart_enabled': self.autostart_pref.is_enabled(),
'available_themes': themes,
'hotkey_show_app': hotkey_caption,
'env': {
'version': VERSION,
'api_version': API_VERSION,
'user_home': os.path.expanduser('~'),
'is_x11': IS_X11,
}
})
return settings
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) or ""
label = Gtk.accelerator_get_label(*Gtk.accelerator_parse(accel))
self.keybind_store.append((names[binding], label, binding))
def _show_gkeybindings(self, setctl):
names = accelerators.ACCELERATOR_NAMES
self.gkeybind_store.clear()
for binding in sorted(names, key=lambda k: names[k]):
accel = setctl.get_accelerator(binding) or ""
label = Gtk.accelerator_get_label(*Gtk.accelerator_parse(accel))
self.gkeybind_store.append((names[binding], label, binding))
def send_prv_msg(self, widget, event):
keyval = event.keyval
name = Gdk.keyval_name(keyval)
mod = Gtk.accelerator_get_label(keyval, event.state)
if mod == "Ctrl+Mod2+Return":
pass
elif event.keyval == 65293:
widget.emit_stop_by_name("key-press-event")
text_buffer = widget.get_buffer()
start_sel = text_buffer.get_start_iter()
end_sel = text_buffer.get_end_iter()
msg = text_buffer.get_text(start_sel, end_sel, False)
if not msg:
return
msg_lines = msg.split("\n")
if len(msg_lines) > 5:
self.pastebin_barnamy(msg, text_buffer)
else:
chat_buffer = self.barnamy_widget_prv_chat[self.selected_prv_chat]["chat_view"].get_buffer()
data = {"type":"private", "from_" : self.nick, "to_" : self.selected_prv_chat, "token_id" : self.token_id, "msg" : msg}
self.BarnamyBase.barnamy_actions['send_prv_msg'](data)
if self.EmoticonsFilter(msg):
msg = self.EmoticonsFilter(msg)
self.smart_barnamy_msg(chat_buffer, msg, True)
text_buffer.set_text("")
return True
return False
def do_key_press_event(self, event):
"""Handles key press events and detects valid accelerators."""
keyval = event.keyval
mask = event.state
if keyval == Gdk.KEY_Escape:
self.destroy()
return
self.accelerator = Gtk.accelerator_name(keyval, mask)
accelerator = Gtk.accelerator_get_label(keyval, mask)
self.accelerator_label.set_markup("<span size='20000'><b>%s</b></span>"
% accelerator)
valid = Gtk.accelerator_valid(keyval, mask)
self.conflicting_action = self.app.shortcuts.get_conflicting_action(
self.customised_item.action_name, keyval, mask)
if valid and self.conflicting_action:
title = self.app.shortcuts.titles[self.conflicting_action]
self.conflict_label.set_markup(
_("This key combination is already used by <b>%s</b>."
" Press Replace to use it for <b>%s</b> instead.")
% (title, self.customised_item.title))
# Set visibility according to the booleans set above.
self.apply_button.set_visible(valid and not bool(self.conflicting_action))
self.accelerator_label.set_visible(valid)
self.conflict_label.set_visible(valid and bool(self.conflicting_action))
self.replace_button.set_visible(valid and bool(self.conflicting_action))
self.invalid_label.set_visible(not valid)
def refresh_accel(self):
""" Refreshes the accelerator """
if not shortcut.is_gsettings_present():
self.button.set_sensitive(False)
iter1 = self.liststore.get_iter_first()
self.liststore.set_value(iter1, 1, "Disabled")
self.cell.set_sensitive(False)
if not self.gsettings_install_label_shown:
self._show_gsettings_install_label()
self.gsettings_install_label_shown = True
return
iter1 = self.liststore.get_iter_first()
self.new_task_binding = shortcut.get_saved_binding()
self.binding_backup = self.new_task_binding
if self.new_task_binding == "":
# User had set a shortcut, but has now disabled it
self.button.set_active(False)
self.liststore.set_value(iter1, 1, "Disabled")
return
elif self.new_task_binding is None:
# User hasn't set a shortcut ever
self.button.set_active(False)
self.new_task_binding = self.new_task_default_binding
self.binding_backup = self.new_task_binding
else:
# There exists a shortcut
self.button.set_active(True)
(accel_key, accel_mods) = Gtk.accelerator_parse(self.new_task_binding)
self.show_input = Gtk.accelerator_get_label(accel_key, accel_mods)
self.liststore.set_value(iter1, 1, self.show_input)
def on_key_press(self,target,event):
mod = Gtk.accelerator_get_label(event.keyval,event.state)
#name = Gdk.keyval_name(event.keyval)
if mod=="Strg+S":
self.save()
elif mod=="Umschalt+Strg+S":
self.save_as()
def on_button_clicked2(self, event, column, treesortable):
keyval = event.keyval
name = Gdk.keyval_name(keyval)
mod = Gtk.accelerator_get_label(keyval, event.state)
if mod == "Mod2+Enter" or mod == "Mod2+Return":
nome = self.nometxt.get_text()
connb = sqlite3.connect(path + 'turbo.db')
a = connb.cursor()
a.execute("SELECT nome FROM contacts WHERE upper(nome) = upper('" +
nome + "')")
contactsName = a.fetchone()
connb.close()
if not contactsName:
try:
IP = socket.gethostbyname(nome)
addcontacts(nome, IP)
self.listmodel.append([pixbuf1, nome.upper(), IP])
treesortable.set_sort_column_id(2, Gtk.SortType.ASCENDING)
except socket.gaierror, err:
msgerror = "I can't ping this host name!\\nPlease chech the host name and try again!"
command = "notify-send --hint=int:transient:1 \"TurboNote Gnome3\" \"" + (
msgerror).decode('iso-8859-1').encode(
'utf8') + "\" -i " + path_icon + "turbo.png"
os.system(command)
else:
msgerror = "This contact already exists!\\nPlease chech the host name and try again!"
command = "notify-send --hint=int:transient:1 \"TurboNote Gnome3\" \"" + (
msgerror).decode('iso-8859-1').encode(
'utf8') + "\" -i " + path_icon + "turbo.png"
os.system(command)
def on_button_clicked2(self, event,column,treesortable):
keyval = event.keyval
name = Gdk.keyval_name(keyval)
mod = Gtk.accelerator_get_label(keyval,event.state)
print mod
if mod == "Mod2+Enter" or mod == "Mod2+Return":
nome = self.nometxt.get_text()
connb = sqlite3.connect(path + 'turbo.db')
a = connb.cursor()
a.execute("SELECT nome FROM contacts WHERE upper(nome) = upper('" + nome + "')")
contactsName = a.fetchone()
connb.close()
if not contactsName:
try:
IP = socket.gethostbyname(nome)
addcontacts(nome,IP)
self.listmodel.append([nome.upper(),IP])
treesortable.set_sort_column_id(1, Gtk.SortType.ASCENDING)
except socket.gaierror, err:
msgerror = "I can't ping this host name!\\nPlease chech the host name and try again!";
command = "notify-send --hint=int:transient:1 \"TurboNote Gnome3\" \"" + (msgerror).decode('iso-8859-1').encode('utf8') + "\" -i " + path_icon + "turbo.png"
os.system(command)
else:
msgerror = "This contact already exists!\\nPlease chech the host name and try again!";
command = "notify-send --hint=int:transient:1 \"TurboNote Gnome3\" \"" + (msgerror).decode('iso-8859-1').encode('utf8') + "\" -i " + path_icon + "turbo.png"
os.system(command)
def _init_from_accel_map(self):
"""Initializes from the app UIManager and the global AccelMap"""
if self.ui_manager is None:
import application
app = application.get_app()
self.ui_manager = app.ui_manager
assert self.ui_manager is not None
self._action_labels.clear()
self._store.clear()
accel_labels = {}
for path, key, mods, changed in self._get_accel_map_entries():
accel_labels[path] = Gtk.accelerator_get_label(key, mods)
for group in self.ui_manager.get_action_groups():
group_name = group.get_name()
for action in group.list_actions():
action_name = action.get_name()
path = "<Actions>/%s/%s" % (group_name, action_name)
action_label = action.get_label()
if not action_label:
continue
self._action_labels[path] = action_label
accel_label = accel_labels.get(path)
row = [None for t in self._COLUMN_TYPES]
row[self._PATH_COLUMN] = path
row[self._ACTION_LABEL_COLUMN] = action_label
row[self._ACCEL_LABEL_COLUMN] = accel_label
self._store.append(row)
def get_app_hotkey(self):
app_hotkey_current_accel_name = self.settings.get_property('hotkey-show-app')
try:
(key, mode) = Gtk.accelerator_parse(app_hotkey_current_accel_name)
except Exception:
logger.warning('Unable to parse accelerator "%s". Use Ctrl+Space' % app_hotkey_current_accel_name)
(key, mode) = Gtk.accelerator_parse("<Primary>space")
return Gtk.accelerator_get_label(key, mode)
def on_key_event(self, widget, event):
shortcut = Gtk.accelerator_get_label(event.keyval, event.state)
if shortcut in ("Ctrl+F", "Ctrl+Mod2+F"):
if self.searchbar.get_search_mode():
self.searchbar.set_search_mode(False)
else:
self.searchbar.set_search_mode(True)
def on_key_event(self, widget, event):
shortcut = Gtk.accelerator_get_label(event.keyval, event.state)
if shortcut in ("Ctrl+F", "Ctrl+Mod2+F"):
if self.searchbar.get_search_mode():
self.searchbar.set_search_mode(False)
else:
self.searchbar.set_search_mode(True)
def accelerator_display(self):
accel = self['accelerator']
if accel:
keyval, mod = Gtk.accelerator_parse(accel)
accel = Gtk.accelerator_get_label(keyval, mod)
return accel or ''
def on_key_event(self, widget, event):
mod = Gtk.accelerator_get_label(event.keyval, event.state)
if mod == "Ctrl+F" or mod == "Ctrl+Mod2+F":
if self.searchbar.get_search_mode():
self.searchbar.set_search_mode(False)
else:
self.searchbar.set_search_mode(True)
def notify_hotkey_change(self, accel_name):
(key, mode) = Gtk.accelerator_parse(accel_name)
display_name = Gtk.accelerator_get_label(key, mode)
app_cache_db = AppCacheDb.get_instance()
if not app_cache_db.find('startup_hotkey_notification'):
app_cache_db.put('startup_hotkey_notification', True)
app_cache_db.commit()
show_notification("Ulauncher", "Hotkey is set to %s" % display_name)
def notify_hotkey_change(self, accel_name):
(key, mode) = Gtk.accelerator_parse(accel_name)
display_name = Gtk.accelerator_get_label(key, mode)
app_cache_db = AppCacheDb.get_instance()
if not app_cache_db.find('startup_hotkey_notification'):
show_notification("Ulauncher", "Hotkey is set to %s" % display_name)
app_cache_db.put('startup_hotkey_notification', True)
app_cache_db.commit()
def get_app_hotkey(self):
app_hotkey_current_accel_name = self.settings.get_property('hotkey-show-app')
try:
(key, mode) = Gtk.accelerator_parse(app_hotkey_current_accel_name)
except Exception:
logger.warning('Unable to parse accelerator "%s". Use Ctrl+Space' % app_hotkey_current_accel_name)
(key, mode) = Gtk.accelerator_parse("<Primary>space")
return Gtk.accelerator_get_label(key, mode)
def on_key_press(self,target,event):
mod = Gtk.accelerator_get_label(event.keyval, event.state)
if mod=="F11":
if self.fullscreen_bool:
self.unfullscreen()
else:
self.fullscreen()
self.fullscreen_bool = not self.fullscreen_bool
def accelerator_display(self):
accel = self['accelerator']
if accel:
keyval, mod = Gtk.accelerator_parse(accel)
accel = Gtk.accelerator_get_label(keyval, mod)
return accel or ''
def get_accel(self):
"""Returns the corresponding accelerator in a viewable format."""
try:
accels = self.app.get_accels_for_action(self.action_name)[0]
except IndexError:
accels = ""
keyval, mods = Gtk.accelerator_parse(accels)
return Gtk.accelerator_get_label(keyval, mods)
def dump(self, window):
keyval, mods = Gtk.accelerator_parse(catapult.conf.toggle_key)
label = Gtk.accelerator_get_label(keyval, mods)
self.widget.catapult_key = catapult.conf.toggle_key
self.widget.set_text(label)
self.widget.set_position(-1)
if window is not None:
# Avoid the main window popping up.
window.unbind_toggle_key()
def get_accel(self):
"""Returns the corresponding accelerator in a viewable format."""
try:
accels = self.app.get_accels_for_action(self.action_name)[0]
except IndexError:
accels = ""
keyval, mods = Gtk.accelerator_parse(accels)
return Gtk.accelerator_get_label(keyval, mods)
def try_bind_key(keystr):
label = Gtk.accelerator_get_label(*Gtk.accelerator_parse(keystr))
ulabel = kupferstring.tounicode(label)
if len(ulabel) == 1 and ulabel.isalnum():
return False
target = keybindings.KEYRANGE_TRIGGERS[-1] - 1
succ = keybindings.bind_key(keystr, target)
if succ:
keybindings.bind_key(None, target)
return succ
def find_event(widget, event=None):
keyval = event.keyval
name = Gdk.keyval_name(keyval)
mod = Gtk.accelerator_get_label(keyval, event.state)
if mod == "Ctrl+F" or mod == "Ctrl+Mod2+F":
if searchbar.get_search_mode():
searchbar.set_search_mode(False)
else:
searchbar.set_search_mode(True)
def do_update_accel_store(self, iter):
while iter != None:
if self.accel_store.iter_has_child(iter):
self.do_update_accel_store(self.accel_store.iter_children(iter))
else:
known, key = Gtk.AccelMap.lookup_entry(
self.convert_tree_iter_to_accel_path(iter))
if known:
self.accel_store[iter][1] = Gtk.accelerator_get_label(
key.accel_key, key.accel_mods)
iter = self.accel_store.iter_next(iter)
def _update_from_accel_map(self):
"""Updates the list from the global AccelMap, logging changes"""
accel_labels = {}
for path, key, mods, changed in self._get_accel_map_entries():
accel_labels[path] = Gtk.accelerator_get_label(key, mods)
for row in self._store:
path = row[self._PATH_COLUMN]
new_label = accel_labels.get(path)
old_label = row[self._ACCEL_LABEL_COLUMN]
if new_label != old_label:
logger.debug("update: %r now uses %r", path, new_label)
row[self._ACCEL_LABEL_COLUMN] = new_label
def _update_from_accel_map(self):
"""Updates the list from the global AccelMap, logging changes"""
accel_labels = {}
for path, key, mods, changed in self._get_accel_map_entries():
accel_labels[path] = Gtk.accelerator_get_label(key, mods)
for row in self._store:
path = row[self._PATH_COLUMN]
new_label = accel_labels.get(path)
old_label = row[self._ACCEL_LABEL_COLUMN]
if new_label != old_label:
logger.debug("update: %r now uses %r", path, new_label)
row[self._ACCEL_LABEL_COLUMN] = new_label
def trigger_accelerator(self, keyval, modifier): """Manually trigger accelerator""" result = False modifier = modifier & Gtk.accelerator_get_default_mod_mask() # filter out unneeded mods label = Gtk.accelerator_get_label(keyval, modifier) # trigger accelerator only if we have method connected if label in self._method_names: result = self._handle_activate(self._accel_group, self._window, keyval, modifier) return result
def add_accel(data, accel_path, key, mods, changed):
label = Gtk.accelerator_get_label(key, mods)
split_path = accel_path.split("/")
parent = None
for i in range(len(split_path) - 1):
subpath = "/".join(split_path[:i + 1])
iter = iters.get(subpath)
if iter == None:
iter = self.accel_store.append(
parent, [split_path[i], "", False])
iters[subpath] = iter
parent = iter
self.accel_store.append(parent, [split_path[-1], label, True])
def _cellAccelEdit(self, cell, path, accel_key, accel_mods, code, model):
""" Accelerator is modified """
self.show_input = Gtk.accelerator_get_label(accel_key, accel_mods)
self.new_task_binding = Gtk.accelerator_name(accel_key, accel_mods)
if shortcut.check_invalidity(self.new_task_binding, accel_key,
accel_mods):
self._show_warning(self.show_input)
return
self.binding_backup = self.new_task_binding
iter = model.get_iter(path)
model.set_value(iter, 1, self.show_input)
shortcut.save_new_binding(self.new_task_binding,
self.button.get_active())
def on_reset_shortcuts_clicked(self, button):
for i in self.store:
for j in i.iterchildren():
default = self.shortcuts.get_default_value(j[2])
accel_name = default.get_string()
if j[4] == "app.show":
self.set_app_show(accel_name)
else:
self.set_accel(accel_name, j[4])
accel_key, accel_mods = Gtk.accelerator_parse(accel_name)
accel_label = Gtk.accelerator_get_label(accel_key, accel_mods)
j[1] = accel_label
self.shortcuts.set_value(j[2], default)
def _cellAccelEdit(self, cell, path, accel_key, accel_mods, code, model):
""" Accelerator is modified """
self.show_input = Gtk.accelerator_get_label(accel_key, accel_mods)
self.new_task_binding = Gtk.accelerator_name(accel_key, accel_mods)
if shortcut.check_invalidity(self.new_task_binding, accel_key,
accel_mods):
self._show_warning(self.show_input)
return
self.binding_backup = self.new_task_binding
iter = model.get_iter(path)
model.set_value(iter, 1, self.show_input)
shortcut.save_new_binding(self.new_task_binding,
self.button.get_active())
def on_accel_edited(self, cell_renderer_accel, path_string, accel_key, accel_mods, hardware_keycode):
cell_iter = self.store.get_iter_from_string(path_string)
accel_name = Gtk.accelerator_name(accel_key, accel_mods)
label = Gtk.accelerator_get_label(accel_key, accel_mods)
for row in self.store:
if label in [child[1] for child in row.iterchildren()]:
self.dialog_repeated_shortcut(label)
return
self.store[cell_iter][1] = label
if self.store[cell_iter][4] == "app.show":
self.set_app_show(accel_name)
else:
self.set_accel(accel_name, self.store[cell_iter][4])
value = self.store[cell_iter][2]
self.shortcuts.set_value(value, GLib.Variant("s", accel_name))
def populate_keys_tree(self):
"""Reads the HOTKEYS global variable and insert all data in
the TreeStore used by the preferences window treeview.
"""
for group in HOTKEYS:
parent = self.store.append(None, [None, group['label'], None, None])
for item in group['keys']:
if item['key'] == "show-hide" or item['key'] == "show-focus":
accel = self.settings.keybindingsGlobal.get_string(item['key'])
else:
accel = self.settings.keybindingsLocal.get_string(item['key'])
gsettings_path = item['key']
keycode, mask = Gtk.accelerator_parse(accel)
keylabel = Gtk.accelerator_get_label(keycode, mask)
self.store.append(parent, [gsettings_path, item['label'], keylabel, accel])
self.get_widget('treeview-keys').expand_all()
def _set_accelmap_entry(cls, path, keyval, mods):
cls._delete_clashing_accelmap_entries(keyval, mods, path)
accel_label = Gtk.accelerator_get_label(keyval, mods)
accel_name = Gtk.accelerator_name(keyval, mods)
entry_exists, junk = Gtk.AccelMap.lookup_entry(path)
if entry_exists:
logger.info("Changing entry %r: %r", accel_name, path)
if Gtk.AccelMap.change_entry(path, keyval, mods, True):
logger.debug("Updated %r successfully", path)
else:
logger.error("Failed to update %r", path)
else:
logger.info("Adding new entry %r: %r", accel_name, path)
Gtk.AccelMap.add_entry(path, keyval, mods)
entry_exists, junk = Gtk.AccelMap.lookup_entry(path)
assert entry_exists
def on_reset_shortcuts_clicked(self, button):
'''
This method will reset all preferences on the shortcuts page.
'''
for i in self.store:
for j in i.iterchildren():
default = self.shortcuts.get_default_value(j[2])
accel_name = default.get_string()
if j[4] == 'app.show':
self.set_app_show(accel_name)
else:
self.set_accel(accel_name, j[4])
accel_key, accel_mods = Gtk.accelerator_parse(accel_name)
accel_label = Gtk.accelerator_get_label(accel_key, accel_mods)
j[1] = accel_label
self.shortcuts.set_value(j[2], default)
def on_button_clicked2(self, event):
keyval = event.keyval
name = Gdk.keyval_name(keyval)
mod = Gtk.accelerator_get_label(keyval,event.state)
if mod == "Ctrl+Mod2+Return" or mod == "Ctrl+Mod2+Enter":
buf = self.textview.get_buffer()
text = buf.get_text(buf.get_start_iter(),buf.get_end_iter(),True)
#fix windows
text.replace("\\","\\\\");
try:
send_turbo(text.decode('utf-8').encode('windows-1252'),self.titulotxt.get_text(),attFile,self.get_size()[0],self.get_size()[1])
except Exception, e:
msgerror = "Unable to send to " + name.upper() + "\\nInvalid Characters!"
command = "notify-send --hint=int:transient:1 \"TurboNote Gnome3\" \"" + (msgerror).decode('iso-8859-1').encode('utf8') + "\" -i " + path_icon + "turbo.png"
os.system(command)
def on_button_clicked2(self, event,nome):
keyval = event.keyval
name = Gdk.keyval_name(keyval)
mod = Gtk.accelerator_get_label(keyval,event.state)
if mod == "Ctrl+Mod2+Return" or mod == "Ctrl+Mod2+Enter":
buf = self.textview.get_buffer()
text = buf.get_text(buf.get_start_iter(),buf.get_end_iter(),True)
win = MyWindow(text.decode('utf-8').encode('windows-1252'),stay,attFile,str(self.get_size()[0]),str(self.get_size()[1]))
win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()
if mod == "Ctrl+Mod2+R":
buf = self.textview.get_buffer()
text = buf.get_text(buf.get_start_iter(),buf.get_end_iter(),True)
s = threading.Thread(target=send_turbo ,args=(text,ip,nome,str(self.get_size()[0]),str(self.get_size()[1])))
s.start()
Gtk.main_quit()
def __init__(self, toolbar, win, uibuilder):
self.log = logging.getLogger('MiscToolbarController')
# Accelerators
accelerators = Gtk.AccelGroup()
win.add_accel_group(accelerators)
closebtn = uibuilder.find_widget_recursive(toolbar, 'close')
closebtn.set_visible(Config.getboolean('misc', 'close'))
closebtn.connect('clicked', self.on_closebtn_clicked)
cutbtn = uibuilder.find_widget_recursive(toolbar, 'cut')
cutbtn.set_visible(Config.getboolean('misc', 'cut'))
cutbtn.connect('clicked', self.on_cutbtn_clicked)
key, mod = Gtk.accelerator_parse('t')
cutbtn.add_accelerator('clicked', accelerators,
key, mod, Gtk.AccelFlags.VISIBLE)
tooltip = Gtk.accelerator_get_label(key, mod)
cutbtn.set_tooltip_text(tooltip)
