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 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 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 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 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 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))