PyGtk client side windows demo
| #!/usr/bin/env python | |
| # Gtk+ client-side-windows demo in python | |
| # John Stowers | |
| import gobject | |
| import cairo | |
| import gtk | |
| import gtk.gdk as gdk | |
| #hacks for using functions not exposed in this pygtk version | |
| import ctypes | |
| cgdk = ctypes.CDLL("libgdk-x11-2.0.so") | |
| class _PyGObject_Functions(ctypes.Structure): | |
| _fields_ = [ | |
| ('register_class', | |
| ctypes.PYFUNCTYPE(ctypes.c_void_p, ctypes.c_char_p, | |
| ctypes.c_int, ctypes.py_object, | |
| ctypes.py_object)), | |
| ('register_wrapper', | |
| ctypes.PYFUNCTYPE(ctypes.c_void_p, ctypes.py_object)), | |
| ('register_sinkfunc', | |
| ctypes.PYFUNCTYPE(ctypes.py_object, ctypes.c_void_p)), | |
| ('lookupclass', | |
| ctypes.PYFUNCTYPE(ctypes.py_object, ctypes.c_int)), | |
| ('newgobj', | |
| ctypes.PYFUNCTYPE(ctypes.py_object, ctypes.c_void_p)), | |
| ] | |
| class PyGObjectCPAI(object): | |
| def __init__(self): | |
| addr = ctypes.pythonapi.PyCObject_AsVoidPtr( | |
| ctypes.py_object(gobject._PyGObject_API)) | |
| self._api = _PyGObject_Functions.from_address(addr) | |
| def pygobject_new(self, addr): | |
| return self._api.newgobj(addr) | |
| cgobject = PyGObjectCPAI() | |
| def gdk_offscreen_window_set_embedder(window, embedder): | |
| cgdk.gdk_offscreen_window_set_embedder(hash(window), hash(embedder)) | |
| def gdk_offscreen_window_get_pixmap(window): | |
| pm = cgdk.gdk_offscreen_window_get_pixmap(hash(window)) | |
| return cgobject.pygobject_new(ctypes.c_void_p(pm)) | |
| class GtkMirrorBin(gtk.Bin): | |
| __gsignals__ = { | |
| "damage_event" : "override" | |
| } | |
| def __init__(self): | |
| # gobject.GObject.__init__(self) | |
| gtk.Bin.__init__(self) | |
| self.child = None | |
| self.offscreen_window = None | |
| self.unset_flags(gtk.NO_WINDOW) | |
| def _to_child(self, widget_x, widget_y): | |
| return widget_x, widget_y | |
| def _to_parent(self, offscreen_x, offscreen_y): | |
| return offscreen_x, offscreen_y | |
| def _pick_offscreen_child(self, offscreen_window, widget_x, widget_y): | |
| print "pick_child" | |
| if self.child and self.child.flags() & gtk.VISIBLE: | |
| x,y = self._to_child(widget_x, widget_y) | |
| ca = self.child.allocation | |
| if (x >= 0 and x < ca.width and y >= 0 and y < ca.height): | |
| return self.offscreen_window | |
| return None | |
| def _offscreen_window_to_parent(self, offscreen_window, offscreen_x, offscreen_y, parent_x, parent_y): | |
| print "to_parent" | |
| x,y = self._to_parent(offscreen_x, offscreen_y) | |
| #FIXME: parent_x and parent_y are gpointers... | |
| px = ctypes.c_void_p(hash(parent_x)) | |
| px.contents = x | |
| py = ctypes.c_void_p(hash(parent_y)) | |
| py.contents = y | |
| def _offscreen_window_from_parent(self, parent_window, parent_x, parent_y, offscreen_x, offscreen_y): | |
| print "to_child" | |
| x,y = self._to_child(parent_x, parent_y) | |
| #FIXME: offscreen_x and offscreen_y are gpointers... | |
| ox = ctypes.c_void_p(hash(offscreen_x)) | |
| ox.contents = x | |
| oy = ctypes.c_void_p(hash(offscreen_y)) | |
| oy.contents = y | |
| def do_realize(self): | |
| print "do_realize" | |
| self.set_flags(gtk.REALIZED) | |
| border_width = self.border_width | |
| w = self.allocation.width - 2*border_width | |
| h = self.allocation.height - 2*border_width | |
| self.window = gdk.Window( | |
| self.get_parent_window(), | |
| x=self.allocation.x + border_width, | |
| y=self.allocation.y + border_width, | |
| width=w, | |
| height=h, | |
| window_type=gdk.WINDOW_CHILD, | |
| event_mask=self.get_events() | |
| | gdk.EXPOSURE_MASK | |
| | gdk.POINTER_MOTION_MASK | |
| | gdk.BUTTON_PRESS_MASK | |
| | gdk.BUTTON_RELEASE_MASK | |
| | gdk.SCROLL_MASK | |
| | gdk.ENTER_NOTIFY_MASK | |
| | gdk.LEAVE_NOTIFY_MASK, | |
| visual=self.get_visual(), | |
| colormap=self.get_colormap(), | |
| wclass=gdk.INPUT_OUTPUT) | |
| self.window.set_user_data(self) | |
| self.window.connect("pick-embedded-child", self._pick_offscreen_child) | |
| if self.child and self.child.flags() & gtk.VISIBLE: | |
| w = self.child.allocation.width | |
| h = self.child.allocation.height | |
| self.offscreen_window = gdk.Window( | |
| self.get_root_window(), | |
| x=self.allocation.x + border_width, | |
| y=self.allocation.y + border_width, | |
| width=w, | |
| height=h, | |
| window_type=gdk.WINDOW_OFFSCREEN, | |
| event_mask=self.get_events() | |
| | gdk.EXPOSURE_MASK | |
| | gdk.POINTER_MOTION_MASK | |
| | gdk.BUTTON_PRESS_MASK | |
| | gdk.BUTTON_RELEASE_MASK | |
| | gdk.SCROLL_MASK | |
| | gdk.ENTER_NOTIFY_MASK | |
| | gdk.LEAVE_NOTIFY_MASK, | |
| visual=self.get_visual(), | |
| colormap=self.get_colormap(), | |
| wclass=gdk.INPUT_OUTPUT) | |
| self.offscreen_window.set_user_data(self) | |
| if self.child: | |
| self.child.set_parent_window(self.offscreen_window) | |
| # self.offscreen_window.set_embedder(self.window) | |
| gdk_offscreen_window_set_embedder(self.offscreen_window, self.window) | |
| self.offscreen_window.connect("to-embedder", self._offscreen_window_to_parent) | |
| self.offscreen_window.connect("from-embedder", self._offscreen_window_from_parent) | |
| self.style.attach(self.window) | |
| self.style.set_background(self.window, gtk.STATE_NORMAL) | |
| self.style.set_background(self.offscreen_window, gtk.STATE_NORMAL) | |
| self.offscreen_window.show() | |
| def do_unrealize(self): | |
| self.offscreen_window.set_user_data(None) | |
| self.offscreen_window = None | |
| def do_add(self, widget): | |
| print "do_add" | |
| if not self.child: | |
| widget.set_parent_window(self.offscreen_window) | |
| widget.set_parent(self) | |
| self.child = widget | |
| else: | |
| print "GtkMirrorBind cannot have more than one child" | |
| def do_remove(self, widget): | |
| print "do_remove" | |
| was_visible = widget.flags() & gtk.VISIBLE | |
| if self.child == widget: | |
| widget.unparent() | |
| self.child = None | |
| if was_visible and (self.flags() & gtk.VISIBLE): | |
| self.queue_resize() | |
| def do_forall(self, internal, callback, data): | |
| print "do_forall" | |
| if self.child: | |
| callback(self.child, data) | |
| def do_size_request(self, r): | |
| print "do_size_request" | |
| cw, ch = 0,0; | |
| if self.child and (self.child.flags() & gtk.VISIBLE): | |
| cw, ch = self.child.size_request() | |
| r.width = self.border_width * 2 + cw + 10 | |
| r.height = self.border_width * 2 + ch * 2 + 10 | |
| def do_child_type(self): | |
| print "do_child_type" | |
| #FIXME: This never seems to get called... | |
| if self.child: | |
| return None | |
| return gtk.Widget.__gtype__ | |
| def do_size_allocate(self, allocation): | |
| print "do_size_allocate" | |
| self.allocation = allocation | |
| border_width = self.border_width | |
| w = self.allocation.width - 2*border_width | |
| h = self.allocation.height - 2*border_width | |
| if self.flags() & gtk.REALIZED: | |
| self.window.move_resize( | |
| allocation.x + border_width, | |
| allocation.y + border_width, | |
| w,h) | |
| if self.child and self.child.flags() & gtk.VISIBLE: | |
| cw, ch = self.child.get_child_requisition() | |
| ca = gtk.gdk.Rectangle(x=0,y=0,width=cw,height=ch) | |
| if self.flags() & gtk.REALIZED: | |
| self.offscreen_window.move_resize( | |
| allocation.x + border_width, | |
| allocation.y + border_width, | |
| cw, ch) | |
| self.child.size_allocate(ca) | |
| def do_damage_event(self, eventexpose): | |
| print "do_damage" | |
| #invalidate the whole window | |
| self.window.invalidate_rect(None, False) | |
| return True | |
| def do_expose_event(self, event): | |
| print "do_expose" | |
| if self.flags() & gtk.VISIBLE and self.flags() & gtk.MAPPED: | |
| if event.window == self.window: | |
| #FIXME: beware pointers... | |
| pm = gdk_offscreen_window_get_pixmap(self.offscreen_window) | |
| w,h = pm.get_size() | |
| print "expose both %dx%d" % (w,h) | |
| cr = self.window.cairo_create() | |
| cr.save() | |
| cr.rectangle(0,0,w,h) | |
| cr.clip() | |
| #paint the offscreen child | |
| cr.set_source_pixmap(pm, 0, 0) | |
| cr.paint() | |
| cr.restore() | |
| matrix = cairo.Matrix(1.0, 0.0, 0.3, 1.0, 0.0, 0.0) | |
| matrix.scale(1.0, -1.0) | |
| matrix.translate(-10, -3 * h - 10) | |
| cr.transform(matrix) | |
| cr.rectangle(0,h,w,h) | |
| cr.clip() | |
| cr.set_source_pixmap(pm, 0, h) | |
| #create linear gradient | |
| mask = cairo.LinearGradient(0.0, h, 0.0, 2*h) | |
| mask.add_color_stop_rgba(0.0, 0.0, 0.0, 0.0, 0.0) | |
| mask.add_color_stop_rgba(0.25, 0.0, 0.0, 0.0, 0.01) | |
| mask.add_color_stop_rgba(0.5, 0.0, 0.0, 0.0, 0.25) | |
| mask.add_color_stop_rgba(0.75, 0.0, 0.0, 0.0, 0.5) | |
| mask.add_color_stop_rgba(1.0, 0.0, 0.0, 0.0, 1.0) | |
| #paint the reflection | |
| cr.mask(mask) | |
| elif event.window == self.offscreen_window: | |
| print "expose offscreen" | |
| self.style.paint_flat_box( | |
| event.window, | |
| gtk.STATE_NORMAL, gtk.SHADOW_NONE, | |
| event.area, self, "blah", | |
| 0, 0, -1, -1) | |
| if self.child: | |
| self.propagate_expose( | |
| self.child, | |
| event) | |
| return False | |
| gobject.type_register(GtkMirrorBin) | |
| if __name__ == "__main__": | |
| w = gtk.Window() | |
| w.set_border_width(10) | |
| hb = gtk.HBox(6) | |
| hb.pack_start(gtk.Button(stock=gtk.STOCK_GO_BACK)) | |
| hb.pack_start(gtk.Entry()) | |
| bin = GtkMirrorBin() | |
| bin.add(hb) | |
| w.add(bin) | |
| w.show_all() | |
| gtk.main() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment