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