def get_geom_of_win(win_id, display=None):
from Xlib.display import Display
if display is None:
d = Display()
else:
d = Display(display)
root = d.screen().root
child_windows = root.query_tree()._data['children']
found = None
done = False
while not done:
done = True
for cw in child_windows:
if cw.id == win_id:
found = cw
break
else:
add_child_windows = cw.query_tree()._data['children']
added = False
for child_window in add_child_windows:
if not child_window in child_windows:
child_windows.append(child_window)
added = True
if added:
done = False
if not found is None:
break
if found is None:
raise Exception(f"No window found with the requested id: {win_id}")
geom = found.get_geometry()._data.copy()
geom.pop('root')
geom.pop('sequence_number')
geom.pop('depth')
return geom
def __init__(self, capture=False, display=None):
self.display = Display(display)
self.display2 = Display(display)
self.ctx = self.display2.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.KeyPress, X.KeyRelease),
'errors': (0, 0),
'client_started': False,
'client_died': False,
}])
self.lock_meaning = None
#Get these dictionaries for converting keysyms and strings
self.keysym_to_string, self.string_to_keysym = self.get_translation_dicts(
)
#Identify and register special groups of keys
self.modifier_keycodes = {}
self.all_mod_keycodes = []
self.keypad_keycodes = []
#self.configure_keys()
#Direct access to the display's keycode-to-keysym array
logger.debug('Keycode to Keysym map')
for i in range(len(self.display._keymap_codes)):
logger.debug('{0}: {1}'.format(i, self.display._keymap_codes[i]))
PyKeyboardEventMeta.__init__(self, capture)
def __init__(self):
self.disp = Display()
self.loc_disp = Display()
self.ctx = None
self.flag = 0
self.first_click = 0.0
self.second_click = 0.0
self.keylistener = KeyListener()
self.keylistener.addKeyListener('Alt_L+l', self.show_app)
self.keylistener.addKeyListener('l+Alt_L', self.show_app)
self.mythread = threading.Thread(target=self.detect_double_ctrl)
self.mythread.daemon = True
self.mythread.start()
def __init__(self):
threading.Thread.__init__(self)
self.finished = threading.Event()
self.contextEventMask = [X.KeyPress, X.MotionNotify]
# Give these some initial values
# Hook to our display.
self.local_dpy = Display()
self.record_dpy = Display()
self.pressed = []
self.listeners = {}
self.character = None
''' 0: Nothing caught; 1: Read buffer and call main module;
2: Call main module
'''
self.status = 0
def __init__(self, xdisplay=None): # type: (Optional[Display]) -> None
"""Connect to X11 and the Glib event loop.
@param xdisplay: A C{python-xlib} display handle.
@type xdisplay: C{Xlib.display.Display}
"""
try:
self.xdisp = xdisplay or Display()
except (UnicodeDecodeError, DisplayConnectionError) as err:
raise XInitError("python-xlib failed with %s when asked to open"
" a connection to the X server. Cannot bind keys."
"\n\tIt's unclear why this happens, but it is"
" usually fixed by deleting your ~/.Xauthority"
" file and rebooting." % err.__class__.__name__)
self.xroot = self.xdisp.screen().root
self._keys = {} # type: Dict[Tuple[int, int], Callable]
# Resolve these at runtime to avoid NameErrors
self._ignored_modifiers = [
getattr(X, name) for name in self.ignored_modifiers
] # type: List[int]
# We want to receive KeyPress events
self.xroot.change_attributes(event_mask=X.KeyPressMask)
# Set up a handler to catch XGrabKey() failures
self.xdisp.set_error_handler(self.cb_xerror)
# Merge python-xlib into the Glib event loop
# Source: http://www.pygtk.org/pygtk2tutorial/sec-MonitoringIO.html
gobject.io_add_watch(self.xroot.display, gobject.IO_IN, self.cb_xevent)
def get_primary_selection():
"""Get the word selected in the primary selection."""
display = Display()
xsel_data_atom = display.intern_atom("XSEL_DATA")
UTF8_STRING = display.intern_atom("UTF8_STRING")
screen = display.screen()
w = screen.root.create_window(0, 0, 2, 2, 0, screen.root_depth)
w.convert_selection(
Xlib.Xatom.PRIMARY, # selection
UTF8_STRING, # target
xsel_data_atom, # property
Xlib.X.CurrentTime) # time
while True:
e = display.next_event()
if e.type == X.SelectionNotify:
break
if e.property != xsel_data_atom or \
e.target != UTF8_STRING:
return ''
reply = w.get_full_property(xsel_data_atom, X.AnyPropertyType)
reply = reply.value.strip()
return reply
def __init__(self) -> None:
self.active_keys = {
XK.string_to_keysym(key): False for key in SETTINGS.keybindings
}
self.modifying_keys = {
XK.string_to_keysym(key): False for key in SETTINGS.keybinding_modifier
}
self.zp = ZoneProfile.from_file()
self.coordinates = Coordinates()
self.display = Display()
self.root = self.display.screen().root
self.context = self.display.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.display.record_enable_context(self.context, self.handler)
self.display.record_free_context(self.context)
def main(options):
# current display
pid_file = '/var/lock/easyxmotion.pid'
# kill any old versions that are still running,
# we do it this way so the current one has input focus.
# might be a better way to just exit and give focus to the old one.
try:
with open(pid_file, 'r') as fp:
pid = int(fp.read())
try:
os.kill(pid, signal.SIGTERM)
except OSError:
#other isn't running
pass
except IOError:
# first ever run
pass
with open(pid_file, 'w') as fp:
fp.write(str(os.getpid()))
osds, windows = display_osd(options)
disp = Display()
root = disp.screen().root
root.change_attributes(event_mask = X.KeyPressMask)
root.grab_keyboard(False, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime)
event = disp.next_event()
keycode = event.detail
if event.type == X.KeyPress:
key = XK.keysym_to_string(disp.keycode_to_keysym(keycode, 0))
if key and key in string.lowercase and string.lowercase.index(key) < len(windows):
windows[string.lowercase.index(key)].activate(timestamp)
disp.ungrab_keyboard(X.CurrentTime)
sys.exit()
def __init__(self, *args, **kwargs) -> None:
self.zones = []
self.display = Display()
self.screen = self.display.screen()
if count := kwargs.get("-n"):
self.add(count)
def _init_xlib(self):
"""Setup python-xlib components in the PyGTK event loop"""
self.xdisp = Display()
self.xroot = self.xdisp.screen().root
# We want to receive KeyPress events
self.xroot.change_attributes(event_mask=X.KeyPressMask)
# unrecognized shortkeys now will be looked up in a hardcoded dict
# and replaced by valid names like ',' -> 'comma'
# while generating the self.keys dict
self.keys = dict()
for key in self._keys:
transKey = key
if key in KEYLOOKUP:
transKey = KEYLOOKUP[key]
code = self.xdisp.keysym_to_keycode(string_to_keysym(transKey))
self.keys[code] = self._keys[key]
# Resolve strings to X11 mask constants for the modifier mask
try:
modmask = reduce(operator.ior,
[getattr(X, "%sMask" % x) for x in self._modkeys])
self._movemodmask = reduce(
operator.ior,
[getattr(X, "%sMask" % x) for x in self._movemodkeys])
except Exception, err:
logging.error("Error while resolving modifier key mask: %s", err)
logging.error("Not binding keys for safety reasons. "
"(eg. What if Ctrl+C got bound?)")
modmask = 0
movemodmask = 0
def connectToX(self):
self.display = Display(self.displayStr)
self.displayWidth = self.display.screen().width_in_pixels
self.displayHeight = self.display.screen().height_in_pixels
self.rect = Rect(0, 0, self.displayWidth, self.displayHeight)
def main(argv):
display = Display()
if not display.has_extension('XFIXES'):
if display.query_extension('XFIXES') is None:
print('XFIXES extension not supported', file=sys.stderr)
return 1
xfixes_version = display.xfixes_query_version()
print('Found XFIXES version %s.%s' % (
xfixes_version.major_version,
xfixes_version.minor_version,
),
file=sys.stderr)
screen = display.screen()
print('Hiding cursor ...', file=sys.stderr)
screen.root.xfixes_hide_cursor()
display.sync()
time.sleep(5)
print('Showing cursor ...', file=sys.stderr)
screen.root.xfixes_hide_cursor()
display.sync()
def test_move(self):
for size in screen_sizes:
with Display(visible=VISIBLE, size=size):
mouse = PyMouse()
for p in positions:
mouse.move(*p)
eq_(expect_pos(p, size), mouse.position())
def __init__(self):
display = Display()
#get base window handle
root = display.screen().root
self.dsp = display
self.rt = root
#traverse windows and find the runescape window by name
self.window = findWindowByName(root, "Old School RuneScape")
if (self.window == 0):
print("Cant find Oldschool Runescape window")
sys.exit(0)
#resize the window to set dimensions, all of the in game GUI offsets are hardcoded
self.window.configure(width=800, height=600)
#wait till the window is resized (I know)
time.sleep(5)
self.frame = 0
self.inv = 0
self.map = 0
self.ga = 0
self.txt = 0
self.ctrGac = (246, 165)
#ingame GUI offsets
#game area (game world window)
self.gac = (20, 4, 511, 333)
#inventory
self.invc = (567, 208, 746, 463)
#map
self.mapc = (582, 3, 727, 157)
#text/chat area
self.txtc = (21, 341, 507, 452)
def start(self):
mod = self.MOD_MASK
dpy = Display()
keys = {}
for key, name in self.KEY_MAP.items():
keys[key] = dpy.keysym_to_keycode(XK.string_to_keysym(key))
root = dpy.screen().root
for key, code in keys.items():
root.grab_key(code, mod, 1, X.GrabModeAsync, X.GrabModeAsync)
root.grab_button(
1, mod, 1,
X.ButtonPressMask | X.ButtonReleaseMask | X.PointerMotionMask,
X.GrabModeAsync, X.GrabModeAsync, X.NONE, X.NONE)
root.grab_button(
3, mod, 1,
X.ButtonPressMask | X.ButtonReleaseMask | X.PointerMotionMask,
X.GrabModeAsync, X.GrabModeAsync, X.NONE, X.NONE)
self.dpy = dpy
self.keys = keys
self.root = root
self.WM_PROTOCOLS = dpy.intern_atom("WM_PROTOCOLS")
self.WM_DELETE_WINDOW = dpy.intern_atom("WM_DELETE_WINDOW")
self._loop()
def __init__(self, name, queue):
super(KeyboardAndMouseWatcher, self).__init__(name, queue)
self._queue = queue
self._mouse_last_x = None
self._mouse_last_y = None
if _platform.startswith("linux"):
self._display = Display()
def main(argv):
global timer, is_run_active, args, min_distance
with FileLock("mousy.lock", timeout=0.3):
log("Lock acquired.") # avoid multiple runs the same time
min_distance = args.distance
start_reset_timer()
display = Display()
try:
extension_info = display.query_extension('XInputExtension')
version_info = display.xinput_query_version()
log('Found XInput version %u.%u' % (
version_info.major_version,
version_info.minor_version,
))
screen = display.screen()
screen.root.xinput_select_events([(xinput.AllDevices,
xinput.MotionMask)])
while is_run_active:
try:
event = display.next_event()
x = event.data.root_x
y = event.data.root_y
handle(x, y)
except KeyboardInterrupt as e:
log("interrupted")
finally:
display.close()
def run(self):
# Run until user clicks on exit iconTray
if _platform == 'Linux':
# Get root screen
root = Display().screen().root
# Add key grabber for 'print'
root.grab_key(PRINT_KEY_ID_LINUX, X.Mod2Mask, 0, X.GrabModeAsync,
X.GrabModeAsync)
# Create a loop to keep the application running
while True:
event = root.display.next_event()
self.OnKeyboardEvent(event)
time.sleep(0.1)
elif _platform == 'Windows':
# create a hook manager
hm = HookManager()
# watch for all mouse events
hm.KeyDown = self.OnKeyboardEvent
# set the hook
hm.HookKeyboard()
# wait forever
while True:
pc.PumpWaitingMessages()
time.sleep(0.1)
#print('Hotkey thread waiting..')
print('Closing HookManager')
del hm
def main(argv):
display = Display()
try:
extension_info = display.query_extension('XInputExtension')
xinput_major = extension_info.major_opcode
version_info = display.xinput_query_version()
print('Found XInput version %u.%u' % (
version_info.major_version,
version_info.minor_version,
))
screen = display.screen()
screen.root.xinput_select_events([
(xinput.AllDevices, xinput.HierarchyChangedMask),
])
while True:
event = display.next_event()
if (event.type == display.extension_event.GenericEvent
and event.extension == xinput_major
and event.evtype == 11):
print_hierarchy_changed_event(event)
finally:
display.close()
def __init__(self, xdisplay=None):
"""Connect to X11 and the Glib event loop.
@param xdisplay: A C{python-xlib} display handle.
@type xdisplay: C{Xlib.display.Display}
"""
self.xdisp = xdisplay or Display()
self.xroot = self.xdisp.screen().root
self._keys = {}
# Resolve these at runtime to avoid NameErrors
self.ignored_modifiers = [
getattr(X, name) for name in self.ignored_modifiers
]
# We want to receive KeyPress events
self.xroot.change_attributes(event_mask=X.KeyPressMask)
# Set up a handler to catch XGrabKey() failures
self.xdisp.set_error_handler(self.handle_xerror)
# Merge python-xlib into the Glib event loop
# Source: http://www.pygtk.org/pygtk2tutorial/sec-MonitoringIO.html
gobject.io_add_watch(self.xroot.display, gobject.IO_IN,
self.handle_xevent)
def __init__(self):
self._display = Display()
self._run_times = {}
self._last_pointer_move = 0
self._last_zoom = 0
self._last_zoom_distance = -1
self._activities_key = self._display.keysym_to_keycode(XK.XK_Super_L)
def main():
disp = Display()
while 1:
keymap = disp.query_keymap()
if keymap not in ignorelist:
KeyPress().start()
time.sleep(0.08)
def getWindows():
"""Return dict: {'window title' : window id} for all visible windows"""
titles = {}
display = Display()
root = display.screen().root
win_list = root.get_full_property(NET_CLIENT_LIST, X.AnyPropertyType).value
for win_id in win_list:
window = display.create_resource_object('window', win_id)
class_list = window.get_wm_class()
"""
get_wm_name() method unable to handle utf-8 characters, thats why
below window title gets from property and decoding instead of using
one short Window method that provided by python xlib
"""
try:
win_name = window.get_full_property(NET_WM_NAME,
X.AnyPropertyType).value
except:
pass
if win_name:
try:
win_name = win_name.decode("utf-8")
except:
pass
titles[win_name] = win_id
else:
titles[class_list[1]] = win_id
return titles
def __init__(self, keymap=None, listen_events=None):
"""
:param dict keymap: Key name to function mapping.
Example:
.. code-block:: python
def do(): print('do')
{
'Ctrl-K': do,
'1': None, # Just intercept.
}
:param int listen_events: X Events or a combination of them.
Examples:
* Xlib.X.KeyPressMask
* Xlib.X.KeyPressMask | Xlib.X.ButtonReleaseMask
"""
from Xlib import X, XK
from Xlib.display import Display
self.x = X
self.xk = XK
self.disp = Display()
self.screen = self.disp.screen().root
self.events = listen_events or self.x.KeyPressMask
self.keymap = keymap or {}
self.mapped = {}
def __init__(self):
GObject.GObject.__init__(self)
threading.Thread.__init__(self)
self.setDaemon(True)
self.display = Display()
self.root = self.display.screen().root
self.windows = []
def main():
disp = Display()
screen = disp.screen()
root = screen.root
# First listen for existing windows
for window in root.query_tree().children:
if is_inkscape(window):
print('Found existing window')
listen = threading.Thread(target=create, args=[window.id])
listen.start()
# New windows
root.change_attributes(event_mask=X.SubstructureNotifyMask)
while True:
evt = disp.next_event()
if evt.type == X.CreateNotify:
window = evt.window
try:
if is_inkscape(window):
print('New window!')
listen = threading.Thread(target=create, args=[window.id])
listen.start()
except Xlib.error.BadWindow:
pass
def main(argv):
globals()['display'] = Display()
for arg in argv:
try:
if arg == '--version':
print("%s v%s" % (NAME, VERSION))
elif arg == '--print-active-window-id':
print("0x%x" % Window.get_active_window_id())
elif arg == '--print-active-window-info':
print_active_window_info()
elif arg == '--print-window-info':
print_window_info()
elif arg == '--print-monitor-info':
print_monitor_info()
elif match(MOVE_REGEX, arg):
p = compile(MOVE_REGEX)
wid, width, height, x, y = p.findall(arg)[0]
w = Window.from_id(int(wid, 16), False)
w.move(int(x), int(y), int(width), int(height))
except:
print("Unexpected error:", exc_info()[0])
display.sync()
display.flush()
display.close()
def main():
### Initialize
fw.init()
### Rift
monitor = get_rift()
win = CbWindow(640, 480, 'pyglfw')
win.make_current()
# XWindows...
d = Display()
root = d.screen().root
pixmap = root.create_pixmap(256, 256, 8)
# glXCreateWindow(d, cfg, pixmap, 0)
while not win.should_close:
render()
win.swap_buffers()
fw.poll_events()
if win.keys.escape:
win.should_close = True
fw.terminate()
def run(self):
disp = Display()
self.root = disp.screen().root
# we tell the X server we want to catch keyPress event
self.root.change_attributes(event_mask=X.KeyPressMask)
#for keycode in [38]:
#self.root.grab_key(keycode, X.AnyModifier, 1,X.GrabModeAsync, X.GrabModeAsync)
self.root.grab_key(38, X.Mod1Mask, 1, X.GrabModeAsync, X.GrabModeAsync)
# Alt+a
while self.signal:
event = self.root.display.next_event()
if (event.type == X.KeyPress) and check_hotkey(['alt'], 38, event):
if root.winfo_viewable():
root.withdraw()
recentlyfiles.refresh_items()
else:
refresh_listbox()
entry.focus_set()
command.set('')
root.deiconify()
self.windows_state = not self.windows_state
def __init__(self, args=None):
command = ['trayer']
self.default_args = {
'edge': 'top',
'align': 'right',
'widthtype': 'request',
'expand': 'true',
'SetDockType': 'true',
'transparent': 'true',
'alpha': '0',
'height': '16',
'margin': '0',
'tint': '0x29b2e',
}
if args is not None:
self.default_args.update(args)
for key, val in self.default_args.items():
command += ["--%s" % (key), str(val)]
super(TrayerWatch, self).__init__(command)
self.proc.stdin.close()
self.proc.stdout.close()
# search for running trayer window
self.display = Display()
root = self.display.screen().root
self.trayer = self.find_tray_window(root)
assert self.trayer is not None, 'Panel not found!'
# activate ConfigureNotify-Events for self.trayer
self.trayer.change_attributes(event_mask=X.StructureNotifyMask)
