def do_init_new_backing_instance(self):
w, h = self.size
self._backing = None
assert w < 32768 and h < 32768, "dimensions too big: %sx%s" % (w, h)
if w == 0 or h == 0:
#this can happen during cleanup
return
if w < 0 or h < 0:
log.warn("Warning: invalid backing dimensions %ix%i", w, h)
w = max(1, w)
h = max(1, h)
try:
if self._alpha_enabled:
self._backing = gdk.Pixmap(None, w, h, 32)
screen = self._backing.get_screen()
rgba = screen.get_rgba_colormap()
if rgba is not None:
self._backing.set_colormap(rgba)
else:
#cannot use transparency
log.warn(
"Warning: cannot display transparency, no RGBA colormap"
)
self._alpha_enabled = False
self._backing = gdk.Pixmap(gdk.get_default_root_window(),
w, h)
else:
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
except RuntimeError as e:
log("do_init_new_backing_instance()", exc_info=True)
log.error("Error creating pixmap backing of size %ix%i", w, h)
log.error(" %s", e)
self._backing = None
def init(self, ww, wh, bw, bh):
#use window size as backing size:
self.render_size = ww, wh
self.size = bw, bh
w, h = bw, bh
old_backing = self._backing
self._backing = None
assert w<32768 and h<32768, "dimensions too big: %sx%s" % (w, h)
if w==0 or h==0:
#this can happen during cleanup
return
if self._alpha_enabled:
self._backing = gdk.Pixmap(None, w, h, 32)
screen = self._backing.get_screen()
rgba = screen.get_rgba_colormap()
if rgba is not None:
self._backing.set_colormap(rgba)
else:
#cannot use transparency
log.warn("cannot use transparency: no RGBA colormap!")
self._alpha_enabled = False
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
else:
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = self._backing.cairo_create()
cr.set_source_rgb(1, 1, 1)
if old_backing is not None:
# Really we should respect bit-gravity here but... meh.
old_w, old_h = old_backing.get_size()
if w>old_w and h>old_h:
#both width and height are bigger:
cr.rectangle(old_w, 0, w-old_w, h)
cr.fill()
cr.new_path()
cr.rectangle(0, old_h, old_w, h-old_h)
cr.fill()
elif w>old_w:
#enlarged in width only
cr.rectangle(old_w, 0, w-old_w, h)
cr.fill()
if h>old_h:
#enlarged in height only
cr.rectangle(0, old_h, w, h-old_h)
cr.fill()
cr.set_operator(cairo.OPERATOR_SOURCE)
cr.set_source_pixmap(old_backing, 0, 0)
cr.paint()
else:
cr.rectangle(0, 0, w, h)
cr.fill()
def init(self, ww, wh, bw, bh):
#use window size as backing size:
self.render_size = ww, wh
self.size = bw, bh
w, h = bw, bh
old_backing = self._backing
self._backing = None
assert w < 32768 and h < 32768, "dimensions too big: %sx%s" % (w, h)
if w == 0 or h == 0:
#this can happen during cleanup
return
if self._alpha_enabled:
self._backing = gdk.Pixmap(None, w, h, 32)
screen = self._backing.get_screen()
rgba = screen.get_rgba_colormap()
if rgba is not None:
self._backing.set_colormap(rgba)
else:
#cannot use transparency
log.warn("cannot use transparency: no RGBA colormap!")
self._alpha_enabled = False
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
else:
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = self._backing.cairo_create()
cr.set_source_rgb(1, 1, 1)
if old_backing is not None:
# Really we should respect bit-gravity here but... meh.
old_w, old_h = old_backing.get_size()
if w > old_w and h > old_h:
#both width and height are bigger:
cr.rectangle(old_w, 0, w - old_w, h)
cr.fill()
cr.new_path()
cr.rectangle(0, old_h, old_w, h - old_h)
cr.fill()
elif w > old_w:
#enlarged in width only
cr.rectangle(old_w, 0, w - old_w, h)
cr.fill()
if h > old_h:
#enlarged in height only
cr.rectangle(0, old_h, w, h - old_h)
cr.fill()
cr.set_operator(cairo.OPERATOR_SOURCE)
cr.set_source_pixmap(old_backing, 0, 0)
cr.paint()
else:
cr.rectangle(0, 0, w, h)
cr.fill()
def dump_windows():
root = gdk.get_default_root_window()
log("root window: %s" % root)
children = get_children(root)
log("%s windows" % len(children))
for window in get_children(root):
log("found window: %s", window_info(window))
def cleanup(self):
log("SystemTray.cleanup()")
root = gdk.get_default_root_window()
def undock(window):
log("undocking %s", window)
X11Window.Unmap(window.xid)
X11Window.Reparent(window.xid, root.xid, 0, 0)
with xswallow:
owner = X11Window.XGetSelectionOwner(SELECTION)
if owner == self.tray_window.xid:
X11Window.XSetSelectionOwner(0, SELECTION)
log("SystemTray.cleanup() reset %s selection owner to %#x",
SELECTION, X11Window.XGetSelectionOwner(SELECTION))
else:
log.warn("Warning: we were no longer the tray selection owner")
remove_event_receiver(self.tray_window, self)
tray_windows = self.tray_windows
self.tray_windows = {}
for window, tray_window in tray_windows.items():
with xswallow:
undock(window)
tray_window.destroy()
self.tray_window.destroy()
self.tray_window = None
log("SystemTray.cleanup() done")
def __init__(self):
self.statusicon = gtk.StatusIcon()
self.counter = 0
self.statusicon.connect("activate", self.quit_cb)
self.statusicon.connect("popup-menu", self.quit_cb)
self.statusicon.set_tooltip("StatusIcon Example")
#generate tray image:
s = 64
w, h = s * 2, s * 2
pixmap = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = pixmap.cairo_create()
cr.set_operator(cairo.OPERATOR_CLEAR)
cr.fill()
cr.set_operator(cairo.OPERATOR_SOURCE)
for i, color in enumerate([(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1)]):
cr.set_source_rgba(*color)
cr.new_path()
x = (i % 2) * s
y = (i / 2) * s
cr.move_to(x, y)
cr.line_to(x + s, y)
cr.line_to(x + s, y + s)
cr.line_to(x, y + s)
cr.close_path()
cr.fill()
pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, w, h)
pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0, w,
h)
self.statusicon.set_from_pixbuf(pixbuf)
def pick_immediate(self, x, y, magnifier):
"""
Select the color at the specified pixel
The coordinates are relative to the screen.
"""
if self.flags() & gtk.REALIZED == False: return
if magnifier:
r,g,b = self.mag.raw_pixbuf.get_pixels_array()[y,x]
else:
# grab raw screen data
self.raw_pixbuf.get_from_drawable(
gdk.get_default_root_window(),
gdk.colormap_get_system(),
x, y,
0, 0,
self.raw_width, self.raw_height)
#pull out rgb value
#XXX first time this is called generates a warning and doesn't work.
# all subsequent times are fine. why?
r,g,b = self.raw_pixbuf.get_pixels_array()[0,0]
self.color.set_rgb(r,g,b)
def cb_motion_notify(self, widget, event):
""" Callback from mouse motion notify events """
if (self.picking):
# check if we are over the magnified image. if so, select from it
a = self.allocation
r = self.mag.allocation
ox, oy = self.mag.origin()
x = a.x + event.x - r.x
y = a.y + event.y - r.y
zx = int((x - ox) / self.mag.zoom)
zy = int((y - oy) / self.mag.zoom)
if (self.mag.has_data and (x >= 0 and x < r.width)
and (y >= 0 and y < r.height)
and (zx >= 0 and zx < self.mag.raw_width)
and (zy >= 0 and zy < self.mag.raw_height)):
self.pick(zx, zy, True)
# otherwise, select from screen
else:
root_w, root_h = gdk.get_default_root_window().get_size()
x = event.x_root
y = event.y_root
if (x < 0): x = 0
if (x >= root_w): x = root_w - 1
if (y < 0): y = 0
if (y >= root_h): y = root_h - 1
self.pick(x, y, False)
def init(self, w, h): old_backing = self._backing self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h) cr = self._backing.cairo_create() cr.set_source_rgb(1, 1, 1) if CRASH and old_backing is not None: cr.set_operator(cairo.OPERATOR_SOURCE) cr.set_source_pixmap(old_backing, 0, 0) cr.paint() old_w, old_h = old_backing.get_size() if w>old_w: cr.new_path() cr.move_to(old_w, 0) cr.line_to(w, 0) cr.line_to(w, h) cr.line_to(old_w, h) cr.close_path() cr.fill() if h>old_h: cr.new_path() cr.move_to(0, old_h) cr.line_to(0, h) cr.line_to(w, h) cr.line_to(w, old_h) cr.close_path() cr.fill() else: cr.rectangle(0, 0, w, h) cr.fill()
def set_icon():
#generate window icon image:
if not self.rotate:
return True
s = 64
w, h = s * 2, s * 2
pixmap = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = pixmap.cairo_create()
cr.set_operator(cairo.OPERATOR_CLEAR)
cr.fill()
cr.set_operator(cairo.OPERATOR_SOURCE)
v = (self.counter % 256 / 255.0)
self.counter += 10
for i, color in enumerate([(1, 0, 0, 1), (0, 1, 0, 1),
(0, 0, 1, 1), (v, v, v, v)]):
cr.set_source_rgba(*color)
cr.new_path()
x = (i % 2) * s
y = (i / 2) * s
cr.move_to(x, y)
cr.line_to(x + s, y)
cr.line_to(x + s, y + s)
cr.line_to(x, y + s)
cr.close_path()
cr.fill()
pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, w, h)
pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0,
w, h)
self.set_icon(pixbuf)
print("set icon to %s" % int(255 * v))
return True
def set_icon():
#generate window icon image:
if not self.rotate:
return True
s = 64
w, h = s*2, s*2
pixmap = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = pixmap.cairo_create()
cr.set_operator(cairo.OPERATOR_CLEAR)
cr.fill()
cr.set_operator(cairo.OPERATOR_SOURCE)
v = (self.counter % 256 / 255.0)
self.counter += 10
for i, color in enumerate([(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1), (v, v, v, v)]):
cr.set_source_rgba(*color)
cr.new_path()
x = (i % 2) * s
y = (i / 2) * s
cr.move_to(x, y)
cr.line_to(x + s, y)
cr.line_to(x+s, y+s)
cr.line_to(x, y+s)
cr.close_path()
cr.fill()
pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, w, h)
pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0, w, h)
self.set_icon(pixbuf)
print("set icon to %s" % int(255*v))
return True
def do_unmanaged(self, wm_exiting):
log("unmanaging window: %s (%s - %s)", self, self.corral_window, self.client_window)
self._internal_set_property("owner", None)
if self.corral_window:
remove_event_receiver(self.corral_window, self)
with xswallow:
for prop in WindowModel.SCRUB_PROPERTIES:
X11Window.XDeleteProperty(self.xid, prop)
if self.client_reparented:
self.client_window.reparent(gdk.get_default_root_window(), 0, 0)
self.client_reparented = False
self.client_window.set_events(self.client_window_saved_events)
#it is now safe to destroy the corral window:
self.corral_window.destroy()
self.corral_window = None
# It is important to remove from our save set, even after
# reparenting, because according to the X spec, windows that are
# in our save set are always Mapped when we exit, *even if those
# windows are no longer inferior to any of our windows!* (see
# section 10. Connection Close). This causes "ghost windows", see
# bug #27:
if self.in_save_set:
with xswallow:
X11Window.XRemoveFromSaveSet(self.xid)
self.in_save_set = False
with xswallow:
X11Window.sendConfigureNotify(self.xid)
if wm_exiting:
self.client_window.show_unraised()
BaseWindowModel.do_unmanaged(self, wm_exiting)
def __init__(self):
self.statusicon = gtk.StatusIcon()
self.counter = 0
self.statusicon.connect("activate", self.quit_cb)
self.statusicon.connect("popup-menu", self.quit_cb)
self.statusicon.set_tooltip("StatusIcon Example")
#generate tray image:
s = 64
w, h = s*2, s*2
pixmap = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = pixmap.cairo_create()
cr.set_operator(cairo.OPERATOR_CLEAR)
cr.fill()
cr.set_operator(cairo.OPERATOR_SOURCE)
for i, color in enumerate([(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1)]):
cr.set_source_rgba(*color)
cr.new_path()
x = (i % 2) * s
y = (i / 2) * s
cr.move_to(x, y)
cr.line_to(x + s, y)
cr.line_to(x+s, y+s)
cr.line_to(x, y+s)
cr.close_path()
cr.fill()
pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, w, h)
pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0, w, h)
self.statusicon.set_from_pixbuf(pixbuf)
def init(self, w, h):
old_backing = self._backing
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = self._backing.cairo_create()
cr.set_source_rgb(1, 1, 1)
if CRASH and old_backing is not None:
cr.set_operator(cairo.OPERATOR_SOURCE)
cr.set_source_pixmap(old_backing, 0, 0)
cr.paint()
old_w, old_h = old_backing.get_size()
if w > old_w:
cr.new_path()
cr.move_to(old_w, 0)
cr.line_to(w, 0)
cr.line_to(w, h)
cr.line_to(old_w, h)
cr.close_path()
cr.fill()
if h > old_h:
cr.new_path()
cr.move_to(0, old_h)
cr.line_to(0, h)
cr.line_to(w, h)
cr.line_to(w, old_h)
cr.close_path()
cr.fill()
else:
cr.rectangle(0, 0, w, h)
cr.fill()
def __init__ (self):
super(LanguageBar, self).__init__()
self.__show = 1
self.__enabled = False
self.__has_focus = False
self.__show_im_name = False
self.__im_name = None
self.set_style(gtk.TOOLBAR_BOTH_HORIZ)
self.set_show_arrow(False)
self.set_property("icon-size", ICON_SIZE)
self.__create_ui()
self.__properties = []
self.__toplevel = gtk.Window(gtk.WINDOW_POPUP)
self.__toplevel.connect("size-allocate", self.__toplevel_size_allocate_cb)
self.__toplevel.add(self)
root = gdk.get_default_root_window()
try:
self.__work_area = root.property_get("_NET_WORKAREA")[2]
except:
w, h = root.get_size()
self.__work_area = 0, 0, w, h
self.__position = self.__work_area[0] + self.__work_area[2] - 20, self.__work_area[1] + self.__work_area[3] - 20
self.__toplevel.move(*self.__position)
def cb_motion_notify(self, widget, event):
""" Callback from mouse motion notify events """
if (self.picking):
# check if we are over the magnified image. if so, select from it
a = self.allocation
r = self.mag.allocation
ox,oy = self.mag.origin()
x = a.x + event.x - r.x
y = a.y + event.y - r.y
zx = int((x-ox)/self.mag.zoom)
zy = int((y-oy)/self.mag.zoom)
if (self.mag.has_data and
(x >= 0 and x < r.width) and
(y >= 0 and y < r.height) and
(zx >= 0 and zx < self.mag.raw_width) and
(zy >= 0 and zy < self.mag.raw_height)):
self.pick(zx, zy, True)
# otherwise, select from screen
else:
root_w, root_h = gdk.get_default_root_window().get_size()
x = event.x_root
y = event.y_root
if (x < 0): x = 0
if (x >= root_w): x = root_w - 1
if (y < 0): y = 0
if (y >= root_h): y = root_h - 1
self.pick(x, y, False)
def _get_root_bbox(self):
root_window = gdk.get_default_root_window()
args = root_window.get_position() + root_window.get_size()
root_bbox = gdk.Rectangle(*args)
current_screen = gtk.gdk.screen_get_default().get_number()
for panel in self._gconf_client.all_dirs('/apps/panel/toplevels'):
orientation = self._gconf_client.get_string(panel + '/orientation')
size = self._gconf_client.get_int(panel + '/size')
screen = self._gconf_client.get_int(panel + '/screen')
if screen != current_screen:
continue
if orientation == 'top':
root_bbox.y += size
root_bbox.height -= size
elif orientation == 'bottom':
root_bbox.height -= size
elif orientation == 'right':
root_bbox.x += size
root_bbox.width -= size
elif orientation == 'left':
root_bbox.x -= size
return root_bbox
def _get_root_bbox(self):
root_window = gdk.get_default_root_window()
args = root_window.get_position() + root_window.get_size()
root_bbox = gdk.Rectangle(*args)
current_screen = gtk.gdk.screen_get_default().get_number()
for panel in self._gconf_client.all_dirs('/apps/panel/toplevels'):
orientation = self._gconf_client.get_string(panel+'/orientation')
size = self._gconf_client.get_int(panel+'/size')
screen = self._gconf_client.get_int(panel+'/screen')
if screen != current_screen:
continue
if orientation == 'top':
root_bbox.y += size
root_bbox.height -= size
elif orientation == 'bottom':
root_bbox.height -= size
elif orientation == 'right':
root_bbox.x += size
root_bbox.width -= size
elif orientation == 'left':
root_bbox.x -= size
return root_bbox
def dump_windows():
root = gdk.get_default_root_window()
log("root window: %s" % root)
children = get_children(root)
log("%s windows" % len(children))
for window in get_children(root):
log("found window: %s", window_info(window))
def do_unmanaged(self, wm_exiting):
log("unmanaging window: %s (%s - %s)", self, self.corral_window,
self.client_window)
self._internal_set_property("owner", None)
if self.corral_window:
remove_event_receiver(self.corral_window, self)
geom = None
#use a new context so we will XSync right here
#and detect if the window is already gone:
with XSwallowContext():
geom = X11Window.getGeometry(self.xid)
if geom is not None:
if self.client_reparented:
self.client_window.reparent(gdk.get_default_root_window(),
0, 0)
self.client_window.set_events(self.client_window_saved_events)
self.client_reparented = False
#it is now safe to destroy the corral window:
self.corral_window.destroy()
self.corral_window = None
# It is important to remove from our save set, even after
# reparenting, because according to the X spec, windows that are
# in our save set are always Mapped when we exit, *even if those
# windows are no longer inferior to any of our windows!* (see
# section 10. Connection Close). This causes "ghost windows", see
# bug #27:
if self.in_save_set:
with xswallow:
X11Window.XRemoveFromSaveSet(self.xid)
self.in_save_set = False
with xswallow:
X11Window.sendConfigureNotify(self.xid)
if wm_exiting:
self.client_window.show_unraised()
BaseWindowModel.do_unmanaged(self, wm_exiting)
def set_background(path):
# Note that the path is not unlinked, because gconf and xfconf set bg
# asynchronously, so there's no way of knowing when the image will
# actually be used
if 'gsettings' in conf.bg_set_methods:
## GSettings - newer GNOME, Unity
# Using gi.repository.Gio here directly is tricky alongside gimp's gtk2
from subprocess import call
from urllib import quote
call([ 'gsettings', 'set',
'org.gnome.desktop.background', 'picture-uri',
'file://{0}'.format(quote(path)) ])
if 'gconf' in conf.bg_set_methods:
## Gconf - older GNOME, XFCE/nautilus and such
try:
import gconf
gconf = gconf.client_get_default()
gconf.set_string(
'/desktop/gnome/background/picture_filename', path )
except ImportError: pass
if 'xfconf' in conf.bg_set_methods:
## Xfconf (via dbus interface) - XFCE/xfdesktop
try: import dbus
except ImportError: pass
else:
try:
xfconf = dbus.Interface(
dbus.SessionBus().get_object(
'org.xfce.Xfconf', '/org/xfce/Xfconf' ),
dbus_interface='org.xfce.Xfconf' )
for k,v in xfconf.GetAllProperties('xfce4-desktop', '/backdrop').iteritems():
if k.endswith('/image-path'): xfconf.SetProperty('xfce4-desktop', k, path)
except dbus.exceptions.DBusException: pass # no property/object/interface/etc
if 'enlightenment' in conf.bg_set_methods:
## E17+ edbus interface
try: import dbus
except ImportError: pass
else:
try:
edbus = dbus.SessionBus().get_object(
'org.enlightenment.wm.service', '/org/enlightenment/wm/RemoteObject' )
dxc, dyc = edbus.GetVirtualCount(dbus_interface='org.enlightenment.wm.Desktop')
edbus = dbus.Interface( edbus,
dbus_interface='org.enlightenment.wm.Desktop.Background' )
for dx, dy in it.product(xrange(dxc), xrange(dyc)): edbus.Add(0, dx, dy, path)
except dbus.exceptions.DBusException: pass # no property/object/interface/etc
if 'x-root-window' in conf.bg_set_methods:
## Paint X root window via pygtk
pb = gdk.pixbuf_new_from_file(path)
pm, mask = pb.render_pixmap_and_mask()
win = gdk.get_default_root_window()
win.set_back_pixmap(pm, False)
win.clear()
win.draw_pixbuf(gdk.GC(win), pb, 0, 0, 0, 0, -1, -1)
def take_screenshot(win=None):
if win is None:
win = gdk.get_default_root_window()
sz = win.get_size()
pb = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8, sz[0], sz[1])
pb = pb.get_from_drawable(win, win.get_colormap(), 0, 0, 0, 0, sz[0],
sz[1])
return pb.get_pixels_array()
def init(self, w, h):
old_backing = self._backing
assert w<32768 and h<32768, "dimensions too big: %sx%s" % (w, h)
if self._has_alpha and HAS_RGBA:
self._backing = gdk.Pixmap(None, w, h, 32)
screen = self._backing.get_screen()
rgba = screen.get_rgba_colormap()
if rgba is not None:
self._backing.set_colormap(rgba)
else:
#cannot use transparency
self._has_alpha = False
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
else:
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = self._backing.cairo_create()
cr.set_source_rgb(1, 1, 1)
if old_backing is not None:
# Really we should respect bit-gravity here but... meh.
old_w, old_h = old_backing.get_size()
#note: we may paint the rectangle (old_w, old_h) to (w, h) twice - no big deal
if w>old_w:
cr.new_path()
cr.move_to(old_w, 0)
cr.line_to(w, 0)
cr.line_to(w, h)
cr.line_to(old_w, h)
cr.close_path()
cr.fill()
if h>old_h:
cr.new_path()
cr.move_to(0, old_h)
cr.line_to(0, h)
cr.line_to(w, h)
cr.line_to(w, old_h)
cr.close_path()
cr.fill()
cr.new_path()
cr.move_to(0, 0)
cr.set_operator(cairo.OPERATOR_SOURCE)
cr.set_source_pixmap(old_backing, 0, 0)
cr.paint()
else:
cr.rectangle(0, 0, w, h)
cr.fill()
def init(self, w, h):
old_backing = self._backing
assert w < 32768 and h < 32768, "dimensions too big: %sx%s" % (w, h)
if self._has_alpha and HAS_RGBA:
self._backing = gdk.Pixmap(None, w, h, 32)
screen = self._backing.get_screen()
rgba = screen.get_rgba_colormap()
if rgba is not None:
self._backing.set_colormap(rgba)
else:
#cannot use transparency
self._has_alpha = False
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
else:
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = self._backing.cairo_create()
cr.set_source_rgb(1, 1, 1)
if old_backing is not None:
# Really we should respect bit-gravity here but... meh.
old_w, old_h = old_backing.get_size()
#note: we may paint the rectangle (old_w, old_h) to (w, h) twice - no big deal
if w > old_w:
cr.new_path()
cr.move_to(old_w, 0)
cr.line_to(w, 0)
cr.line_to(w, h)
cr.line_to(old_w, h)
cr.close_path()
cr.fill()
if h > old_h:
cr.new_path()
cr.move_to(0, old_h)
cr.line_to(0, h)
cr.line_to(w, h)
cr.line_to(w, old_h)
cr.close_path()
cr.fill()
cr.new_path()
cr.move_to(0, 0)
cr.set_operator(cairo.OPERATOR_SOURCE)
cr.set_source_pixmap(old_backing, 0, 0)
cr.paint()
else:
cr.rectangle(0, 0, w, h)
cr.fill()
def f(t,width,height):
time.sleep(t)
w = g.get_default_root_window()
sz = (width,height)
pb = g.Pixbuf(g.COLORSPACE_RGB, False, 8,*sz)
cm = w.get_colormap()
pb = pb.get_from_drawable(w,cm,58,141,0,0,*sz)
im = Image(pb.get_pixels_array()) #creates simplecv image from pixbuf
return im
def dock_tray(self, xid):
log("dock_tray(%#x)", xid)
root = gdk.get_default_root_window()
window = gdk.window_foreign_new(xid)
if window is None:
log.warn("could not find gdk window for tray window %#x", xid)
return
log("dock_tray: root=%s, window=%s", root, window)
w, h = window.get_geometry()[2:4]
log("dock_tray: geometry=%s", (w, h))
if w == 0 and h == 0:
log("dock_tray: invalid tray geometry, ignoring this request")
return
event_mask = gdk.STRUCTURE_MASK | gdk.EXPOSURE_MASK | gdk.PROPERTY_CHANGE_MASK
window.set_events(event_mask=event_mask)
add_event_receiver(window, self)
w = max(1, min(128, w))
h = max(1, min(128, h))
title = prop_get(window, "_NET_WM_NAME", "utf8", ignore_errors=True)
if title is None:
title = prop_get(window, "WM_NAME", "latin1", ignore_errors=True)
if title is None:
title = ""
log(
"dock_tray(%#x) gdk window=%#x, geometry=%s, title=%s, visual.depth=%s",
xid, window.xid, window.get_geometry(), title,
window.get_visual().depth)
event_mask = gdk.STRUCTURE_MASK | gdk.EXPOSURE_MASK | gdk.PROPERTY_CHANGE_MASK
tray_window = gdk.Window(root,
width=w,
height=h,
window_type=gdk.WINDOW_TOPLEVEL,
event_mask=event_mask,
wclass=gdk.INPUT_OUTPUT,
title=title,
x=-200,
y=-200,
override_redirect=True,
visual=window.get_visual(),
colormap=window.get_colormap())
log("dock_tray(%#x) setting tray properties", xid)
set_tray_window(tray_window, window)
tray_window.show()
self.tray_windows[window] = tray_window
self.window_trays[tray_window] = window
log("dock_tray(%#x) resizing and reparenting", xid)
window.resize(w, h)
xwin = window.xid
xtray = tray_window.xid
X11Window.Withdraw(xwin)
X11Window.Reparent(xwin, xtray, 0, 0)
X11Window.MapRaised(xwin)
log("dock_tray(%#x) new tray container window %#x", xid, xtray)
tray_window.invalidate_rect(gdk.Rectangle(width=w, height=h), True)
X11Window.send_xembed_message(xwin, XEMBED_EMBEDDED_NOTIFY, 0, xtray,
XEMBED_VERSION)
def do_init_new_backing_instance(self):
w, h = self.size
self._backing = None
assert w<32768 and h<32768, "dimensions too big: %sx%s" % (w, h)
if w==0 or h==0:
#this can happen during cleanup
return
if self._alpha_enabled:
self._backing = gdk.Pixmap(None, w, h, 32)
screen = self._backing.get_screen()
rgba = screen.get_rgba_colormap()
if rgba is not None:
self._backing.set_colormap(rgba)
else:
#cannot use transparency
log.warn("cannot use transparency: no RGBA colormap!")
self._alpha_enabled = False
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
else:
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
def _gtk_screenshot(self, path):
window = gdk.get_default_root_window()
if not window:
raise RuntimeError('Taking screenshot failed')
width, height = window.get_size()
pb = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8, width, height)
pb = pb.get_from_drawable(window, window.get_colormap(), 0, 0, 0, 0,
width, height)
if not pb:
raise RuntimeError('Taking screenshot failed')
pb.save(path, 'jpeg')
def _gtk_screenshot(self, path):
window = gdk.get_default_root_window()
if not window:
raise RuntimeError('Taking screenshot failed')
width, height = window.get_size()
pb = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8, width, height)
pb = pb.get_from_drawable(window, window.get_colormap(),
0, 0, 0, 0, width, height)
if not pb:
raise RuntimeError('Taking screenshot failed')
pb.save(path, 'jpeg')
def _grab_screenshot_gtk_py2():
window = gdk.get_default_root_window()
if not window:
raise RuntimeError('Taking screenshot failed.')
width, height = window.get_size()
pb = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8, width, height)
pb = pb.get_from_drawable(window, window.get_colormap(), 0, 0, 0, 0, width,
height)
if not pb:
raise RuntimeError('Taking screenshot failed.')
return pb
def do_init_new_backing_instance(self):
w, h = self.size
self._backing = None
assert w<32768 and h<32768, "dimensions too big: %sx%s" % (w, h)
if w==0 or h==0:
#this can happen during cleanup
return
if self._alpha_enabled:
self._backing = gdk.Pixmap(None, w, h, 32)
screen = self._backing.get_screen()
rgba = screen.get_rgba_colormap()
if rgba is not None:
self._backing.set_colormap(rgba)
else:
#cannot use transparency
log.warn("cannot use transparency: no RGBA colormap!")
self._alpha_enabled = False
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
else:
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
def get_workarea():
"""
List with x-offset, y-offset, width and height in pixel of the first desktop
workarea relative to the root window.
TODO: take not the first, but the current desktop (right now, all
desktops are the same size, so it doesn't bother me)
"""
root_win = gdk.get_default_root_window()
win_property = gdk.atom_intern("_NET_WORKAREA")
wa_list = root_win.property_get(win_property)[2]
return ([wa_list[0], wa_list[1], wa_list[2], wa_list[3]])
def init(self, w, h):
old_backing = self._backing
assert w<32768 and h<32768, "dimensions too big: %sx%s" % (w, h)
if self._has_alpha and HAS_ALPHA:
self._backing = gdk.Pixmap(None, w, h, 32)
screen = self._backing.get_screen()
rgba = screen.get_rgba_colormap()
if rgba is not None:
self._backing.set_colormap(rgba)
else:
#cannot use transparency
self._has_alpha = False
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
else:
self._backing = gdk.Pixmap(gdk.get_default_root_window(), w, h)
cr = self._backing.cairo_create()
cr.set_source_rgb(1, 1, 1)
if old_backing is not None:
# Really we should respect bit-gravity here but... meh.
old_w, old_h = old_backing.get_size()
if w>old_w and h>old_h:
#both width and height are bigger:
cr.rectangle(old_w, 0, w-old_w, h)
cr.fill()
cr.new_path()
cr.rectangle(0, old_h, old_w, h-old_h)
cr.fill()
elif w>old_w:
#enlarged in width only
cr.rectangle(old_w, 0, w-old_w, h)
cr.fill()
if h>old_h:
#enlarged in height only
cr.rectangle(0, old_h, w, h-old_h)
cr.fill()
cr.set_operator(cairo.OPERATOR_SOURCE)
cr.set_source_pixmap(old_backing, 0, 0)
cr.paint()
else:
cr.rectangle(0, 0, w, h)
cr.fill()
def motion_notify_event(self, win, event):
"""Mouse motion_notify_event handler"""
pixbuf = Pixbuf(COLORSPACE_RGB, False, 8, 1, 1)
root = get_default_root_window()
xcoord, ycoord = event.get_root_coords()
from_draw = pixbuf.get_from_drawable(root, root.get_colormap(),
int(xcoord), int(ycoord),
0, 0, 1, 1)
pixel = from_draw.get_pixels_array()[0][0]
self.rgb = (pixel[0], pixel[1], pixel[2])
self.draw_color()
self.label.set_label(rgb_to_string(self.rgb).upper())
def get_screenshot(x=0, y=0, w=None, h=None, grayscale=True):
window = gg.get_default_root_window()
if not (w and h):
w, h = window.get_size()
pixbuf = gg.Pixbuf(gg.COLORSPACE_RGB, False, 8, w, h)
pixbuf = pixbuf.get_from_drawable(window, window.get_colormap(),x,y,0,0,w,h)
pixbuf.save('sc.png', 'png')
if grayscale:
img = cv2.imread('sc.png',0)
else:
img = cv2.imread('sc.png')
os.remove('sc.png')
return img
def __init__ (self):
super(Handle, self).__init__()
self.set_visible_window(False)
self.set_size_request(10, -1)
self.set_events(
gdk.EXPOSURE_MASK | \
gdk.BUTTON_PRESS_MASK | \
gdk.BUTTON_RELEASE_MASK | \
gdk.BUTTON1_MOTION_MASK)
self.__move_begined = False
root = gdk.get_default_root_window()
def _bell_signaled(self, wm, event):
log("bell signaled on window %#x", get_xwindow(event.window))
if not self.bell:
return
wid = 0
if event.window!=gdk.get_default_root_window() and event.window_model is not None:
try:
wid = self._window_to_id[event.window_model]
except:
pass
log("_bell_signaled(%s,%r) wid=%s", wm, event, wid)
for ss in self._server_sources.values():
ss.bell(wid, event.device, event.percent, event.pitch, event.duration, event.bell_class, event.bell_id, event.bell_name or "")
def __init__(self):
super(Handle, self).__init__()
self.set_visible_window(False)
self.set_size_request(10, -1)
self.set_events(
gdk.EXPOSURE_MASK | \
gdk.BUTTON_PRESS_MASK | \
gdk.BUTTON_RELEASE_MASK | \
gdk.BUTTON1_MOTION_MASK)
self.__move_begined = False
root = gdk.get_default_root_window()
def _get_window_by_title(title):
root = gdk.get_default_root_window()
if not root:
return
extents = _get_win_property(root, '_NET_CLIENT_LIST')
if not extents:
return
for id in extents:
w = gdk.window_foreign_new(id)
if w:
wm_name = w.property_get("WM_NAME")
if wm_name and title == wm_name[2]:
return w
def activate():
screen = gdk.screen_get_default()
screenWidth = screen.get_width()
screenHeight = screen.get_height()
pixbuf = gdk.Pixbuf(gdk.COLORSPACE_RGB, True, 8, screenWidth, screenHeight)
screenshot = gdk.Pixbuf.get_from_drawable(pixbuf, gdk.get_default_root_window(), gdk.colormap_get_system(), 0, 0, 0, 0, screenWidth, screenHeight)
screenshot.save(os.path.join(tempfile.gettempdir(), 'perdyselection.png'), 'png')
areaWindow = AreaWindow(screenWidth, screenHeight)
areaWindow.move(0, 0)
areaWindow.setFixedSize(screenWidth, screenHeight)
areaWindow.show()
def _get_window_by_title(title):
root = gdk.get_default_root_window()
if not root:
return
extents = _get_win_property(root, '_NET_CLIENT_LIST')
if not extents:
return
for id in extents:
w = gdk.window_foreign_new(id)
if w:
wm_name = w.property_get("WM_NAME")
if wm_name and title == wm_name[2]:
return w
def _get_window_by_pid(pid):
root = gdk.get_default_root_window()
if not root:
return
extents = _get_win_property(root, '_NET_CLIENT_LIST')
if not extents:
return
for id in extents:
w = gdk.window_foreign_new(id)
if w:
wm_pids = w.property_get("_NET_WM_PID")
if pid in wm_pids[2]:
return w
def _get_window_by_pid(pid):
root = gdk.get_default_root_window()
if not root:
return
extents = _get_win_property(root, '_NET_CLIENT_LIST')
if not extents:
return
for id in extents:
w = gdk.window_foreign_new(id)
if w:
wm_pids = w.property_get("_NET_WM_PID")
if pid in wm_pids[2]:
return w
def cb_motion_notify(self, widget, event):
"""
Callback for mouse motion notify events
If magnifying, calculates the size of a region centered on the
mouse cursor that is just large enough to fill the widget when
scaled up by the zoom factor. Then queues a grab of this region.
If measuring, updates measurement rectangle.
If panning, updates pan.
"""
if self.grabbing:
root_w, root_h = gdk.get_default_root_window().get_size()
w = int(math.ceil(float(self.allocation.width) / self.zoom))
h = int(math.ceil(float(self.allocation.height) / self.zoom))
x = event.x_root - int(w / 2)
y = event.y_root - int(h / 2)
if x < 0:
x = 0
if x > root_w - w:
x = root_w - w
if y < 0:
y = 0
if y > root_h - h:
y = root_h - h
self.grab(x, y, w, h)
elif self.panning:
pan_x = int(event.x - self.pan_start_x)
pan_y = int(event.y - self.pan_start_y)
self.pan(pan_x, pan_y)
elif self.measuring:
x0, y0 = self.coord_widget_to_pixbuf(*self.measure_start)
x1, y1 = self.coord_widget_to_pixbuf(event.x, event.y)
if x0 > x1:
x0, x1 = x1, x0
if y0 > y1:
y0, y1 = y1, y0
rect = gdk.Rectangle(x0, y0, x1 - x0 + 1, y1 - y0 + 1)
if rect != self.measure_rect:
self.measure_rect = rect
self.emit("measure-changed")
self.queue_draw()
def do_button_press_event(self, widget, event, data=None):
if event.button == 1:
root = gdk.get_default_root_window()
try:
desktop = root.property_get("_NET_CURRENT_DESKTOP")[2][0]
self.__workarea = root.property_get("_NET_WORKAREA")[2][desktop * 4: (desktop + 1) * 4]
except:
self.__workarea = None
self.__move_begined = True
toplevel = self.get_toplevel()
x, y = toplevel.get_position()
self.__press_pos = event.x_root - x, event.y_root - y
self.window.set_cursor(gdk.Cursor(gdk.FLEUR))
return True
return False
def get_x11_property(atom_name):
if sys.platform.startswith("win"):
return ""
try:
from gtk import gdk
root = gdk.get_default_root_window()
pulse_server_atom = gdk.atom_intern(atom_name)
p = root.property_get(pulse_server_atom)
if p is None:
return ""
v = p[2]
log("%s=%s", atom_name, v)
return v
except:
return ""
def get_x11_property(atom_name):
if sys.platform.startswith("win"):
return ""
try:
from gtk import gdk
root = gdk.get_default_root_window()
pulse_server_atom = gdk.atom_intern(atom_name)
p = root.property_get(pulse_server_atom)
if p is None:
return ""
v = p[2]
debug("get_x11_property(%s)=%s", atom_name, v)
return v
except:
return ""
def dump_windows():
from xpra.log import Logger
log = Logger("x11", "window")
from gtk import gdk
root = gdk.get_default_root_window()
log("root window: %s" % root)
try:
from xpra.x11.gtk2.gdk_bindings import get_children #@UnresolvedImport
except ImportError:
pass
else:
children = get_children(root)
log("%s windows" % len(children))
for window in get_children(root):
log("found window: %s", window_info(window))
def _record_gtk_py2(path, fps, stop):
window = gdk.get_default_root_window()
fourcc = cv2.VideoWriter_fourcc(*'VP08')
width, height = window.get_size()
with suppress_stderr():
vid = cv2.VideoWriter('%s' % path, fourcc, fps, (width, height))
while not stop.isSet():
pb = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8, width, height)
pb = pb.get_from_drawable(window, window.get_colormap(), 0, 0, 0, 0,
width, height)
numpy_array = pb.get_pixels_array()
frame = cv2.cvtColor(numpy_array, cv2.COLOR_RGB2BGR)
vid.write(frame)
vid.release()
cv2.destroyAllWindows()
def setup_tray_window(self):
display = gdk.display_get_default()
root = gdk.get_default_root_window()
screen = root.get_screen()
if TRANSPARENCY:
colormap, visual = screen.get_rgba_colormap(
), screen.get_rgba_visual()
if colormap is None or visual is None:
log.warn("setup tray: using rgb visual fallback")
colormap, visual = screen.get_rgb_colormap(
), screen.get_rgb_visual()
assert colormap is not None and visual is not None, "failed to obtain visual or colormap"
owner = X11Window.XGetSelectionOwner(SELECTION)
log("setup tray: current selection owner=%#x", owner)
if owner != XNone:
raise Exception("%s already owned by %s" % (SELECTION, owner))
self.tray_window = gdk.Window(root,
width=1,
height=1,
window_type=gdk.WINDOW_TOPLEVEL,
event_mask=0,
wclass=gdk.INPUT_OUTPUT,
title="Xpra-SystemTray",
visual=visual,
colormap=colormap)
xtray = self.tray_window.xid
set_tray_visual(self.tray_window, visual)
set_tray_orientation(self.tray_window, TRAY_ORIENTATION_HORZ)
log("setup tray: tray window %#x", xtray)
display.request_selection_notification(SELECTION)
try:
with xsync:
setsel = X11Window.XSetSelectionOwner(xtray, SELECTION)
log("setup tray: set selection owner returned %s, owner=%#x",
setsel, X11Window.XGetSelectionOwner(SELECTION))
event_mask = StructureNotifyMask
log("setup tray: sending client message")
X11Window.sendClientMessage(root.xid, root.xid, False,
event_mask, "MANAGER", CurrentTime,
SELECTION, xtray)
owner = X11Window.XGetSelectionOwner(SELECTION)
assert owner == xtray, "we failed to get ownership of the tray selection"
add_event_receiver(self.tray_window, self)
log("setup tray: done")
except Exception:
log("setup_tray failure", exc_info=True)
self.cleanup()
raise
def get_x11_property(atom_name):
from xpra.os_util import WIN32, OSX
if WIN32 or OSX:
return ""
try:
from gtk import gdk
root = gdk.get_default_root_window()
atom = gdk.atom_intern(atom_name)
p = root.property_get(atom)
if p is None:
return ""
v = p[2]
log("get_x11_property(%s)=%s", atom_name, v)
return v
except:
return ""
def _bell_signaled(self, wm, event):
log("bell signaled on window %#x", get_xwindow(event.window))
if not self.bell:
return
wid = 0
if event.window != gdk.get_default_root_window(
) and event.window_model is not None:
try:
wid = self._window_to_id[event.window_model]
except:
pass
log("_bell_signaled(%s,%r) wid=%s", wm, event, wid)
for ss in self._server_sources.values():
ss.bell(wid, event.device, event.percent, event.pitch,
event.duration, event.bell_class, event.bell_id,
event.bell_name or "")
def _take_gtk_screen_size():
if not gdk and not Gdk:
raise RuntimeError('PyGTK not installed/supported on this platform.')
if gdk:
window = gdk.get_default_root_window()
if not window:
raise RuntimeError('Taking screenshot failed.')
width, height = window.get_size()
return width, height
elif Gdk:
window = Gdk.get_default_root_window()
if not window:
raise RuntimeError('Taking screenshot failed.')
width = window.get_width()
height = window.get_height()
return width, height
def serverlist(self):
''' get the serverlist from the X root window '''
rootwindow = gdk.get_default_root_window()
# Read the property
propval = rootwindow.property_get("VimRegistry")
res = {}
if propval:
prop = propval[-1].split('\0')
for r in prop:
if r:
rs = r.split()
id = long(int(rs[0], 16))
name = rs[1]
w = self.server_exists(id)
if w and not (name in self.bad_servers):
res[name] = id
return res
def peek_gtk():
"""Takes a screenshot using gtk."""
from gtk import gdk
window = gdk.get_default_root_window()
size = window.get_size()
buff = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8, size[0], size[1])
buff = buff.get_from_drawable(window, window.get_colormap(),
0, 0, 0, 0, size[0], size[1])
if buff is None:
raise PeekUnableToPeek()
path = _gettempfile()
buff.save(path, "png")
screenshot = _file2screen(path)
screenshot.fmt = "png"
return screenshot
def __get_xkb_layout(self):
root_window = get_default_root_window()
if not root_window:
return 0
prop = root_window.property_get("_XKB_RULES_NAMES")[2]
list = prop.split('\0')
layout = 0
for data in list:
if data == "jp":
layout = 0
elif data == "us":
layout = 1
elif data.find("japan:nicola_f_bs") >= 0:
layout = 2
elif data.find("japan:") >= 0:
layout = 0
return layout
def __check_position(self):
bx = self.__cursor_location[0] + self.__toplevel.allocation.width
by = self.__cursor_location[1] + self.__toplevel.allocation.height
root_window = gdk.get_default_root_window()
sx, sy = root_window.get_size()
if bx > sx:
x = sx - self.__toplevel.allocation.width
else:
x = self.__cursor_location[0]
if by > sy:
y = sy - self.__toplevel.allocation.height
else:
y = self.__cursor_location[1]
self.move(x, y)