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
