def __init__(self, main_instance): """ Constructor """ gobject.GObject.__init__(self) threading.Thread.__init__(self) self.setDaemon(True) self.running = False self.main = main_instance try: XK.load_keysym_group("xf86") except ImportError, err: log.warn("Xlib backend needs python-xlib 0.15rc1 or higher\n") raise ImportError(str(err))
def run(self): self.disp = Display() XK.load_keysym_group('xf86') root = self.disp.screen().root ctx = self.disp.record_create_context(0, [record.AllClients], [{ 'core_requests': (0, 0), 'core_replies': (0, 0), 'ext_requests': (0, 0, 0, 0), 'ext_replies': (0, 0, 0, 0), 'delivered_events': (0, 0), 'device_events': (X.KeyReleaseMask, X.ButtonReleaseMask), 'errors': (0, 0), 'client_started': False, 'client_died': False, }]) self.disp.record_enable_context(ctx, lambda reply: self.event_handler(reply)) self.disp.record_free_context(ctx) while True: event = root.display.next_event()
def __init__(self, display=None): PyKeyboardMeta.__init__(self) self.display = Display(display) self.root = self.display.screen().root XK.load_keysym_group('xkb') altList = self.display.keysym_to_keycodes(XK.XK_ISO_Level3_Shift) self.__usable_modifiers = (0, 1) for code, offset in altList: if code == 108 and offset == 0: self.__usable_modifiers += (4, 5) break mapping = self.display.get_modifier_mapping() self.modmasks = {} for keyname in MODIFIERS: keysym = XK.string_to_keysym(keyname) keycodes = self.display.keysym_to_keycodes(keysym) found = False for keycode, lvl in keycodes: for index, mask in MASK_INDEXES: if keycode in mapping[index]: self.modmasks[keycode] = mask found = True if found: break self.flags = { 'Shift': X.ShiftMask, 'Lock': X.LockMask, 'Ctrl': X.ControlMask, 'Alt': 0, 'AltGr': self.modmasks[altList[0][0]], 'Hankaku': 0} self.special_key_assignment()
self.handle_keyrelease(event.hw_code) def __processMouseEvent(self, event): if event.type[-1] == "p": button = int(event.type[-2]) self.handle_mouseclick(button, event.detail1, event.detail2) def __pumpEvents(self): pyatspi.Registry.pumpQueuedEvents() return True from iomediator import Key, MODIFIERS from configmanager import * XK.load_keysym_group("xkb") XK_TO_AK_MAP = { XK.XK_Shift_L: Key.SHIFT, XK.XK_Shift_R: Key.SHIFT, XK.XK_Caps_Lock: Key.CAPSLOCK, XK.XK_Control_L: Key.CONTROL, XK.XK_Control_R: Key.CONTROL, XK.XK_Alt_L: Key.ALT, XK.XK_Alt_R: Key.ALT, XK.XK_ISO_Level3_Shift: Key.ALT_GR, XK.XK_Super_L: Key.SUPER, XK.XK_Super_R: Key.SUPER, XK.XK_Hyper_L: Key.HYPER, XK.XK_Hyper_R: Key.HYPER, XK.XK_Meta_L: Key.META,
def __processMouseEvent(self, event): if event.type[-1] == 'p': button = int(event.type[-2]) self.handle_mouseclick(button, event.detail1, event.detail2) def __pumpEvents(self): pyatspi.Registry.pumpQueuedEvents() return True from .iomediator_constants import MODIFIERS from .iomediator_Key import Key # from .iomediator import Key, MODIFIERS from .configmanager import * XK.load_keysym_group('xkb') XK_TO_AK_MAP = { XK.XK_Shift_L : Key.SHIFT, XK.XK_Shift_R : Key.SHIFT, XK.XK_Caps_Lock : Key.CAPSLOCK, XK.XK_Control_L : Key.CONTROL, XK.XK_Control_R : Key.CONTROL, XK.XK_Alt_L : Key.ALT, XK.XK_Alt_R : Key.ALT, XK.XK_ISO_Level3_Shift : Key.ALT_GR, XK.XK_Super_L : Key.SUPER, XK.XK_Super_R : Key.SUPER, XK.XK_Hyper_L : Key.HYPER, XK.XK_Hyper_R : Key.HYPER, XK.XK_Meta_L : Key.META,
MASK_INDEXES = [ (X.ShiftMapIndex, X.ShiftMask), (X.ControlMapIndex, X.ControlMask), (X.LockMapIndex, X.LockMask), (X.Mod1MapIndex, X.Mod1Mask), (X.Mod2MapIndex, X.Mod2Mask), (X.Mod3MapIndex, X.Mod3Mask), (X.Mod4MapIndex, X.Mod4Mask), (X.Mod5MapIndex, X.Mod5Mask), ] MODIFIERS = [ Key.CONTROL, Key.ALT, Key.ALT_GR, Key.SHIFT, Key.SUPER, Key.HYPER, Key.META, Key.CAPSLOCK, Key.NUMLOCK ] XK.load_keysym_group('xkb') XK_TO_AK_MAP = { XK.XK_Shift_L: Key.SHIFT, XK.XK_Shift_R: Key.SHIFT, XK.XK_Caps_Lock: Key.CAPSLOCK, XK.XK_Control_L: Key.CONTROL, XK.XK_Control_R: Key.CONTROL, XK.XK_Alt_L: Key.ALT, XK.XK_Alt_R: Key.ALT, XK.XK_ISO_Level3_Shift: Key.ALT_GR, XK.XK_Super_L: Key.SUPER, XK.XK_Super_R: Key.SUPER, XK.XK_Hyper_L: Key.HYPER, XK.XK_Hyper_R: Key.HYPER, XK.XK_Meta_L: Key.META,
from .common import unpack as _unpack from .hidpp20 import FEATURE as _F from .special_keys import CONTROL as _CONTROL _log = getLogger(__name__) del getLogger # many of the rule features require X11 so turn rule processing off if X11 is not available try: import Xlib from Xlib import X from Xlib.display import Display from Xlib.ext import record from Xlib.protocol import rq from Xlib import XK as _XK _XK.load_keysym_group('xf86') XK_KEYS = vars(_XK) disp_prog = Display() x11 = True except Exception: _log.warn('X11 not available - rules will not be activated') XK_KEYS = {} x11 = False if x11: # determine name of active process NET_ACTIVE_WINDOW = disp_prog.intern_atom('_NET_ACTIVE_WINDOW') NET_WM_PID = disp_prog.intern_atom('_NET_WM_PID') root2 = disp_prog.screen().root root2.change_attributes(event_mask=Xlib.X.PropertyChangeMask)
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from Xlib import XK import KEYSYMDEF _keysyms = [name for name in dir(KEYSYMDEF)] for keysym in _keysyms: XK.__dict__[keysym] = KEYSYMDEF.__dict__[keysym] del KEYSYMDEF XK.load_keysym_group('miscellany') XK.load_keysym_group('latin1') XK.load_keysym_group('latin2') XK.load_keysym_group('latin3') XK.load_keysym_group('latin4') XK.load_keysym_group('arabic') XK.load_keysym_group('cyrillic') XK.load_keysym_group('greek') XK.load_keysym_group('hebrew') XK.load_keysym_group('katakana') XK.load_keysym_group('korean') XK.load_keysym_group('publishing') XK.load_keysym_group('thai') XK.load_keysym_group('xkb') XK.load_keysym_group('technical')
def __init__(self, prefs, session_info): self.prefs = prefs self.session_info = session_info self.ewmh = EWMH() self.dpy = display.Display() self.screen = self.dpy.screen() self.dpy_root = self.screen.root self.colormap = self.screen.default_colormap self.pixel_palette = PixelPalette(self.colormap) self.display_dimensions = self.get_display_geometry() self.window_resize_options = [ "center", "maximize", "left", "right", "top", "bottom" ] self.managed_windows = [] self.exposed_windows = [] self.last_raised_window = None self.active_window_title = self.session_info.session_name self.window_order = -1 self.key_alias = {} self.keys_down = set() self.start = None self.attr = None self.wm_window_type = self.dpy.intern_atom('_NET_WM_WINDOW_TYPE') self.wm_state = self.dpy.intern_atom('_NET_WM_STATE') self.wm_window_types = { "dock": self.dpy.intern_atom('_NET_WM_WINDOW_TYPE_DOCK'), "normal": self.dpy.intern_atom('_NET_WM_WINDOW_TYPE_NORMAL'), "dialog": self.dpy.intern_atom('_NET_WM_WINDOW_TYPE_DIALOG'), "utility": self.dpy.intern_atom('_NET_WM_WINDOW_TYPE_UTILITY'), "toolbar": self.dpy.intern_atom('_NET_WM_WINDOW_TYPE_TOOLBAR'), "menu": self.dpy.intern_atom('_NET_WM_WINDOW_TYPE_MENU'), "splash": self.dpy.intern_atom('_NET_WM_WINDOW_TYPE_SPLASH') } self.wm_window_status = { "active": self.dpy.intern_atom('_NET_ACTIVE_WINDOW'), "desktop": self.dpy.intern_atom('_NET_WM_DESKTOP'), "above": self.dpy.intern_atom('_NET_WM_STATE_ABOVE'), "skip_taskbar": self.dpy.intern_atom('_NET_WM_STATE_SKIP_TASKBAR'), "maximize_vertical": self.dpy.intern_atom('_NET_WM_STATE_MAXIMIZED_VERT'), "maximize_horizontal": self.dpy.intern_atom('_NET_WM_STATE_MAXIMIZED_HORIZ') } self.wm_window_cyclical = [ self.wm_window_types["normal"], self.wm_window_types["dialog"], self.wm_window_types["utility"], self.wm_window_types["toolbar"] ] self.deskbar = None self.display_corners = None self.update_active_window_title_rt = RepeatedTimer( interval=1, function=self.update_active_window_title) self.update_active_window_title_rt.stop() self.set_cursor(self.dpy_root) XK.load_keysym_group('xf86') self.set_key_aliases()
back=(0, 0, 0)): cursor_font = dpy.open_font('cursor') return cursor_font.create_glyph_cursor(cursor_font, cursor_idx, cursor_idx + 1, fore, back) verbose = "-v" in sys.argv[1:] dpy = Display() root = dpy.screen().root cursor = create_font_cursor(dpy, Xcursorfont.pirate) active_cursor = create_font_cursor(dpy, Xcursorfont.pirate, fore=(0xffff, 0, 0)) esc_keycode = dpy.keysym_to_keycode(XK.XK_Escape) # other intersting keys: XK.load_keysym_group('xf86') XK.XK_XF86_PowerOff XK.XK_XF86_AudioMedia print "# grab pointer:", root.grab_pointer(False, X.ButtonPressMask | X.ButtonReleaseMask, X.GrabModeAsync, X.GrabModeAsync, X.NONE, cursor, X.CurrentTime) print "# grab keyboard:", root.grab_keyboard(False, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime) # cheap. import os os.system('notify-send "XKidGrab" "Keyboard and mouse buttons grabbed.' + ' Exit by pressing Escape %d times."' % ESCAPE_COUNT) active_cnt = 0
def __init__(self): self.display = Display() self.root_win = self.display.screen().root self.go_on = True # var to keep looping events (or not) self.notifs_on = False self.poweroff_time = 0 clear_log() # clear the log file once # kobo touch screen dimension: 600x800px (minus the dock) self.full_width = 600 self.full_height = 740 self.keyboard_height = 0 self.keyboard_on = False self.active_window = None # may be transient self.top_win_list = [] # list of the top window to cycle in self.top_win_pos = -1 # postition in the top win list, -1 means you have to start over self.transient_of = { } # key: win, val: set of windows transient for win # windows of wm-related apps self.wm_keyboard, self.wm_launcher, self.wm_dock, self.wm_notifs = None, None, None, None # codes for the keys to catch self.f1_codes = set( code for code, index in self.display.keysym_to_keycodes(XK.XK_F1)) self.f2_codes = set( code for code, index in self.display.keysym_to_keycodes(XK.XK_F2)) self.f3_codes = set( code for code, index in self.display.keysym_to_keycodes(XK.XK_F3)) self.f4_codes = set( code for code, index in self.display.keysym_to_keycodes(XK.XK_F4)) self.f9_codes = set( code for code, index in self.display.keysym_to_keycodes(XK.XK_F9)) XK.load_keysym_group('xf86') self.poweroff_codes = set( code for code, index in self.display.keysym_to_keycodes( XK.XK_XF86_PowerOff)) self.poweroff_codes.update( set(code for code, index in self.display.keysym_to_keycodes(XK.XK_F12))) self.launch1_codes = set( code for code, index in self.display.keysym_to_keycodes( XK.XK_XF86_Launch1)) self.launch1_codes.update( set(code for code, index in self.display.keysym_to_keycodes(XK.XK_F11))) # error catcher error_catcher = CatchError(BadAccess) self.root_win.change_attributes( event_mask=X.SubstructureRedirectMask, onerror=error_catcher, background_pixel=self.display.screen().white_pixel) self.display.sync() error = error_catcher.get_error() if error: sys.exit(1) # grab root window key events self.grab_root_key(self.poweroff_codes, X.NONE) self.grab_root_key(self.launch1_codes, X.NONE) self.grab_root_key(self.f1_codes, X.NONE) self.grab_root_key(self.f2_codes, X.NONE) self.grab_root_key(self.f3_codes, X.NONE) self.grab_root_key(self.f4_codes, X.NONE) self.grab_root_key(self.f9_codes, X.NONE) # handlers self.display.set_error_handler(self.x_error_handler) self.event_dispatch_table = { X.MapRequest: self.handle_map_request, X.ConfigureRequest: self.handle_configure_request, X.MappingNotify: self.handle_mapping_notify, X.UnmapNotify: self.handle_unmapping_notify, X.KeyPress: self.handle_key_press, X.KeyRelease: self.handle_key_release }
def this_should_be_a_module(): import Xlib import Xlib.display from Xlib import X, XK import Xlib.keysymdef for group in Xlib.keysymdef.__all__: XK.load_keysym_group(group) mods = {"c": X.ControlMask, "s": X.ShiftMask, "w": X.Mod4Mask, "a": X.Mod1Mask} modmask = 0 for mod in mods: modmask |= mods[mod] def parse_key(k): (*parts, sym) = k.split("-") modmask = 0 for mod in parts: modmask |= mods[mod] keysym = XK.string_to_keysym(sym) if keysym == 0: print("Invalid key '%s'" % parts) return (keysym, modmask) display = Xlib.display.Display() bound = {} all_keys = {} def regrab_keys(): root = display.screen().root for key in bound.keys(): root.ungrab_key(key[0], key[1]) display.sync() bound.clear() grab_keys(all_keys) def grab_keys(keys): for (code, mask), func in keys.items(): code = display.keysym_to_keycode(code) if (code, mask) == (0, 0): continue bound[code, mask] = func bound[code, mask | X.Mod2Mask] = func bound[code, mask | X.LockMask] = func bound[code, mask | X.Mod2Mask | X.LockMask] = func root = display.screen().root for key in bound.keys(): root.grab_key(key[0], key[1], 1, X.GrabModeAsync, X.GrabModeAsync) display.sync() def bind(keys): keys = {parse_key(k): f for k, f in keys.items()} grab_keys(keys) all_keys.update(keys) def start(): def on_event(): nonlocal bound while display.pending_events(): evt = display.next_event() if evt.type == X.KeyPress: k = (evt.detail, evt.state & modmask) if k in bound: asyncio.ensure_future(bound[k]()) if evt.type == X.MappingNotify and evt.request == X.MappingKeyboard: display.refresh_keyboard_mapping(evt) regrab_keys() asyncio.get_event_loop().add_reader(display.fileno(), on_event) asyncio.get_event_loop().run_forever() return bind, start