def getKeyName(keyval):
'''Get key name.'''
keyUnicode = gdk.keyval_to_unicode(keyval)
if keyUnicode == 0:
return gdk.keyval_name(keyval)
else:
return str(unichr(keyUnicode))
def on_key_press(self, widget, event):
"""
The keypress handler, which dispatches keypresses to the
functions mapped to in self.keyactions"""
keyval = gdk.keyval_name(event.keyval)
if keyval is None:
return
# Order is important, we want control_shift_alt_XXX
method_name = 'key_'
if event.state & gdk.CONTROL_MASK:
method_name += 'control_'
if event.state & gdk.SHIFT_MASK:
method_name += 'shift_'
if event.state & gdk.MOD1_MASK:
method_name += 'alt_'
method_name += keyval
func = getattr(self, method_name, None)
if not func and event.keyval in self._keyactions:
func = self._keyactions[event.keyval]
if func:
return func()
def on_key_press(self, widget, event):
"""
The keypress handler, which dispatches keypresses to the
functions mapped to in self.keyactions"""
keyval = gdk.keyval_name(event.keyval)
if keyval is None:
return
# Order is important, we want control_shift_alt_XXX
method_name = 'key_'
if event.state & gdk.CONTROL_MASK:
method_name += 'control_'
if event.state & gdk.SHIFT_MASK:
method_name += 'shift_'
if event.state & gdk.MOD1_MASK:
method_name += 'alt_'
method_name += keyval
func = getattr(self, method_name, None)
if not func and event.keyval in self._keyactions:
func = self._keyactions[event.keyval]
if func:
return func()
def bntextview_keypress(self, obj, event, data=None):
if self.lang == "en":
return False
key = keyval_name(event.keyval)
if key in editkeys:
self.flushBnText()
return False
elif key == "BackSpace":
strBn = bntranslit.fin + bntranslit.unfin
if len(strBn) > 0:
strBn = strBn[0:-1]
bntranslit.convertString(strBn)
self.labelBn.set_text(bntranslit.tstr + bntranslit.fin_s +
bntranslit.unfin_s)
return True
else:
return False
elif (event.keyval >= 0
and event.keyval < 128) or (event.keyval >= 65456
and event.keyval <= 65465):
if event.keyval >= 65456:
event.keyval = ord('0') + event.keyval - 65456
bntranslit.translit(chr(event.keyval))
self.labelBn.set_text(bntranslit.tstr + bntranslit.fin_s +
bntranslit.unfin_s)
return True
elif event.keyval in dicnumerickeypad.keys():
event.keyval = dicnumerickeypad[event.keyval]
bntranslit.translit(chr(event.keyval))
self.labelBn.set_text(bntranslit.tstr + bntranslit.fin_s +
bntranslit.unfin_s)
return True
else:
#self.flushBnText()
return False
def _on_key_press_event(self, widget, event):
keyname = keyval_name(event.keyval)
if keyname is not None:
func = getattr(self, 'keypress_' + keyname.lower(), None)
selected_rows = self.listview.get_selection().get_selected_rows()[1]
if func and selected_rows:
return func(event)
def keyPress(self, arg, event):
kname = gdk.keyval_name(event.keyval).lower()
if kname=='up':
self.jdPlus(-1)
elif kname=='down':
self.jdPlus(1)
elif kname in ('space', 'home'):
self.goToday()
elif kname=='end':
self.gotoJd(self.status[-1].jd)
elif kname=='page_up':
self.jdPlus(-7)
elif kname=='page_down':
self.jdPlus(7)
#elif kname=='menu':
# self.emit('popup-menu-cell', event.time, *self.getCellPos())
#elif kname in ('f10', 'm'):
# if event.state & gdk.SHIFT_MASK:
# # Simulate right click (key beside Right-Ctrl)
# self.emit('popup-menu-cell', event.time, *self.getCellPos())
# else:
# self.emit('popup-menu-main', event.time, *self.getMainMenuPos())
else:
return False
return True
def on_drawarea_keypress(self, wid, e, data=None):
# block all keyboard events if panning or selecting
if self.panning or self.selecting:
return True
elif self.kbselect_state is not None:
key = GG.keyval_name(e.keyval)
if e.state & ALLMODS != 0:
return True
elif key in ('space', 'KP_Space'):
self.on_key_space(wid)
elif key in ('Return', 'KP_Enter'):
self.on_key_return()
elif key in ('Insert', 'KP_Insert'):
self.on_key_insert()
elif key in ('Delete', 'KP_Delete'):
self.on_key_delete()
elif key in self.select_keymap:
dsp = GG.display_get_default()
screen , x , y , mods = dsp.get_pointer()
shift = self.select_keymap[key]
x, y = x + shift[0], y + shift[1]
dsp.warp_pointer(screen, x , y)
if self.kbselect_state == 'extending':
xw, yw = wid.get_pointer()
w, h = self.doc.get_page(self.current_page).get_size()
self.view.continue_ptr_selection(xw, yw, self.zoom,
self.rotation, h)
self.view.invalidate()
return True
else:
return False
def getKeyName(keyval):
'''Get key name.'''
keyUnicode = gdk.keyval_to_unicode(keyval)
if keyUnicode == 0:
return gdk.keyval_name(keyval)
else:
return str(unichr(keyUnicode))
def keyPress(self, treev, g_event):
#from scal2.time_utils import getCurrentTime, getGtkTimeFromEpoch
#print g_event.time-getGtkTimeFromEpoch(time())## FIXME
#print getCurrentTime()-gdk.CURRENT_TIME/1000.0
## gdk.CURRENT_TIME == 0## FIXME
## g_event.time == gtk.get_current_event_time() ## OK
kname = gdk.keyval_name(g_event.keyval).lower()
if kname=='menu':## Simulate right click (key beside Right-Ctrl)
path = treev.get_cursor()[0]
if path:
menu = self.genRightClickMenu(path)
if not menu:
return
rect = treev.get_cell_area(path, treev.get_column(1))
x = rect.x
if rtl:
x -= 100
else:
x += 50
dx, dy = treev.translate_coordinates(self, x, rect.y + rect.height)
wx, wy = self.window.get_origin()
menu.popup(
None,
None,
lambda m: (wx+dx, wy+dy+20, True),
3,
g_event.time,
)
elif kname=='delete':
self.moveSelectionToTrash()
else:
#print kname
return False
return True
def keyPress(self, arg, event):
k = gdk.keyval_name(event.keyval).lower()
#print '%.3f'%time.time()
if k in ('space', 'home'):
self.centerToNow()
elif k=='right':
self.movingUserEvent(1)
elif k=='left':
self.movingUserEvent(-1)
elif k=='down':
self.stopMovingAnim()
elif k in ('q', 'escape'):
self.closeFunc()
#elif k=='end':
# pass
#elif k=='page_up':
# pass
#elif k=='page_down':
# pass
#elif k=='menu':# Simulate right click (key beside Right-Ctrl)
# #self.emit('popup-menu-cell', event.time, *self.getCellPos())
#elif k in ('f10','m'): # F10 or m or M
# if event.state & gdk.SHIFT_MASK:
# # Simulate right click (key beside Right-Ctrl)
# self.emit('popup-menu-cell', event.time, *self.getCellPos())
# else:
# self.emit('popup-menu-main', event.time, *self.getMainMenuPos())
else:
return False
self.queue_draw()
return True
def key_press_event(self,widget,event): from gtk.gdk import CONTROL_MASK from gtk.gdk import keyval_name #if event.state & CONTROL_MASK: #if keyval_name(event.keyval) == "Page_Up": #elif keyval_name(event.keyval) == "Page_Down": #else: print "Your press " + keyval_name(event.keyval) + " " + str(event.keyval)
def __keycode_button_clicked_cb(self, button):
out = []
dlg = gtk.MessageDialog(parent=self.get_toplevel(),
buttons=gtk.BUTTONS_CLOSE)
message = _(
"Please press a key (or a key combination).\nThe dialog will be closed when the key is released."
)
dlg.set_markup(message)
dlg.set_title(_("Please press a key (or a key combination)"))
def __key_press_event(d, k, out):
out.append(k.copy())
def __key_release_event(d, k, out):
d.response(gtk.RESPONSE_OK)
dlg.connect("key-press-event", __key_press_event, out)
dlg.connect("key-release-event", __key_release_event, None)
id = dlg.run()
dlg.destroy()
if id != gtk.RESPONSE_OK or not out:
return
keyevent = out[len(out) - 1]
state = keyevent.state & (gdk.CONTROL_MASK | \
gdk.SHIFT_MASK | \
gdk.MOD1_MASK | \
gdk.META_MASK | \
gdk.SUPER_MASK | \
gdk.HYPER_MASK)
if state == 0:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Control_L, keysyms.Control_R
) and state == gdk.CONTROL_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Shift_L,
keysyms.Shift_R) and state == gdk.SHIFT_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Alt_L,
keysyms.Alt_R) and state == gdk.MOD1_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Meta_L,
keysyms.Meta_R) and state == gdk.META_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Super_L,
keysyms.Super_R) and state == gdk.SUPER_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Hyper_L,
keysyms.Hyper_R) and state == gdk.HYPER_MASK:
state = state | gdk.RELEASE_MASK
for name, button, mask in self.__modifier_buttons:
if state & mask:
button.set_active(True)
else:
button.set_active(False)
self.__keycode_entry.set_text(gdk.keyval_name(keyevent.keyval))
def keyPress(self, obj, gevent):
kval = gevent.keyval
kname = gdk.keyval_name(gevent.keyval).lower()
#print kval, kname
if kname in (
'tab', 'escape', 'backspace', 'delete', 'insert',
'home', 'end',
'control_l', 'control_r',
'iso_next_group',
):
return False
elif kname == 'return':
self.validate()
return False
elif kname=='up':
self.numPlus(1)
elif kname=='down':
self.numPlus(-1)
elif kname=='page_up':
self.numPlus(self.page_inc)
elif kname=='page_down':
self.numPlus(-self.page_inc)
elif kname=='left':
return False## FIXME
elif kname=='right':
return False## FIXME
#elif kname in ('braceleft', 'bracketleft'):
# self.insertText(u'[')
#elif kname in ('braceright', 'bracketright'):
# self.insertText(u']')
elif kname in ('comma', 'arabic_comma'):
self.insertText(u', ', False)
elif kname=='minus':
pos = self.get_position()
text = toUnicode(self.get_text())
n = len(text)
if pos==n:
start = numDecode(text.split(',')[-1].strip())
self.insertText(u'-' + _(start + 2), False)
else:
self.insertText(u'-', False)
elif ord('0') <= kval <= ord('9'):
self.insertText(self.digs[kval-ord('0')])
else:
uniVal = gtk.gdk.keyval_to_unicode(kval)
#print 'uniVal=%r'%uniVal
if uniVal!=0:
ch = unichr(uniVal)
#print 'ch=%r'%ch
if ch in self.digs:
self.insertText(ch)
if gevent.state & gdk.CONTROL_MASK:## Shortcuts like Ctrl + [A, C, X, V]
return False
else:
print kval, kname
return True
def _check_input(self, key_pressed):
close = False
if keyval_name(key_pressed) == 'BackSpace':
self.search.pop()
elif keyval_name(key_pressed) == 'Return':
best_guess_pos = self.search.best_guess()[0]
if best_guess_pos:
secured_clipboard(self.ring.get_password(best_guess_pos))
close = True
elif keyval_name(key_pressed) == 'space':
if len(self.search.string) > 0:
#TODO unsecured memory
pw = self.pw_engine.create_passwords()[0]
pos = self.ring.save_password(pw, searchable=self.search.string)
secured_clipboard(self.ring.get_password(pos))
close = True
elif key_pressed < 256 and key_pressed > 32:
self.search.push(chr(key_pressed))
return close
def __key_press_event_cb(self, entry, event):
from gtk.gdk import keyval_name, SHIFT_MASK
keyname = keyval_name(event.keyval)
ShiftKey = (event.state & SHIFT_MASK)
Return = (keyname == "Return")
Escape = (keyname == "Escape")
if ShiftKey:
if Return: self.__manager.emit("back-button")
if Escape: self.__manager.emit("hide-bar")
return False
def key_pressed(self, widget, event):
if not keyval_name(event.keyval) == 'Escape':
if not self._check_input(event.keyval):
self._redraw_left_frame(widget, event.keyval)
self._redraw_right_frame(widget, event.keyval)
else:
self.emit("copied-event")
else:
self.hide()
self.destroy()
def isKeypadKey(self, keycode):
entry = self._keymap.get_entries_for_keycode(keycode)
if entry:
for info in entry:
if info[2] == self._group:
name = gdk.keyval_name(info[0]) # @UndefinedVariable
if name and name.startswith('KP_'):
return True
return False
def on_key_press(self, view, event, buffer):
"""Check if the key press is 'Return' or 'Backspace' and indent or
un-indent accordingly.
"""
key_name = gdk.keyval_name(event.keyval)
if key_name not in ('Return', 'BackSpace') or \
len(buffer.get_selection_bounds()) != 0:
# If some text is selected we want the default behavior of Return
# and Backspace so we do nothing
return
if view.get_insert_spaces_instead_of_tabs():
self.indent = ' ' * view.props.tab_width
else:
self.indent = '\t'
if key_name == 'Return':
line = self._get_current_line(buffer)
if line.endswith(':'):
old_indent = line[:len(line) - len(line.lstrip())]
indent = '\n' + old_indent + self.indent
# Use insert_interactive instead of insert, so that the
# undo manager knows what we are doing (or something like that).
# The True parameter is here because we are inserting into an
# editable view
buffer.insert_interactive_at_cursor(indent, True)
self._scroll_to_cursor(buffer, view)
return True
else:
stripped_line = line.strip()
n = len(line) - len(line.lstrip())
if (stripped_line.startswith('return')
or stripped_line.startswith('break')
or stripped_line.startswith('continue')
or stripped_line.startswith('pass')
or stripped_line.startswith('raise')):
n -= len(self.indent)
buffer.insert_interactive_at_cursor('\n' + line[:n], True)
self._scroll_to_cursor(buffer, view)
return True
if key_name == 'BackSpace':
line = self._get_current_line(buffer)
if line.strip() == '' and line != '':
length = len(self.indent)
nb_to_delete = len(line) % length or length
self._delete_before_cursor(buffer, nb_to_delete)
self._scroll_to_cursor(buffer, view)
return True
def parse_key_event(evt):
args = []
if evt.state & gdk.CONTROL_MASK:
args.append("<Ctrl>")
if evt.state & gdk.MOD1_MASK:
args.append("<Alt>")
if evt.state & gdk.SHIFT_MASK:
args.append("<Shift>")
args.append(gdk.keyval_name(evt.keyval))
return "+".join(args)
def on_key_press(self, view, event, buffer):
"""Check if the key press is 'Return' or 'Backspace' and indent or
un-indent accordingly.
"""
key_name = gdk.keyval_name(event.keyval)
if key_name not in ('Return', 'BackSpace') or \
len(buffer.get_selection_bounds()) != 0:
# If some text is selected we want the default behavior of Return
# and Backspace so we do nothing
return
if view.get_insert_spaces_instead_of_tabs():
self.indent = ' ' * view.props.tab_width
else:
self.indent = '\t'
if key_name == 'Return':
line = self._get_current_line(buffer)
if line.endswith(':'):
old_indent = line[:len(line) - len(line.lstrip())]
indent = '\n' + old_indent + self.indent
# Use insert_interactive instead of insert, so that the
# undo manager knows what we are doing (or something like that).
# The True parameter is here because we are inserting into an
# editable view
buffer.insert_interactive_at_cursor(indent, True)
self._scroll_to_cursor(buffer, view)
return True
else:
stripped_line = line.strip()
n = len(line) - len(line.lstrip())
if (stripped_line.startswith('return')
or stripped_line.startswith('break')
or stripped_line.startswith('continue')
or stripped_line.startswith('pass')
or stripped_line.startswith('raise')):
n -= len(self.indent)
buffer.insert_interactive_at_cursor('\n' + line[:n], True)
self._scroll_to_cursor(buffer, view)
return True
if key_name == 'BackSpace':
line = self._get_current_line(buffer)
if line.strip() == '' and line != '':
length = len(self.indent)
nb_to_delete = len(line) % length or length
self._delete_before_cursor(buffer, nb_to_delete)
self._scroll_to_cursor(buffer, view)
return True
def key_release_event_cb(self, widget, event):
'''
Click
'''
# Filter and dispatch control keys
# TODO key combinations
if gdk.keyval_name(event.keyval) == "Control_L" : # Left control
# print "Control key"
self.control_key_release(event)
else:
self.bland_key_release(event)
return False
def key_release_event_cb(self, widget, event):
'''
Click
'''
# Filter and dispatch control keys
# TODO key combinations
if gdk.keyval_name(event.keyval) == "Control_L": # Left control
# print "Control key"
self.control_key_release(event)
else:
self.bland_key_release(event)
return False
def __treeview_event_cb(self, treeview, event):
from gtk.gdk import keyval_name, MOD1_MASK, CONTROL_MASK
if (event.state == MOD1_MASK) and (keyval_name(event.keyval) == "Left"): return self.__emit("go-back")
if (event.state == MOD1_MASK) and (keyval_name(event.keyval) == "Up"): return self.__emit("go-up")
if (event.state == MOD1_MASK) and (keyval_name(event.keyval) == "Home"): return self.__emit("go-home")
if (event.state == CONTROL_MASK) and (keyval_name(event.keyval) == "h"): return self.__emit("toggle-hidden")
if (event.state & 0 == 0) and (keyval_name(event.keyval) == "F4"): return self.__emit("activate")
if (event.state & 0 == 0) and (keyval_name(event.keyval) == "Escape"): return self.__emit("activate")
if (event.state & 0 == 0) and (keyval_name(event.keyval) == "Return"): return self.__emit("activate-selection")
return False
def keycode2char(self, keycode, mods, group=0):
char = ''
name = ''
info = self._keymap.translate_keyboard_state(keycode, mods, group)
if info:
keysym = info[0]
char = gdk.keyval_to_unicode(keysym) # @UndefinedVariable
if char:
char = unichr(char)
name = gdk.keyval_name(keysym) # @UndefinedVariable
return char or '', name or ''
def keyPress(self, arg, event):
CustomizableCalObj.keyPress(self, arg, event)
kname = gdk.keyval_name(event.keyval).lower()
if kname in ('space', 'home', 't'):
self.goToday()
elif kname=='menu':
self.emit('popup-menu-cell', event.time, *self.getCellPos())
elif kname=='i':
self.emit('day-info')
else:
return False
return True
def on_keypress(self, widget, event, data = None):
self.__key_str = ""
if event.state & gdk.CONTROL_MASK :
self.__key_str += "Control+"
if event.state & gdk.MOD1_MASK :
self.__key_str += "Alt+"
if event.state & gdk.SHIFT_MASK :
self.__key_str += "Shift+"
self.__key_str += gdk.keyval_name(event.keyval)
self.__dialog.format_secondary_markup('<span size="large" weight="bold">%s</span>' % self.__key_str)
def get_key_name(keyval):
'''
Get key name with given key value.
@param keyval: Key value.
@return: Return key name with given key value.
'''
key_unicode = gdk.keyval_to_unicode(keyval)
if key_unicode == 0:
return gdk.keyval_name(keyval)
else:
return str(unichr(key_unicode))
def _key_press(self, widget, gevent):
kval = gevent.keyval
kname = gdk.keyval_name(kval).lower()
size = len(self.field)
sep = self.field.sep
step_inc, page_inc = self.get_increments()
if kname in ('up', 'down', 'page_up', 'page_down', 'left', 'right'):
if not self.get_editable():
return True
if kname in ('left', 'right'):
return False
#if not self.arrow_select:
# return False
#shift = {
# 'left': -1,
# 'right': 1
#}[kname]
#FIXME
else:
p = {
'up': step_inc,
'down': -step_inc,
'page_up': page_inc,
'page_down': -page_inc,
}[kname]
self.entry_plus(p)
#if fieldIndex==0:
# i1 = 0
#else:
# i1 = strFindNth(text, sep, fieldIndex) + len(sep)
#i2 = strFindNth(text, sep, fieldIndex+1)
##self.grab_focus()
#self.select_region(i1, i2)
return True
#elif kname=='return':## Enter
# self.update()
# ##self.emit('activate')
# return True
elif ord('0') <= kval <= ord('9'):
self.insertText(self.digs[kval-ord('0')])
return True
elif 'kp_0' <= kname <= 'kp_9':
self.insertText(self.digs[int(kname[-1])])
return True
elif kname in (
'period', 'kp_decimal',
'slash', 'kp_divide',## FIXME
):
self.insertText(locale_man.getNumSep())
return True
else:
#print kname, kval
return False
def key_pressed(self, widget, event):
buffer = self.buff
view = widget
key_name = gdk.keyval_name(event.keyval)
"""Check if the key press is 'Return' or 'Backspace' and indent or
un-indent accordingly.
"""
if key_name not in ('Return', 'Backspace') or \
len(buffer.get_selection_bounds()) != 0:
# If some text is selected we want the default behavior of Return
# and Backspace so we do nothing
return
if view.get_insert_spaces_instead_of_tabs():
self.indent = ' ' * view.props.tab_width
else:
self.indent = '\t'
if key_name == 'Return':
line = self._get_current_line(buffer)
if line.endswith(':'):
old_indent = line[:len(line) - len(line.lstrip())]
buffer.insert_at_cursor('\n' + old_indent + self.indent)
return True
else:
stripped_line = line.strip()
n = len(line) - len(line.lstrip())
starts_with_return = stripped_line.startswith('return')
starts_with_break = stripped_line.startswith('break')
starts_with_continue = stripped_line.startswith('continue')
starts_with_pass = stripped_line.startswith('pass')
con_check = (starts_with_return or starts_with_break or
starts_with_continue or starts_with_pass)
if (con_check):
n -= len(self.indent)
buffer.insert_at_cursor('\n' + line[:n])
self._scroll_to_cursor(buffer, view)
return True
if key_name == 'BackSpace':
line = self._get_current_line(buffer)
if line.strip() == '' and line != '':
length = len(self.indent)
nb_to_delete = len(line) % length or length
self._delete_before_cursor(buffer, nb_to_delete)
self._scroll_to_cursor(buffer, view)
return True
def findWithDeadKey(self, keysym):
name = gdk.keyval_name(keysym) # @UndefinedVariable
for deadName in DEAD_KEYS:
if name.endswith(deadName):
keyName = name[:-len(deadName)]
deadName = {'ring': 'abovering',
'schwa': 'small_schwa',
'SCHWA': 'capital_schwa'}.get(deadName, deadName)
deadName = 'dead_' + deadName
keyKeysym = gdk.keyval_from_name(keyName) # @UndefinedVariable
deadSym = gdk.keyval_from_name(deadName) # @UndefinedVariable
return keyKeysym, deadSym
return None
def parse_keypress_event(event):
"""
Get a keypress event, return a tuple of (keyval_name, state).
Will return (None, None) when no appropriate tuple is available.
"""
r = gdk.keymap_get_default().translate_keyboard_state(event.hardware_keycode, event.state, event.group)
if r is None:
# This seems to be the case when pressing CapsLock on win32
return (None, None)
keyval, _group, _level, consumed_mods = r
state = event.state & ~consumed_mods & handled_mods
keyval_name = gdk.keyval_name(keyval)
return keyval_name, state
def on_dialog_key_press(dialog, event, key_mapping, buttons):
from gtk.gdk import keyval_name
key_name = str.lower(str(keyval_name(event.keyval)))
for i, desired_key in enumerate(key_mapping):
if i >= len(buttons):
break
if isinstance(desired_key, list):
key_list = desired_key
for desired_key in key_list:
if str.lower(str(desired_key)) == key_name:
buttons[i].clicked()
elif str.lower(desired_key) == key_name:
buttons[i].clicked()
pass
def keyPress(self, arg, event):
kname = gdk.keyval_name(event.keyval).lower()
#print time(), 'MainWin.keyPress', kname
if kname=='escape':
self.dialogEsc()
elif kname=='f1':
self.aboutShow()
elif kname in ('insert', 'plus', 'kp_add'):
self.eventManShow()
elif kname in ('q', 'arabic_dad'):## FIXME
self.quit()
else:
self.vbox.keyPress(arg, event)
return True ## FIXME
def parse_keypress_event(event):
"""
Get a keypress event, return a tuple of (keyval_name, state).
Will return (None, None) when no appropriate tuple is available.
"""
r = gdk.keymap_get_default().translate_keyboard_state(
event.hardware_keycode, event.state, event.group)
if r is None:
# This seems to be the case when pressing CapsLock on win32
return (None, None)
keyval, _group, _level, consumed_mods = r
state = event.state & ~consumed_mods & handled_mods
keyval_name = gdk.keyval_name(keyval)
return keyval_name, state
def _key_press_cb(self, widget, event):
copy = False
kname = gdk.keyval_name(event.keyval)
if event.state & gdk.CONTROL_MASK or kname in ("Control_L", "Control_R"):
if kname in ('c', 'C') and self.props.state != gtksheet.SHEET_NORMAL:
if self.in_clip():
self.unclip_range()
#/*gtk_sheet_unselect_range(sheet);*/
copy = True
if kname in ('x', 'X') and self.state != gtksheet.SHEET_NORMAL:
if self.in_clip():
self.unclip_range()
copy = True
if copy:
return self._copy_to_clipboard()
return False
def get_key_name(keyval, to_upper=False):
'''
Get key name with given key value.
@param keyval: Key value.
@param to_upper: Set as True to return upper key name, default is False.
@return: Return key name with given key value.
'''
if to_upper:
key_unicode = gdk.keyval_to_unicode(gdk.keyval_to_upper(keyval))
else:
key_unicode = gdk.keyval_to_unicode(keyval)
if key_unicode == 0:
return gdk.keyval_name(keyval)
else:
return str(unichr(key_unicode))
def __keycode_button_clicked_cb(self, button):
out = []
dlg = gtk.MessageDialog(parent = self.get_toplevel(), buttons = gtk.BUTTONS_CLOSE)
message = _("Please press a key (or a key combination).\nThe dialog will be closed when the key is released.")
dlg.set_markup(message)
dlg.set_title(_("Please press a key (or a key combination)"))
def __key_press_event(d, k, out):
out.append(k.copy())
def __key_release_event(d, k, out):
d.response(gtk.RESPONSE_OK)
dlg.connect("key-press-event", __key_press_event, out)
dlg.connect("key-release-event", __key_release_event, None)
id = dlg.run()
dlg.destroy()
if id != gtk.RESPONSE_OK or not out:
return
keyevent = out[len(out) - 1]
state = keyevent.state & (gdk.CONTROL_MASK | \
gdk.SHIFT_MASK | \
gdk.MOD1_MASK | \
gdk.META_MASK | \
gdk.SUPER_MASK | \
gdk.HYPER_MASK)
if state == 0:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Control_L, keysyms.Control_R) and state == gdk.CONTROL_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Shift_L, keysyms.Shift_R) and state == gdk.SHIFT_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Alt_L, keysyms.Alt_R) and state == gdk.MOD1_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Meta_L, keysyms.Meta_R) and state == gdk.META_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Super_L, keysyms.Super_R) and state == gdk.SUPER_MASK:
state = state | gdk.RELEASE_MASK
elif keyevent.keyval in (keysyms.Hyper_L, keysyms.Hyper_R) and state == gdk.HYPER_MASK:
state = state | gdk.RELEASE_MASK
for name, button, mask in self.__modifier_buttons:
if state & mask:
button.set_active(True)
else:
button.set_active(False)
self.__keycode_entry.set_text(gdk.keyval_name(keyevent.keyval))
def get_key_name(keyval, to_upper=False):
'''
Get key name with given key value.
@param keyval: Key value.
@param to_upper: Set as True to return upper key name, default is False.
@return: Return key name with given key value.
'''
if to_upper:
key_unicode = gdk.keyval_to_unicode(gdk.keyval_to_upper(keyval))
else:
key_unicode = gdk.keyval_to_unicode(gdk.keyval_convert_case(keyval)[0])
if key_unicode == 0:
return gdk.keyval_name(keyval)
else:
return str(unichr(key_unicode))
def handle_key_press_event(self, sender, event):
keyname = gdk.keyval_name(event.keyval)
if keyname == 'w' and event.state & gdk.CONTROL_MASK:
self.tabs.close_current()
return True
elif keyname == 't' and event.state & gdk.CONTROL_MASK:
self.tabs.new_page()
return True
elif keyname == 'q' and event.state & gdk.CONTROL_MASK:
gtk.main_quit()
return True
elif keyname == 'Right' and event.state & gdk.MOD1_MASK:
self.tabs.next_page()
return True
elif keyname == 'Left' and event.state & gdk.MOD1_MASK:
self.tabs.prev_page()
return True
def __key_press_event_cb(self, widget, event):
from gtk.gdk import keyval_name
if keyval_name(event.keyval) != "Return": return False
from gtk.gdk import SHIFT_MASK, MOD1_MASK, CONTROL_MASK
if event.state & SHIFT_MASK: return False
if event.state & MOD1_MASK: return False
if event.state & CONTROL_MASK: return False
ends_with_colon = self.__line_ends_with_colon()
if ends_with_colon:
if self.__cursor_is_before_colon(): return False
self.__indent_next_line()
return True
starts_with_return = self.__starts_with_return()
if not starts_with_return: return False
if self.__cursor_is_before_return(): return False
self.__dedent_next_line()
return True
def __key_press_event_cb(self, widget, event): from gtk.gdk import keyval_name if keyval_name(event.keyval) != "Return": return False from gtk.gdk import SHIFT_MASK, MOD1_MASK, CONTROL_MASK if event.state & SHIFT_MASK: return False if event.state & MOD1_MASK: return False if event.state & CONTROL_MASK: return False ends_with_colon = self.__line_ends_with_colon() if ends_with_colon: if self.__cursor_is_before_colon(): return False self.__indent_next_line() return True starts_with_return = self.__starts_with_return() if not starts_with_return: return False if self.__cursor_is_before_return(): return False self.__dedent_next_line() return True
def keyPress(self, arg, event):
t = time()
#if t-self.kTime < ui.keyDelay:
# return True
kname = gdk.keyval_name(event.keyval).lower()
#if kname.startswith('alt'):
# return True
## How to disable Alt+Space of metacity ?????????????????????
if kname=='up':
self.jdPlus(-7)
elif kname=='down':
self.jdPlus(7)
elif kname=='right':
if rtl:
self.jdPlus(-1)
else:
self.jdPlus(1)
elif kname=='left':
if rtl:
self.jdPlus(1)
else:
self.jdPlus(-1)
elif kname in ('space', 'home'):
self.goToday()
elif kname=='end':
self.changeDate(ui.cell.year, ui.cell.month, getMonthLen(ui.cell.year, ui.cell.month, core.primaryMode))
elif kname=='page_up':
ui.monthPlus(-1)
self.onDateChange()
elif kname=='page_down':
ui.monthPlus(1)
self.onDateChange()
elif kname=='menu':
self.emit('popup-menu-cell', event.time, *self.getCellPos())
elif kname in ('f10', 'm'):
if event.state & gdk.SHIFT_MASK:
# Simulate right click (key beside Right-Ctrl)
self.emit('popup-menu-cell', event.time, *self.getCellPos())
else:
self.emit('popup-menu-main', event.time, *self.getMainMenuPos())
else:
return False
return True
def on_navigate_key(self, treeview, event):
keyname = gdk.keyval_name(event.keyval)
path, col = treeview.get_cursor()
columns = [c for c in treeview.get_columns()]
colnum = columns.index(col)
nrows = len(treeview.get_model())
if keyname == 'Tab':
newcol = treeview.get_column((colnum + 1) % 3)
newpath = path
treeview.set_cursor(newpath, newcol, True)
elif keyname == 'Return':
newcol = treeview.get_column(colnum)
if path[0] + 1 < nrows:
newpath = (path[0] + 1, )
treeview.set_cursor(newpath, newcol, True)
else:
pass
def key_press(self, widget, event):
""" The mouse_button function serves, as the names states, to catch
events in the keyboard, e.g. letter 'l' pressed, 'backslash'
pressed. Note that there is a difference between 'A' and 'a'.
Here I use a specific handler for each key pressed after
discarding the CONTROL, ALT and SHIFT keys pressed (usefull
for customized actions) and maintained, i.e. it's the same as
using Ctrl+Z to undo an action.
"""
k_name = gdk.keyval_name(event.keyval)
if event.state & gdk.CONTROL_MASK:
print 'Ctrl pressed'
elif event.state & gdk.MOD1_MASK:
print 'Alt pressed'
elif event.state & gdk.SHIFT_MASK:
print 'Shift pressed'
else:
func = getattr(self, 'pressed_' + k_name, None)
print k_name, 'key Pressed'
if func:
func()
return True
def __treeview_event_cb(self, treeview, event):
from gtk.gdk import keyval_name, MOD1_MASK, CONTROL_MASK
if (event.state == MOD1_MASK) and (keyval_name(event.keyval)
== "Left"):
return self.__emit("go-back")
if (event.state == MOD1_MASK) and (keyval_name(event.keyval) == "Up"):
return self.__emit("go-up")
if (event.state == MOD1_MASK) and (keyval_name(event.keyval)
== "Home"):
return self.__emit("go-home")
if (event.state == CONTROL_MASK) and (keyval_name(event.keyval)
== "h"):
return self.__emit("toggle-hidden")
if (event.state & 0 == 0) and (keyval_name(event.keyval) == "F4"):
return self.__emit("activate")
if (event.state & 0 == 0) and (keyval_name(event.keyval) == "Escape"):
return self.__emit("activate")
if (event.state & 0 == 0) and (keyval_name(event.keyval) == "Return"):
return self.__emit("activate-selection")
return False
def do_key_press_event(self, event):
if not self.active:
return False
log.info("do_key_press_event()")
key_name = gdk.keyval_name(event.keyval)
log.info("key_name = " + str(key_name))
# Deactivate on Escape
if key_name == "Escape":
self.deactivate()
return True
keybinding = []
# FIXME Doesn't work with any super combination
# FIXME What if keys are already used by another plugin?
if key_name == "space" or key_name == "Tab" \
or key_name in string.ascii_letters:
# Check for Ctrl
if event.state & gdk.CONTROL_MASK:
log.info("Ctrl held down.")
keybinding.append("ctrl")
# Check for Alt
if event.state & gdk.MOD1_MASK:
log.info("Alt held down.")
keybinding.append("alt")
# Check for Shift
if event.state & gdk.SHIFT_MASK:
log.info("Shift held down.")
keybinding.append("shift")
keybinding.append(key_name.lower())
log.info("Setting key keybinding to " + '+'.join(keybinding))
self.setKeybinding('+'.join(keybinding))
self.deactivate()
self.emit("keybinding-changed", self.getKeybinding())
return True
def __key_press_event_cb(self, entry, event):
from gtk.gdk import keyval_name, SHIFT_MASK
keyname = keyval_name(event.keyval)
if keyname != "Escape": return False
self.__manager.emit("hide-bar")
return False
def event_key_released(self, widget, event):
key = gdk.keyval_name(event.keyval)
if self.gui_key_on(key):
self.keys.pop(key)
def on_themes_trv_key_press_event(self, _widget, event):
if gdk.keyval_name(event.keyval) == 'Delete':
if len(self.themes_list) < 2:
beep()
else:
self.delete_theme()
def on_key_press_event(self, widget, event):
keyname = keyval_name(event.keyval)
if keyname is not None:
func = getattr(self, 'keypress_' + keyname.lower(), None)
if func:
return func(event)
def key_press_event(self, w, e):
if gdk.keyval_name(e.keyval) == 'Escape':
self.destroy()
def check_for_enter(self, entry, event):
key_name = keyval_name(event.keyval)
if key_name in ["Return", "KP_Enter"]:
self.change_name(entry.get_text())
def __window_event_cb(self, window, event):
from gtk.gdk import keyval_name
if (event.state & 0 == 0) and (keyval_name(event.keyval) == "F6"):
return self.__emit("switch-focus")
return False
def accept(self, a_key):
"""Ensure that key is within the original ASCII 128."""
if a_key > 127:
return ord(self.mapped.get(gdk.keyval_name(a_key), '$'))
else:
return a_key
def on_key_press_event(self, widget, event):
keyname = keyval_name(event.keyval).lstrip('KP_').lower()
if keyname.isdigit() or keyname in [
'period', 'minus', 'delete', 'backspace'
]:
self.button_apply.set_sensitive(True)
def _key_press_cb(self, widget, event):
if not self._grabbed:
return
if gdk.keyval_name(event.keyval).upper() == "ESCAPE":
self.popdown()
return True
def event_key_pressed(self, widget, event):
key = gdk.keyval_name(event.keyval)
self.keys[key] = True
if key == 'c' and (event.state & gdk.CONTROL_MASK):
import sys
sys.exit()
def event_key_pressed(self, widget, event):
key = gdk.keyval_name(event.keyval)
self.keys[key] = True
if key == "space" and self.trajectory is not None and len(
self.trajectory) > 1:
self.event_toggle_play()
def keyPress(event):
if opts.TraceKeys:
print "%s : %s pressed" % (event.keyval, gdk.keyval_name(event.keyval))
