def send_string(str) : for ch in str : #print "sending", ch, "=", display.keysym_to_keycode(Xlib.XK.string_to_keysym(ch)) keycode, shift_mask = char_to_keycode(ch) if (UseXTest) : #print "Trying fake_input of", ch, ", shift_mask is", shift_mask if shift_mask != 0 : Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, 50) Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, keycode) Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, keycode) if shift_mask != 0 : Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, 50) else : event = Xlib.protocol.event.KeyPress( time = int(time.time()), root = display.screen().root, window = window, same_screen = 0, child = Xlib.X.NONE, root_x = 0, root_y = 0, event_x = 0, event_y = 0, state = shift_mask, detail = keycode ) window.send_event(event, propagate = True) event = Xlib.protocol.event.KeyRelease( time = int(time.time()), root = display.screen().root, window = window, same_screen = 0, child = Xlib.X.NONE, root_x = 0, root_y = 0, event_x = 0, event_y = 0, state = shift_mask, detail = keycode ) window.send_event(event, propagate = True)
def _suppress_start(self, display): display.screen().root.grab_keyboard( self._event_mask, Xlib.X.GrabModeAsync, Xlib.X.GrabModeAsync, Xlib.X.CurrentTime, )
def send_string(str) : """I am not working. I dont know why:(""" for ch in str : #print "sending", ch, "=", display.keysym_to_keycode(Xlib.XK.string_to_keysym(ch)) keycode, shift_mask = char_to_keycode(ch) event = Xlib.protocol.event.KeyPress( time = int(time.time()), root = display.screen().root, window = window, same_screen = 0, child = Xlib.X.NONE, root_x = 0, root_y = 0, event_x = 0, event_y = 0, state = shift_mask, detail = keycode ) window.send_event(event, propagate = True) event = Xlib.protocol.event.KeyRelease( time = int(time.time()), root = display.screen().root, window = window, same_screen = 0, child = Xlib.X.NONE, root_x = 0, root_y = 0, event_x = 0, event_y = 0, state = shift_mask, detail = keycode ) window.send_event(event, propagate = True)
def send_string(str): """I am not working. I dont know why:(""" for ch in str: #print "sending", ch, "=", display.keysym_to_keycode(Xlib.XK.string_to_keysym(ch)) keycode, shift_mask = char_to_keycode(ch) event = Xlib.protocol.event.KeyPress(time=int(time.time()), root=display.screen().root, window=window, same_screen=0, child=Xlib.X.NONE, root_x=0, root_y=0, event_x=0, event_y=0, state=shift_mask, detail=keycode) window.send_event(event, propagate=True) event = Xlib.protocol.event.KeyRelease(time=int(time.time()), root=display.screen().root, window=window, same_screen=0, child=Xlib.X.NONE, root_x=0, root_y=0, event_x=0, event_y=0, state=shift_mask, detail=keycode) window.send_event(event, propagate=True)
def _suppress_start(self, display): display.screen().root.grab_pointer( True, self._event_mask, Xlib.X.GrabModeAsync, Xlib.X.GrabModeAsync, 0, 0, Xlib.X.CurrentTime, )
def widget_load_config(self, plugman): self.load_config(plugman) if self.desktop == "Full": self.desktopButton.setChecked(True) elif self.desktop == "Area": self.areaButton.setChecked(True) elif self.desktop == "Window": self.windowButton.setChecked(True) # Xlib is only available on linux if sys.platform.startswith("linux"): display = Xlib.display.Display() self.screenSpinBox.setMaximum(display.screen_count() - 1) # minus 1 since we like to start count at 0 root = display.screen().root windows = root.query_tree().children uniq_wins = [] n = 0 for win in windows: win_name = win.get_wm_name() if win_name not in uniq_wins and win_name is not None: uniq_wins.append(win_name) self.windowList.addItem(win_name) if win_name == self.window: self.windowList.setCurrentIndex(n) n = n + 1
def get_idle_time(): """get idle time from X server""" display = Xlib.display.Display() info = display.query_extension(EXTNAME) display.display.set_extension_major(EXTNAME, info.major_opcode) millis = screen_saver_query_info(display.screen().root).idle_time return datetime.timedelta(milliseconds=millis)
def change_workspace(name): print(f"Changing to {name}", flush=True) display = Xlib.display.Display() screen = display.screen() root = screen.root w, h = screen.width_in_pixels, screen.height_in_pixels try: hue = int(name)/10+1/3 except: hue = mkrand(name).random() if name not in colors: colors[name] = gen_colors(hue) proc = subprocess.Popen(["xrdb", "-merge"], stdin=subprocess.PIPE) proc.communicate(input=colors[name].encode()) proc.wait() i3.command("reload") if (name, w, h) not in backgrounds: backgrounds[name, w, h] = root.create_pixmap(w, h, screen.root_depth) gen_bg(backgrounds[name, w, h], hue, name) id = backgrounds[name, w, h].id root.change_property(display.get_atom("_XROOTPMAP_ID"), Xatom.PIXMAP, 32, [id]) root.change_property(display.get_atom("ESETROOT_PMAP_ID"), Xatom.PIXMAP, 32, [id]) root.change_attributes(background_pixmap=id) root.clear_area(0, 0, w, h) display.sync()
def send_event(client_id, keystate, shiftstate, keycode): display = Xlib.display.Display() Xlib_root_window = display.screen().root window = display.create_resource_object('window', client_id) if keystate == 2: XEVENT = Xlib.protocol.event.KeyPress elif keystate == 3: XEVENT = Xlib.protocol.event.KeyRelease else: raise event = XEVENT(time=int(time.time()), root=Xlib_root_window, window=window, same_screen=0, child=Xlib.X.NONE, root_x=0, root_y=0, event_x=0, event_y=0, state=shiftstate, detail=keycode) display.sync() p = window.send_event(event, propagate=False) display.sync() display.close() return True
def get_outputs(display): """Get collection of display outputs :returns: array of display output objects """ root = display.screen().root resources = root.xrandr_get_screen_resources()._data primaryOutput = root.xrandr_get_output_primary().output outputs = [] for output in resources['outputs']: _data = display.xrandr_get_output_info( output, resources['config_timestamp'])._data x = y = 0 if _data['crtc']: crtcInfo = display.xrandr_get_crtc_info( _data['crtc'], resources['config_timestamp']) x = crtcInfo.x y = crtcInfo.y outputs.append({ 'isPrimary': output == primaryOutput, 'name': _data['name'], 'connected': not _data['connection'], 'dissabled': not _data['crtc'], 'x': x, 'y': y }) return outputs
def get_windows(display, name): root_win = display.screen().root window_list = [root_win] windows = [] while len(window_list) != 0: win = window_list.pop(0) if win.get_wm_name() == name: windows.append(win) elif win.get_wm_name() == None: children = win.query_tree().children if children != None: window_list += children continue return windows # TODO why is this still here? # not using this anymore, dont think if win.get_wm_name().find(name) != -1: return win children = win.query_tree().children if children != None: window_list += children print('Unable to find window matching - %s\n' % name) sys.exit(1)
def screen_resolution(): """ Returns the current screen's resolution. Should be multi-platform. :return: A tuple containing the width and height of the screen. """ w = 0 h = 0 try: # Windows import ctypes user32 = ctypes.windll.user32 w, h = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1) except AttributeError: try: # Mac OS X import AppKit size = AppKit.NSScreen.screens()[0].frame().size w, h = int(size.width), int(size.height) except ImportError: try: # Linux import Xlib import Xlib.display display = Xlib.display.Display() root = display.screen().root size = root.get_geometry() w, h = size.width, size.height except ImportError: w = 1920 h = 1080 return w, h
def _is_active_window_fullscreen(self, display): root = display.screen().root net_active_window = display.intern_atom('_NET_ACTIVE_WINDOW') net_wm_state = display.intern_atom('_NET_WM_STATE') net_wm_state_fullscreen = display.intern_atom( '_NET_WM_STATE_FULLSCREEN') active_win_id = root.get_full_property(net_active_window, Xlib.X.AnyPropertyType) if not active_win_id: return False active_win_id = active_win_id.value[0] active_win = display.create_resource_object('window', active_win_id) wm_state = active_win.get_full_property(net_wm_state, Xlib.X.AnyPropertyType) if not wm_state: return False wm_state = wm_state.value return net_wm_state_fullscreen in wm_state
def pick_coordinate(display, cursor): """Changes the cursor and grabs the pointer for every window. Args: display: Xlib display cursor: cursor object or X.NONE """ try: display.screen().root.grab_pointer( 0, X.PointerMotionMask | X.ButtonReleaseMask | X.ButtonPressMask, X.GrabModeAsync, X.GrabModeAsync, X.NONE, cursor, X.CurrentTime) display.flush() yield finally: display.ungrab_pointer(0) display.flush()
def __init__(self): self.sct = mss() display = Xlib.display.Display() root = display.screen().root windowIDs = root.get_full_property(display.intern_atom('_NET_CLIENT_LIST'), Xlib.X.AnyPropertyType).value for windowID in windowIDs: window = display.create_resource_object('window', windowID) name = window.get_wm_name() # Title if 'Dolphin 5.0 |' in str(name): geometry = window.get_geometry() self.width = geometry.__getattr__('width') self.height = geometry.__getattr__('height') self.x = 0 self.y = 0 tree = window.query_tree() parent = tree.__getattr__('parent') while parent is not 0: geometry = parent.get_geometry() self.x += geometry.__getattr__('x') self.y += geometry.__getattr__('y') parent_tree = parent.query_tree() parent = parent_tree.__getattr__('parent')
def get_window_by_gtk_application_id_xlib(gtk_application_id): ''' Function to get window using the gtk_application_id from NET_WM ''' import Xlib import Xlib.display display = Xlib.display.Display() root = display.screen().root NET_CLIENT_LIST = display.intern_atom('_NET_CLIENT_LIST') GTK_APPLICATION_ID = display.intern_atom('_GTK_APPLICATION_ID') root.change_attributes(event_mask=Xlib.X.FocusChangeMask) try: window_id = root.get_full_property(NET_CLIENT_LIST, Xlib.X.AnyPropertyType).value for id in window_id: window = display.create_resource_object('window', id) window.change_attributes(event_mask=Xlib.X.PropertyChangeMask) if window.get_full_property(GTK_APPLICATION_ID, 0): if window.get_full_property( GTK_APPLICATION_ID, 0).value.decode("utf-8") == gtk_application_id: break except Xlib.error.XError: #simplify dealing with BadWindow window = None return window
def __init__(self): QtCore.QThread.__init__(self) display = Xlib.display.Display() self.root = display.screen().root self.root.change_attributes(event_mask=Xlib.X.KeyPressMask) # set keyboard shortcut to "c" self.root.grab_key(54, Xlib.X.Mod4Mask, 0, Xlib.X.GrabModeAsync, Xlib.X.GrabModeAsync)
def get(): import Xlib import Xlib.display display = Xlib.display.Display() root = display.screen().root geom = root.get_geometry() return (geom.width, geom.height)
def send_key(keycode, shift_down, ctrl_down, alt_down, meta_down): print "send_key", keycode, shift_down, ctrl_down, alt_down, meta_down if UseXTest: Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, keycode) Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, keycode) else: mod_mask = 0 if shift_down: mod_mask |= Xlib.X.ShiftMask if ctrl_down: mod_mask |= Xlib.X.ControlMask # I don't know which masks alt and meta/windows correspond to; # these are just guesses. if alt_down: mod_mask |= Xlib.X.Mod1Mask if meta_down: mod_mask |= Xlib.X.Mod2Mask window = display.get_input_focus()._data["focus"] event = Xlib.protocol.event.KeyPress(time=int(time.time()), root=display.screen().root, window=window, same_screen=0, child=Xlib.X.NONE, root_x=0, root_y=0, event_x=0, event_y=0, state=mod_mask, detail=keycode) window.send_event(event, propagate=True) event = Xlib.protocol.event.KeyRelease(time=int(time.time()), root=display.screen().root, window=window, same_screen=0, child=Xlib.X.NONE, root_x=0, root_y=0, event_x=0, event_y=0, state=mod_mask, detail=keycode) window.send_event(event, propagate=True)
def main(): display = Xlib.display.Display(':0') root = display.screen().root root.change_attributes(event_mask= Xlib.X.ButtonPressMask | Xlib.X.ButtonReleaseMask) while True: event = root.display.next_event() print event
def getWindowName(self): display = Xlib.display.Display() root = display.screen().root windowID = root.get_full_property( display.intern_atom('_NET_ACTIVE_WINDOW'), Xlib.X.AnyPropertyType).value[0] window = display.create_resource_object('window', windowID) return window.get_wm_class()[1]
def reset(display, win): win.set_wm_normal_hints( flags = Xutil.PWinGravity, win_gravity = X.NorthWestGravity) atom = lambda s: display.intern_atom(s) send_event(display.screen().root, win, atom("_NET_WM_STATE"), [0, atom("_NET_WM_STATE_MAXIMIZED_VERT"), atom("_NET_WM_STATE_MAXIMIZED_HORZ")]) display.flush()
def main(): display = Xlib.display.Display(':0') root = display.screen().root root.change_attributes(event_mask=Xlib.X.ButtonPressMask | Xlib.X.ButtonReleaseMask) while True: event = root.display.next_event() print event
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 open_x(screen_no = None): ''' Open connection the X and select screen @param screen_no:int? The index of the screen to use, `None` for default ''' global display, screen, screen_i display = Xlib.display.Display() screen_i = screen_no if screen_no is not None else display.get_default_screen() screen = display.screen(screen_i)
def get_active_window_id(): import Xlib import Xlib.display display = Xlib.display.Display() root = display.screen().root windowID = root.get_full_property( display.intern_atom('_NET_ACTIVE_WINDOW'), Xlib.X.AnyPropertyType).value[0] return windowID
def open_x(screen_no=None): ''' Open connection the X and select screen @param screen_no:int? The index of the screen to use, `None` for default ''' global display, screen, screen_i display = Xlib.display.Display() screen_i = screen_no if screen_no is not None else display.get_default_screen( ) screen = display.screen(screen_i)
def send_key(keycode, shift_down, ctrl_down, alt_down, meta_down): print "send_key", keycode, shift_down, ctrl_down, alt_down, meta_down if UseXTest: Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, keycode) Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, keycode) else: mod_mask = 0 if shift_down: mod_mask |= Xlib.X.ShiftMask if ctrl_down: mod_mask |= Xlib.X.ControlMask # I don't know which masks alt and meta/windows correspond to; # these are just guesses. if alt_down: mod_mask |= Xlib.X.Mod1Mask if meta_down: mod_mask |= Xlib.X.Mod2Mask window = display.get_input_focus()._data["focus"] event = Xlib.protocol.event.KeyPress( time = int(time.time()), root = display.screen().root, window = window, same_screen = 0, child = Xlib.X.NONE, root_x = 0, root_y = 0, event_x = 0, event_y = 0, state = mod_mask, detail = keycode ) window.send_event(event, propagate = True) event = Xlib.protocol.event.KeyRelease( time = int(time.time()), root = display.screen().root, window = window, same_screen = 0, child = Xlib.X.NONE, root_x = 0, root_y = 0, event_x = 0, event_y = 0, state = mod_mask, detail = keycode ) window.send_event(event, propagate = True)
def __init__(self, display, margin, size, size_border, color=(0, 0, 0)): self._last_color = color self._display = display self._screen = display.screen() self._root = self._screen.root self.margin = margin + int(size / 2) self.size = size self.size_border = size_border self._wnd = None self._gc = None res = self._root.get_geometry() self.screen_width, self.screen_height = res.width, res.height
def find_xid(display, title): root = display.screen().root window_ids = root.get_full_property( display.intern_atom('_NET_CLIENT_LIST'), Xlib.X.AnyPropertyType).value for window_id in window_ids: window = display.create_resource_object('window', window_id) name = window.get_full_property(display.intern_atom('_NET_WM_NAME'), Xlib.X.AnyPropertyType).value if title in name: return window_id return None
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 send_string(str): for ch in str: #print "sending", ch, "=", display.keysym_to_keycode(Xlib.XK.string_to_keysym(ch)) keycode, shift_mask = char_to_keycode(ch) if (UseXTest): #print "Trying fake_input of", ch, ", shift_mask is", shift_mask if shift_mask != 0: Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, 50) Xlib.ext.xtest.fake_input(display, Xlib.X.KeyPress, keycode) Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, keycode) if shift_mask != 0: Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, 50) else: event = Xlib.protocol.event.KeyPress(time=int(time.time()), root=display.screen().root, window=window, same_screen=0, child=Xlib.X.NONE, root_x=0, root_y=0, event_x=0, event_y=0, state=shift_mask, detail=keycode) window.send_event(event, propagate=True) event = Xlib.protocol.event.KeyRelease(time=int(time.time()), root=display.screen().root, window=window, same_screen=0, child=Xlib.X.NONE, root_x=0, root_y=0, event_x=0, event_y=0, state=shift_mask, detail=keycode) window.send_event(event, propagate=True)
def invalidate(self): ''' Cause the window to be redraw on the main window ''' # Dummy event for performing update in the main thread # TODO do this better e = Xlib.protocol.event.KeyPress(detail = 1, time = Xlib.X.CurrentTime, root = display.screen().root, window = self.window, child = Xlib.X.NONE, root_x = 1, root_y = 1, event_x = 1, event_y = 1, state = 0, same_screen = 1) display.send_event(self.window, e) display.flush()
def main(): args = parse_args() ckb = CKBPipe(args.ckb_pipe) display = Xlib.display.Display() atom = display.intern_atom('_NET_CURRENT_DESKTOP', True) window = display.screen().root highlight_current_workspace(ckb, window, atom) window.change_attributes(event_mask=X.PropertyChangeMask) while True: ev = display.next_event() if ev.type == X.PropertyNotify and ev.state == X.PropertyNewValue and ev.window == window and ev.atom == atom: highlight_current_workspace(ckb, window, atom)
def getWindows(): o={} display = Xlib.display.Display() root = display.screen().root children = _findWindows(display,root) for win in children: try: winObj=_parseWindow(display,win) winName=winObj["name"] winPids=winObj["pids"] if not winName in o: o[winName]=[] for p in winPids: o[winName].append(p) except: pass return o
def __init__(self,ui,h,s,v): ''' Constructor ''' self.h_motion_range=h self.s_motion_range=s self.v_motion_range=v self.h_click_range=h self.s_click_range=s self.v_click_range=v self.ui=ui ui.h_spinBox.setValue(self.h_motion_range) ui.s_spinBox.setValue(self.s_motion_range) ui.v_spinBox.setValue(self.v_motion_range) ui.h_spinBox1.setValue(self.h_click_range) ui.s_spinBox1.setValue(self.s_click_range) ui.v_spinBox1.setValue(self.v_click_range) ui.smooth_slide.setValue(self.mousesmoothness) ui.clickstvt_slide.setValue(self.clicksensitivity) display = Xlib.display.Display(':0') #print display.screen_count() # output: 1 root = display.screen().root #print root.get_geometry().width # output: 2960 -> no way to get width of single display? #print root.get_geometry().height #get screen size self.screensize_x=root.get_geometry().width self.screensize_y=root.get_geometry().height ### Click Sound initialising #pygame.mixer.init() #self.click_sound = pygame.mixer.Sound("click.wav") self.ui.log_txt.insertHtml("Set motion color and click color to start.<br>") pass
def waitClick(): display = Xlib.display.Display(':0') root = display.screen().root root.grab_pointer(1, X.ButtonReleaseMask,X.GrabModeAsync, X.GrabModeAsync, X.NONE,X.NONE, X.CurrentTime) while 1: event = root.display.next_event() if event.type==X.ButtonRelease: if len(sys.argv)==1: color=getColor(1) else: ctype=sys.argv[1] color=getColor(int(ctype)) copy2Clipboard(color); print color sys.exit()
def release_key(keysym, shift_mask = 0) : keycode = display.keysym_to_keycode(keysym) if (UseXTest) : Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, keycode) if shift_mask != 0 : Xlib.ext.xtest.fake_input(display, Xlib.X.KeyRelease, 50) else : event = Xlib.protocol.event.KeyRelease( time = int(time.time()), root = display.screen().root, window = window, same_screen = 0, child = Xlib.X.NONE, root_x = 0, root_y = 0, event_x = 0, event_y = 0, state = shift_mask, detail = keycode ) window.send_event(event, propagate = True) display.sync()
def invalidate(self): ''' Cause the window to be redraw on the main window ''' # Dummy event for performing update in the main thread # TODO do this better e = Xlib.protocol.event.KeyPress(detail=1, time=Xlib.X.CurrentTime, root=display.screen().root, window=self.window, child=Xlib.X.NONE, root_x=1, root_y=1, event_x=1, event_y=1, state=0, same_screen=1) display.send_event(self.window, e) display.flush()
def get_active_window_id_xlib(): ''' Function to get active window ''' import Xlib import Xlib.display display = Xlib.display.Display() root = display.screen().root NET_ACTIVE_WINDOW = display.intern_atom('_NET_ACTIVE_WINDOW') root.change_attributes(event_mask=Xlib.X.FocusChangeMask) try: window_id = root.get_full_property(NET_ACTIVE_WINDOW, Xlib.X.AnyPropertyType).value[0] except Xlib.error.XError: #simplify dealing with BadWindow window_id = None return window_id
def main(): display = Xlib.display.Display() root = display.screen().root root.change_attributes(event_mask = X.KeyReleaseMask) screen = wnck.screen_get_default() screen.force_update() (root_width, root_height) = (screen.get_width(), screen.get_height() - PANEL_HEIGHT) for keysym in KEYMAP: if keysym == XK.XK_Num_Lock: modifier_mask = 0 elif keysym < XK.XK_KP_1: modifier_mask = KEY_MODIFIER_MASK else: modifier_mask = PAD_MODIFIER_MASK root.grab_key(display.keysym_to_keycode(keysym), modifier_mask, True, X.GrabModeAsync, X.GrabModeAsync) check_num_lock() while True: event = root.display.next_event() run_idle() if event.type == X.KeyRelease: run_idle() (root_width, root_height) = (screen.get_width(), screen.get_height() - PANEL_HEIGHT) w = screen.get_active_window() for i in range(4): try: func = KEYMAP[display.keycode_to_keysym(event.detail, i)] break except KeyError: continue else: raise x, y, width, height = w.get_geometry() y -= PANEL_HEIGHT g = func(w, (root_width, root_height), (x, y, width, height)) if g is not None: print w.get_name(), (x, y, width, height), g w.set_geometry(0, 15, g[0], g[1], g[2], g[3]) run_idle()
def waitClick(): display = Xlib.display.Display(':0') root = display.screen().root root.grab_pointer(1, X.ButtonReleaseMask, X.GrabModeAsync, X.GrabModeAsync, X.NONE, X.NONE, X.CurrentTime) while 1: event = root.display.next_event() if event.type == X.ButtonRelease: if len(sys.argv) == 1: color = getColor(1) else: ctype = sys.argv[1] color = getColor(int(ctype)) copy2Clipboard(color) print color sys.exit()
def _diff_window_is_open(left_path, right_path): """Return True if PyCharm is currently showing a diff window for the given paths. The search iterates over all windows managed by X and examines the properties / atoms. The window must have "jetbrains" as part of one or more classes and have "{left_path} vs {right_path}" as part of its window name. """ display = Xlib.display.Display() net_wm_name = display.intern_atom("_NET_WM_NAME") # Modern, UTF-8 wm_name = display.intern_atom("WM_NAME") # Legacy title_str = "{} vs {}".format( os.path.split(left_path)[1], os.path.split(right_path)[1]) def find_diff_window(window): for w in window.query_tree().children: if find_diff_window(w): return True else: if any(["jetbrains" in c for c in w.get_wm_class() or []]): if title_str in get_window_name(w) or '': return True return False def get_window_name(window_id): """Return window title if one can be found or None.""" for atom in (net_wm_name, wm_name): window_obj = display.create_resource_object("window", window_id) name_str = window_obj.get_full_property(atom, 0).value if isinstance(name_str, bytes): return name_str.decode("latin1", "replace") return name_str try: return find_diff_window(display.screen().root) except ( Xlib.error.XError, Xlib.error.BadWindow, UnicodeDecodeError, AttributeError, ): return False
def change_workspace(name): display = Xlib.display.Display() screen = display.screen() root = screen.root w, h = screen.width_in_pixels, screen.height_in_pixels if (name, w, h) not in background_cache: background_cache[name, w, h] = gen_bg( root.create_pixmap(w, h, screen.root_depth), name) id = background_cache[name, w, h].id root.change_property(display.get_atom("_XROOTPMAP_ID"), Xatom.PIXMAP, 32, [id]) root.change_property(display.get_atom("ESETROOT_PMAP_ID"), Xatom.PIXMAP, 32, [id]) root.change_attributes(background_pixmap=id) root.clear_area() display.sync()
def getWindowIDFromString(self, window_name): root = display.screen().root windowIDs = root.get_full_property( display.intern_atom('_NET_CLIENT_LIST'), Xlib.X.AnyPropertyType).value for windowID in windowIDs: window = display.create_resource_object('window', windowID) if window_name in window.get_wm_name(): window_width = window.get_geometry().width window_heigth = window.get_geometry().height raw = window.get_image(0, 0, window_width, window_heigth, X.ZPixmap, 0xffffffff) image = Image.frombytes("RGB", (window_width, window_heigth), raw.data, "raw", "BGRX") image.show()
def get_selection(): display = Xlib.display.Display() xsel_data_atom = display.intern_atom("XSEL_DATA") screen = display.screen() w = screen.root.create_window(0, 0, 2, 2, 0, screen.root_depth) w.convert_selection(Xlib.Xatom.PRIMARY, Xlib.Xatom.STRING, xsel_data_atom, Xlib.X.CurrentTime) while True: e = display.next_event() if e.type == Xlib.X.SelectionNotify: break assert e.property == xsel_data_atom assert e.target == Xlib.Xatom.STRING reply = w.get_full_property(xsel_data_atom, Xlib.X.AnyPropertyType) return reply.value
def send_string(window, str): for ch in str : keycode, shift_mask = char_to_keycode(ch) if keycode == 0: keycode, shift_mask = char_to_keycode('_') print 'sending [{0!r}] keycode={1} with shift_mask={2}'.format( ch, keycode, shift_mask) for eventtype in (Xlib.protocol.event.KeyPress, Xlib.protocol.event.KeyRelease): event = eventtype(root=display.screen().root, window=window, same_screen=0, child=Xlib.X.NONE, root_x=0, root_y=0, event_x=0, event_y=0, state=shift_mask, detail=keycode, time=int(time.time())) window.send_event(event, propagate=True)
def __init__(self, display): self.display = display self.screen = display.screen() self.colormap = self.screen.default_colormap bg = self.colormap.alloc_named_color("gray10").pixel self.window = self.screen.root.create_window( 50, 50, 600, 400, 0, self.screen.root_depth, X.InputOutput, X.CopyFromParent, # special attribute values background_pixel = bg, event_mask = (#X.ExposureMask | X.StructureNotifyMask), colormap = self.colormap ) self.window.set_wm_name('Pyxine') self.window.set_wm_icon_name('Pyxine') self.window.set_wm_class('pyxine', 'PyXine') self.window.set_wm_protocols([display.WM_DELETE_WINDOW]) self.window.set_wm_hints(flags = Xutil.StateHint, initial_state = Xutil.NormalState) self.window.set_wm_normal_hints(flags = (Xutil.PPosition | Xutil.PSize | Xutil.PMinSize), min_width = 20, min_height = 20) # Map the window, making it visible self.window.map() # Wait for window to map. # FIXME: is this right? while 1: e = display.next_event() if e.type == X.MapNotify: break self.xine_visual = pyxine.XlibDrawable(self.window)
def blinkRect(self, times=MAX_BLINKS): ''' Blink a rectangle on the screen using L{extents} for position and size. @param times: Maximum times to blink. @type times: integer ''' if self.extents is None or \ -0x80000000 in (self.extents.x, self.extents.y): return self.max_blinks = times self.blinks = 0 # get info for drawing higlight rectangles display = Xlib.display.Display() screen = display.screen() self.root = screen.root self.gc = w.create_gc(subwindow_mode = Xlib.X.IncludeInferiors, function = Xlib.X.GXinvert) self.inv = gtk.Invisible() self.inv.set_screen(screen) GLib.timeout_add(30, self._drawRectangle)
def openWindow(): global window, WIDTH, HEIGHT, display, LEFT, TOP os.system('clear') # Open the browser os.system('firefox "https://agar.io" -new-window -private &') sleep(2) # Get display display = Xlib.display.Display() root = display.screen().root # Get the x windows ID of the browser windowID = root.get_full_property( display.intern_atom('_NET_ACTIVE_WINDOW'), Xlib.X.AnyPropertyType).value[0] window = display.create_resource_object('window', windowID) window.configure(width=WIDTH, height=HEIGHT) display.sync() LEFT, TOP = window.get_geometry().x, window.get_geometry().y
def process_request(self, absolute_path, get_params): global CURSOR_X, CURSOR_Y fin = open("home.html","r") html_page = fin.read(); operation = int(get_params['operation'][0]) display = Xlib.display.Display() screen = display.screen() SMALL_MOVE = 20 BIG_MOVE = 70 root = screen.root if operation == 1: CURSOR_X = CURSOR_X - SMALL_MOVE elif operation == 2: CURSOR_Y = CURSOR_Y + SMALL_MOVE elif operation == 3: CURSOR_X = CURSOR_X + SMALL_MOVE elif operation == 4: CURSOR_Y = CURSOR_Y - SMALL_MOVE elif operation == 7: CURSOR_X = CURSOR_X - BIG_MOVE elif operation == 8: CURSOR_Y = CURSOR_Y + BIG_MOVE elif operation == 9: CURSOR_X = CURSOR_X + BIG_MOVE elif operation == 10: CURSOR_Y = CURSOR_Y - BIG_MOVE root.warp_pointer(CURSOR_X,CURSOR_Y) if operation == 5: Xlib.ext.xtest.fake_input(display,Xlib.X.ButtonPress,1) Xlib.ext.xtest.fake_input(display,Xlib.X.ButtonRelease,1) elif operation == 6: Xlib.ext.xtest.fake_input(display,Xlib.X.ButtonPress,3) Xlib.ext.xtest.fake_input(display,Xlib.X.ButtonRelease,3) display.sync() print str(CURSOR_X)+ ","+str(CURSOR_Y) return html_page
def set_active_window_by_pointer(): ''' Function to set window as active based on where the mouse pointer is located ''' import Xlib from Xlib.display import Display from Xlib import X display = Display() root = display.screen().root window = root.query_pointer().child window.set_input_focus(X.RevertToParent, X.CurrentTime) window.configure(stack_mode=X.Above) display.sync() # get active window NET_ACTIVE_WINDOW = display.intern_atom('_NET_ACTIVE_WINDOW') try: window_id = root.get_full_property(NET_ACTIVE_WINDOW, Xlib.X.AnyPropertyType).value[0] except Xlib.error.XError: #simplify dealing with BadWindow window_id = None return window_id
def run(self): self.xlock.acquire() # get X objects self.display = Xlib.display.Display(':0') display = self.display self.root = display.screen().root root = self.root if not display.has_extension("RANDR"): print "RANDR extension not found" sys.exit(1) display.query_extension('RANDR') if mplugd.verbose: r = display.xrandr_query_version() print "RANDR extension version %d.%d" % (r.major_version, r.minor_version) # set which types of events we want to receive root.xrandr_select_input( randr.RRScreenChangeNotifyMask | randr.RRCrtcChangeNotifyMask | randr.RROutputChangeNotifyMask | randr.RROutputPropertyNotifyMask ) self.xlock.release() self.initflag.set() import time # enter event loop while not self.stop: for x in range(0, self.root.display.pending_events()): e = self.root.display.next_event() mp_ev = XMP_Event(self, e) self.queue.push(mp_ev) # TODO find something better time.sleep(1)
def get_x_selection(): import Xlib.display # from the python X library, http://python-xlib.sf.net/ import Xlib.X import Xlib.Xatom display = Xlib.display.Display() xsel_data_atom = display.intern_atom("XSEL_DATA") screen = display.screen() w = screen.root.create_window(0, 0, 2, 2, 0, screen.root_depth) w.convert_selection(Xlib.Xatom.PRIMARY, # selection Xlib.Xatom.STRING, # target xsel_data_atom, # property Xlib.X.CurrentTime) # time while True: e = display.next_event() if e.type == Xlib.X.SelectionNotify: break assert e.property == xsel_data_atom assert e.target == Xlib.Xatom.STRING reply = w.get_full_property(xsel_data_atom, Xlib.X.AnyPropertyType) return reply.value
import Xlib.display import time import sys display = Xlib.display.Display() last = None while True: data = display.screen().root.query_pointer()._data now = (data["root_x"], data["root_y"]) if last is not None and now != last: print "Movement detected" else: print "No movement" sys.stdout.flush() last = now time.sleep(1)
def move_mouse(self, posxy): display = Xlib.display.Display() root = display.screen().root root.warp_pointer(posxy[0] + Glob.window_topleft[0], posxy[1] + Glob.window_topleft[1]) display.sync()
'?' : "question", '@' : "at", '[' : "bracketleft", ']' : "bracketright", '\\' : "backslash", '^' : "asciicircum", '_' : "underscore", '`' : "grave", '{' : "braceleft", '|' : "bar", '}' : "braceright", '~' : "asciitilde" } display = display.Display() window = display.screen().root def wait(p_keys_list): """Block the whole keyboard!!! And wait until some key from p_keys_list is pressed. By now p_keys_list is a list of strings, so use single ascii symbols. There is a way out of this hell - hit 'Escape'. The function returns hit button`s string representation Eg. for p_keys_list == ['1','2','3'] the function will hand untill 1,2 or 3 key is preseed or Escape is pressed.""" ds = display window.grab_keyboard(1, X.GrabModeAsync, X.GrabModeAsync, X.CurrentTime) while True: ev = ds.next_event() if ev.type == X.KeyPress: keysym = ds.keycode_to_keysym(ev._data['detail'], 0)
import Xlib.X ## Config # Pretend these windows don't exist when calculating size # of a different window. # They can still be selected directly. ignore_classes = [] # as reported by get_wm_class() ignore_names = [] # as reported by get_wm_name() # Button to alternate maximize-width or maximize-height modifier = Xlib.X.Mod1Mask # Alt # Button to finish execution done_button = Xlib.X.Button1Mask # Left mouse button ## End config display = Xlib.display.Display() root = display.screen().root def get_prop(window, prop_name): return window.get_full_property(display.intern_atom(prop_name), Xlib.X.AnyPropertyType).value try: # xwininfo blocks until the user clicks on a window. xwininfo = subprocess.Popen("xwininfo", stdout=subprocess.PIPE, shell=True, bufsize=-1) ret = xwininfo.wait() target_win_info = xwininfo.stdout.read()[:-1] if ret != 0: raise subprocess.CalledProcessError(ret, "xwininfo", target_win_info) target_win_id = re.search('Window id: ([0-9a-fx]+)', target_win_info).group(1) target_win_id = int(target_win_id, 16) except: target_win_id = get_prop(root, "_NET_ACTIVE_WINDOW")[0]
def __init__(self, display): """ Initialize and display the panel """ self.display = display # Display obj self.screen = display.screen() # Screen obj self.root = self.screen.root # Display root self.error = error.CatchError() # Error Handler/Suppressor self.panel = {"sections": []} # Panel data and layout self.colors = {} # Alloc'd colors self.hidden = 0 # Panel hidden/minimized self.focus = 0 # Currently focused window self.rpm = None # Root pixmap ID self.beats = bool(TIME_BEATS) global P_HEIGHT, P_WIDTH, P_LOCATION # Misc. initializations if SHOWLINES or SHOWBORDER: self.lgc = self.root.create_gc(foreground=self.getColor(LINE_COLOR)) if not P_WIDTH: P_WIDTH = self.screen.width_in_pixels - P_START if SHOWBORDER: P_HEIGHT += 2 if P_LOCATION: P_LOCATION = self.screen.height_in_pixels - P_HEIGHT else: P_LOCATION = 0 # Setup the panel's window self.window = self.screen.root.create_window(P_START, P_LOCATION, P_WIDTH, P_HEIGHT, 0, self.screen.root_depth, window_class=X.InputOutput, visual=X.CopyFromParent, colormap=X.CopyFromParent, event_mask=( X.ExposureMask | X.ButtonPressMask | X.ButtonReleaseMask | X.EnterWindowMask)) ppinit(self.window.id, FONT) # Init the panel sections if DESKTOP: self.panel["sections"].append(DESKTOP) self.panel[DESKTOP] = Obj(id="desktop", names=[], first=0, last=0) if CLOCK: self.panel["sections"].append(CLOCK) self.panel[CLOCK] = Obj(id="clock", name="", first=0, last=0, x1=0, x2=0, color=self.getColor(CLOCK_COLOR), shadow=self.getColor(CLOCK_SHADOW_COLOR)) if TRAY: self.panel["sections"].append(TRAY) self.panel[TRAY] = Obj(id="tray", tasks={}, order=[], first=0, last=0, window=self.window) self.createTray(self.display, self.screen) if LAUNCHER and LAUNCH_LIST: self.panel["sections"].append(LAUNCHER) self.panel[LAUNCHER] = Obj(id="launcher", tasks={}, order=[], first=0, last=0) self.createLauncher() self.panel["sections"].append(TASKS) self.panel[TASKS] = Obj(id="tasks", tasks={}, order=[], first=0, last=0) self.panel["sections"].sort() self.panel[self.panel["sections"][0]].first = 1 self.panel[self.panel["sections"][-1]].last = 1 # Init the properties and then start the event loop self.setProps(self.display, self.window) self.setStruts(self.window) self.getDesktopNames() self.root.change_attributes(event_mask=(X.PropertyChangeMask)) self.window.map() self.display.flush() self.loop(self.display, self.root, self.window, self.panel)
import Xlib import Xlib.display display = Xlib.display.Display() screen = display.screen() root = screen.root window = root.create_window( 0, 0, 800, 600, 0, screen.root_depth, window_class=Xlib.X.InputOutput, visual=Xlib.X.CopyFromParent, colormap=Xlib.X.CopyFromParent, event_mask=( Xlib.X.ExposureMask |Xlib.X.ButtonPressMask |Xlib.X.ButtonReleaseMask |Xlib.X.EnterWindowMask ) ) _WIN_STATE = display.intern_atom("_WIN_STATE") _MOTIF_WM_HINTS = display.intern_atom("_MOTIF_WM_HINTS") window.set_wm_name("PyPanel") window.set_wm_class("pypanel","PyPanel") window.set_wm_hints(flags=(Xlib.Xutil.InputHint|Xlib.Xutil.StateHint), input=0, initial_state=1) window.set_wm_normal_hints(flags=(Xlib.Xutil.PPosition|Xlib.Xutil.PMaxSize|Xlib.Xutil.PMinSize), min_width=800, min_height=600, max_width=800, max_height=600) window.change_property(_WIN_STATE,Xlib.Xatom.CARDINAL,32,[1])