Python X Library

Revision: 134
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=134&view=rev
Author:   funkiedamouse
Date:     2009-06-02 21:14:36 +0000 (Tue, 02 Jun 2009)

Log Message:
-----------
Implemented RANDR extension, and added xrandr and xinerama examples.

Modified Paths:
--------------
    trunk/Xlib/ext/__init__.py

Added Paths:
-----------
    trunk/Xlib/ext/randr.py
    trunk/examples/xinerama.py
    trunk/examples/xrandr.py

Modified: trunk/Xlib/ext/__init__.py
===================================================================
--- trunk/Xlib/ext/__init__.py	2009-04-11 23:18:15 UTC (rev 133)
+++ trunk/Xlib/ext/__init__.py	2009-06-02 21:14:36 UTC (rev 134)
@@ -26,6 +26,7 @@
     ('XINERAMA', 'xinerama'),
     ('RECORD', 'record'),
     ('Composite', 'composite'),
+    ('RANDR', 'randr'),
     ]
 
 __all__ = map(lambda x: x[1], __extensions__)

Added: trunk/Xlib/ext/randr.py
===================================================================
--- trunk/Xlib/ext/randr.py	                        (rev 0)
+++ trunk/Xlib/ext/randr.py	2009-06-02 21:14:36 UTC (rev 134)
@@ -0,0 +1,1183 @@
+# Xlib.ext.randr -- RandR extension module
+#
+#    Copyright (C) 2006 Mike Meyer <mwm@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+
+"""RandR - provide access to the RandR extension information.
+
+This implementation is based off version 1.3 of the XRandR protocol, and may
+not be compatible with other versions.
+
+Version 1.2 of the protocol is documented at:
+http://cgit.freedesktop.org/xorg/proto/randrproto/tree/randrproto.txt
+
+"""
+
+
+from Xlib import X
+from Xlib.protocol import rq, structs
+
+extname = 'RANDR'
+
+
+# Event codes #
+RRScreenChangeNotify        = 0
+
+# V1.2 additions
+RRNotify                    = 1
+
+# RRNotify Subcodes
+RRNotify_CrtcChange         = 0
+RRNotify_OutputChange       = 1
+RRNotify_OutputProperty     = 2
+
+
+# Event selection bits #
+RRScreenChangeNotifyMask    = (1 << 0)
+
+# V1.2 additions
+RRCrtcChangeNotifyMask      = (1 << 1)
+RROutputChangeNotifyMask    = (1 << 2)
+RROutputPropertyNotifyMask  = (1 << 3)
+
+
+# Constants #
+SetConfigSuccess            = 0
+SetConfigInvalidConfigTime  = 1
+SetConfigInvalidTime        = 2
+SetConfigFailed             = 3
+
+# used in the rotation field; rotation and reflection in 0.1 proto.
+Rotate_0                    = 1
+Rotate_90                   = 2
+Rotate_180                  = 4
+Rotate_270                  = 8
+
+# new in 1.0 protocol, to allow reflection of screen
+Reflect_X                   = 16
+Reflect_Y                   = 32
+
+# new in 1.2 protocol
+HSyncPositive               = 0x00000001
+HSyncNegative               = 0x00000002
+VSyncPositive               = 0x00000004
+VSyncNegative               = 0x00000008
+Interlace                   = 0x00000010
+DoubleScan                  = 0x00000020
+CSync                       = 0x00000040
+CSyncPositive               = 0x00000080
+CSyncNegative               = 0x00000100
+HSkewPresent                = 0x00000200
+BCast                       = 0x00000400
+PixelMultiplex              = 0x00000800
+DoubleClock                 = 0x00001000
+ClockDivideBy2              = 0x00002000
+
+# event types?
+Connected                   = 0
+Disconnected                = 1
+UnknownConnection           = 2
+
+# Conventional RandR output properties
+PROPERTY_RANDR_EDID         = "EDID"
+PROPERTY_SIGNAL_FORMAT      = "SignalFormat"
+PROPERTY_SIGNAL_PROPERTIES  = "SignalProperties"
+PROPERTY_CONNECTOR_TYPE     = "ConnectorType"
+PROPERTY_CONNECTOR_NUMBER   = "ConnectorNumber"
+PROPERTY_COMPATIBILITY_LIST = "CompatibilityList"
+PROPERTY_CLONE_LIST         = "CloneList"
+
+# subpixel order - TODO: These constants are part of the RENDER extension and
+# should be moved there if/when that extension is added to python-xlib.
+SubPixelUnknown             = 0
+SubPixelHorizontalRGB       = 1
+SubPixelHorizontalBGR       = 2
+SubPixelVerticalRGB         = 3
+SubPixelVerticalBGR         = 4
+SubPixelNone                = 5
+
+
+# Error Codes #
+BadRROutput                 = 0
+BadRRCrtc                   = 1
+BadRRMode                   = 2
+
+
+# Data Structures #
+
+RandR_ScreenSizes = rq.Struct(
+        rq.Card16('width_in_pixels'),
+        rq.Card16('height_in_pixels'),
+        rq.Card16('width_in_millimeters'),
+        rq.Card16('height_in_millimeters'),
+        )
+
+
+RandR_ModeInfo = rq.Struct(
+        rq.Card32('id'),
+        rq.Card16('width'),
+        rq.Card16('height'),
+        rq.Card32('dot_clock'),
+        rq.Card16('h_sync_start'),
+        rq.Card16('h_sync_end'),
+        rq.Card16('h_total'),
+        rq.Card16('h_skew'),
+        rq.Card16('v_sync_start'),
+        rq.Card16('v_sync_end'),
+        rq.Card16('v_total'),
+        rq.Card16('name_length'),
+        rq.Card32('flags'),
+        )
+
+RandR_Rates = rq.Struct(
+        rq.LengthOf('rates', 2),
+        rq.List('rates', rq.Card16Obj)
+        )
+
+# TODO: This struct is part of the RENDER extension and should be moved there
+# if/when that extension is added to python-xlib.
+Render_Transform = rq.Struct(
+        rq.Card32('matrix11'), #FIXME: All of these are listed as FIXED in the protocol header.
+        rq.Card32('matrix12'),
+        rq.Card32('matrix13'),
+        rq.Card32('matrix21'),
+        rq.Card32('matrix22'),
+        rq.Card32('matrix23'),
+        rq.Card32('matrix31'),
+        rq.Card32('matrix32'),
+        rq.Card32('matrix33'),
+        )
+
+
+# Requests #
+
+class QueryVersion(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(0),
+        rq.RequestLength(),
+        rq.Card32('major_version'),
+        rq.Card32('minor_version'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('major_version'),
+        rq.Card32('minor_version'),
+        rq.Pad(16),
+        )
+
+def query_version(self):
+    """Get the current version of the RandR extension.
+
+    """
+    return QueryVersion(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        major_version=1,
+        minor_version=3,
+        )
+
+
+class _1_0SetScreenConfig(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(2),
+        rq.RequestLength(),
+        rq.Drawable('drawable'),
+        rq.Card32('timestamp'),
+        rq.Card32('config_timestamp'),
+        rq.Card16('size_id'),
+        rq.Card16('rotation'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('new_timestamp'),
+        rq.Card32('new_config_timestamp'),
+        rq.Window('root'),
+        rq.Card16('subpixel_order'),
+        rq.Pad(10),
+        )
+
+def _1_0set_screen_config(self, size_id, rotation, config_timestamp, timestamp=X.CurrentTime):
+    """Sets the screen to the specified size and rotation.
+
+    """
+    return _1_0SetScreenConfig(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        drawable=self,
+        timestamp=timestamp,
+        config_timestamp=config_timestamp,
+        size_id=size_id,
+        rotation=rotation,
+        )
+
+
+class SetScreenConfig(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(2),
+        rq.RequestLength(),
+        rq.Drawable('drawable'),
+        rq.Card32('timestamp'),
+        rq.Card32('config_timestamp'),
+        rq.Card16('size_id'),
+        rq.Card16('rotation'),
+        rq.Card16('rate'), # added in version 1.1
+        rq.Pad(2),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('new_timestamp'),
+        rq.Card32('new_config_timestamp'),
+        rq.Window('root'),
+        rq.Card16('subpixel_order'),
+        rq.Pad(10),
+        )
+
+def set_screen_config(self, size_id, rotation, config_timestamp, rate=0, timestamp=X.CurrentTime):
+    """Sets the screen to the specified size, rate, rotation and reflection.
+
+    rate can be 0 to have the server select an appropriate rate.
+
+    """
+    return SetScreenConfig(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        drawable=self,
+        timestamp=timestamp,
+        config_timestamp=config_timestamp,
+        size_id=size_id,
+        rotation=rotation,
+        rate=rate,
+        )
+
+
+class SelectInput(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(4),
+        rq.RequestLength(),
+        rq.Window('window'),
+        rq.Card16('mask'),
+        rq.Pad(2),
+        )
+
+def select_input(self, mask):
+    return SelectInput(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        mask=mask,
+        )
+
+
+class GetScreenInfo(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(5),
+        rq.RequestLength(),
+        rq.Window('window'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('set_of_rotations'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Window('root'),
+        rq.Card32('timestamp'),
+        rq.Card32('config_timestamp'),
+        rq.LengthOf('sizes', 2),
+        rq.Card16('size_id'),
+        rq.Card16('rotation'),
+        rq.Card16('rate'), # added in version 1.1
+        rq.Card16('n_rate_ents'), # XCB's protocol description disagrees with the X headers on this; ignoring.
+        rq.Pad(2),
+        rq.List('sizes', RandR_ScreenSizes),
+        #rq.List('rates', RandR_Rates) #FIXME: Why does uncommenting this cause an error?
+        )
+
+def get_screen_info(self):
+    """Retrieve information about the current and available configurations for
+    the screen associated with this window.
+
+    """
+    return GetScreenInfo(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        )
+
+
+# version 1.2
+
+class GetScreenSizeRange(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(6),
+        rq.RequestLength(),
+        rq.Window('window'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card16('min_width'),
+        rq.Card16('min_height'),
+        rq.Card16('max_width'),
+        rq.Card16('max_height'),
+        rq.Pad(16),
+        )
+
+def get_screen_size_range(self):
+    """Retrieve the range of possible screen sizes. The screen may be set to
+	any size within this range.
+
+    """
+    return GetScreenSizeRange(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        )
+
+
+class SetScreenSize(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(7),
+        rq.RequestLength(),
+        rq.Window('window'),
+        rq.Card16('width'),
+        rq.Card16('height'),
+        rq.Card32('width_in_millimeters'),
+        rq.Card32('height_in_millimeters'),
+        )
+
+def set_screen_size(self, width, height, width_in_millimeters=None, height_in_millimeters=None):
+    return SetScreenSize(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        width=width,
+        height=height,
+        width_in_millimeters=width_in_millimeters,
+        height_in_millimeters=height_in_millimeters,
+        )
+
+
+class GetScreenResources(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(8),
+        rq.RequestLength(),
+        rq.Window('window'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('timestamp'),
+        rq.Card32('config_timestamp'),
+        rq.LengthOf('crtcs', 2),
+        rq.LengthOf('outputs', 2),
+        rq.LengthOf('modes', 2),
+        rq.LengthOf('mode_names', 2),
+        rq.Pad(8),
+        rq.List('crtcs', rq.Card32Obj),
+        rq.List('outputs', rq.Card32Obj),
+        rq.List('modes', RandR_ModeInfo),
+        rq.String8('mode_names'),
+        )
+
+def get_screen_resources(self):
+    return GetScreenResources(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        )
+
+
+class GetOutputInfo(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(9),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        rq.Card32('config_timestamp'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('timestamp'),
+        rq.Card32('crtc'),
+        rq.Card32('mm_width'),
+        rq.Card32('mm_height'),
+        rq.Card8('connection'),
+        rq.Card8('subpixel_order'),
+        rq.LengthOf('crtcs', 2),
+        rq.LengthOf('modes', 2),
+        rq.LengthOf('preferred', 2),
+        rq.LengthOf('clones', 2),
+        rq.LengthOf('name', 2),
+        rq.List('crtcs', rq.Card32Obj),
+        rq.List('modes', rq.Card32Obj),
+        rq.List('preferred', rq.Card32Obj),
+        rq.List('clones', rq.Card32Obj),
+        rq.String8('name'),
+        )
+
+def get_output_info(self, output, config_timestamp):
+    return GetOutputInfo(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        config_timestamp=config_timestamp,
+        )
+
+
+class ListOutputProperties(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(10),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.LengthOf('atoms', 2),
+        rq.Pad(22),
+        rq.List('atoms', rq.Card32Obj),
+        )
+
+def list_output_properties(self, output):
+    return ListOutputProperties (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        )
+
+
+class QueryOutputProperty(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(11),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        rq.Card32('property'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Bool('pending'),
+        rq.Bool('range'),
+        rq.Bool('immutable'),
+        rq.Pad(21),
+        rq.List('valid_values', rq.Card32Obj),
+        )
+
+def query_output_property(self, output, property):
+    return QueryOutputProperty (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        property=property,
+        )
+
+
+class ConfigureOutputProperty (rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(12),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        rq.Card32('property'),
+        rq.Bool('pending'),
+        rq.Bool('range'),
+        rq.Pad(2),
+        rq.List('valid_values', rq.Card32Obj),
+        )
+
+def configure_output_property (self, output, property):
+    return ConfigureOutputProperty (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        property=property,
+        )
+
+
+class ChangeOutputProperty(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(13),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        rq.Card32('property'),
+        rq.Card32('type'),
+        rq.Format('value', 1),
+        rq.Card8('mode'),
+        rq.Pad(2),
+        rq.LengthOf('value', 4),
+        rq.List('value', rq.Card8Obj),
+        )
+
+def change_output_property(self, output, property, type, format, mode, nUnits):
+    return ChangeOutputProperty(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        property=property,
+        type=type,
+        format=format,
+        mode=mode,
+        nUnits=nUnits,
+        )
+
+
+class DeleteOutputProperty(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(14),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        rq.Card32('property'),
+        )
+
+def delete_output_property(self, output, property):
+    return DeleteOutputProperty(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        property=property,
+        )
+
+
+class GetOutputProperty(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(15),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        rq.Card32('property'),
+        rq.Card32('type'),
+        rq.Card32('long_offset'),
+        rq.Card32('long_length'),
+        rq.Bool('delete'),
+        rq.Bool('pending'),
+        rq.Pad(2),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Format('value', 1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('property_type'),
+        rq.Card32('bytes_after'),
+        rq.LengthOf('value', 4),
+        rq.Pad(12),
+        rq.List('value', rq.Card8Obj),
+        )
+
+def get_output_property(self, output, property, type, longOffset, longLength):
+    return GetOutputProperty(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        property=property,
+        type=type,
+        longOffset=longOffset,
+        longLength=longLength,
+        )
+
+
+class CreateMode(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(16),
+        rq.RequestLength(),
+        rq.Window('window'),
+        rq.Object('mode', RandR_ModeInfo),
+        rq.String8('name'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('mode'),
+        rq.Pad(20),
+        )
+
+def create_mode(self):
+    return CreateMode (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        )
+
+
+class DestroyMode(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(17),
+        rq.RequestLength(),
+        rq.Card32('mode'),
+        )
+
+def destroy_mode(self, mode):
+    return DestroyMode(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        mode=mode,
+        )
+
+
+class AddOutputMode(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(18),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        rq.Card32('mode'),
+        )
+
+def add_output_mode(self):
+    return AddOutputMode(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        mode=mode,
+        )
+
+
+class DeleteOutputMode(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(19),
+        rq.RequestLength(),
+        rq.Card32('output'),
+        rq.Card32('mode'),
+        )
+
+def delete_output_mode(self):
+    return DeleteOutputMode(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        output=output,
+        mode=mode,
+        )
+
+
+class GetCrtcInfo(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(20),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        rq.Card32('config_timestamp'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('timestamp'),
+        rq.Card16('width'),
+        rq.Card16('height'),
+        rq.Card32('mode'),
+        rq.Card16('rotation'),
+        rq.Card16('possible_rotations'),
+        rq.LengthOf('outputs', 2),
+        rq.LengthOf('possible_outputs', 2),
+        rq.List('outputs', rq.Card32Obj),
+        rq.List('possible_outputs', rq.Card32Obj),
+        )
+
+def get_crtc_info(self, crtc, config_timestamp):
+    return GetCrtcInfo (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        config_timestamp=config_timestamp,
+        )
+
+
+class SetCrtcConfig(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(21),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        rq.Card32('timestamp'),
+        rq.Card32('config_timestamp'),
+        rq.Int16('x'),
+        rq.Int16('y'),
+        rq.Card32('mode'),
+        rq.Card16('rotation'),
+        rq.Pad(2),
+        rq.List('outputs', rq.Card32Obj),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('new_timestamp'),
+        rq.Pad(20),
+        )
+
+def set_crtc_config(self, crtc, config_timestamp, mode, rotation, timestamp=X.CurrentTime):
+    return SetCrtcConfig (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        config_timestamp=config_timestamp,
+        mode=mode,
+        rotation=rotation,
+        timestamp=timestamp,
+        )
+
+
+class GetCrtcGammaSize(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(22),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card16('size'),
+        rq.Pad(22),
+        )
+
+def get_crtc_gamma_size(self, crtc):
+    return GetCrtcGammaSize (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        )
+
+
+class GetCrtcGamma(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(23),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card16('size'),
+        rq.Pad(22),
+        rq.List('red', rq.Card16Obj),
+        rq.List('green', rq.Card16Obj),
+        rq.List('blue', rq.Card16Obj),
+        )
+
+def get_crtc_gamma(self, crtc):
+    return GetCrtcGamma (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        )
+
+
+class SetCrtcGamma(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(24),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        rq.Card16('size'),
+        rq.Pad(2),
+        rq.List('red', rq.Card16Obj),
+        rq.List('green', rq.Card16Obj),
+        rq.List('blue', rq.Card16Obj),
+        )
+
+def set_crtc_gamma(self, crtc, size):
+    return SetCrtcGamma(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        size=size,
+        )
+
+
+# version 1.3
+
+class GetScreenResourcesCurrent(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(25),
+        rq.RequestLength(),
+        rq.Window('window'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('timestamp'),
+        rq.Card32('config_timestamp'),
+        rq.LengthOf('crtcs', 2),
+        rq.LengthOf('outputs', 2),
+        rq.LengthOf('modes', 2),
+        rq.LengthOf('names', 2),
+        rq.Pad(8),
+        rq.List('crtcs', rq.Card32Obj),
+        rq.List('outputs', rq.Card32Obj),
+        rq.List('modes', RandR_ModeInfo),
+        rq.String8('names'),
+        )
+
+def get_screen_resources_current(self):
+    return GetScreenResourcesCurrent(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        )
+
+
+class SetCrtcTransform(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(26),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        rq.Object('transform', Render_Transform),
+        rq.LengthOf('filter_name', 2),
+        rq.Pad(2),
+        rq.String8('filter_name'),
+        rq.List('filter_params', rq.Card32Obj), #FIXME: The protocol says FIXED? http://cgit.freedesktop.org/xorg/proto/randrproto/tree/randrproto.txt#n2161
+        )
+
+def set_crtc_transform(self, crtc, n_bytes_filter):
+    return SetCrtcTransform(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        n_bytes_filter=n_bytes_filter,
+        )
+
+
+class GetCrtcTransform(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(27),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Object('pending_transform', Render_Transform),
+        rq.Bool('has_transforms'),
+        rq.Pad(3),
+        rq.Object('current_transform', Render_Transform),
+        rq.Pad(4),
+        rq.LengthOf('pending_filter_name', 2),
+        rq.LengthOf('pending_filter_params', 2),
+        rq.LengthOf('current_filter_name', 2),
+        rq.LengthOf('current_filter_params', 2),
+        rq.String8('pending_filter_name'),
+        rq.List('pending_filter_params', rq.Card32Obj), #FIXME: The protocol says FIXED? http://cgit.freedesktop.org/xorg/proto/randrproto/tree/randrproto.txt#n2161
+        rq.String8('current_filter_name'),
+        rq.List('current_filter_params', rq.Card32Obj), #FIXME: The protocol says FIXED? http://cgit.freedesktop.org/xorg/proto/randrproto/tree/randrproto.txt#n2161
+        )
+
+def get_crtc_transform(self, crtc):
+    return GetCrtcTransform(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        )
+
+
+class GetPanning(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(28),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('timestamp'),
+        rq.Card16('left'),
+        rq.Card16('top'),
+        rq.Card16('width'),
+        rq.Card16('height'),
+        rq.Card16('track_left'),
+        rq.Card16('track_top'),
+        rq.Card16('track_width'),
+        rq.Card16('track_height'),
+        rq.Int16('border_left'),
+        rq.Int16('border_top'),
+        rq.Int16('border_right'),
+        rq.Int16('border_bottom'),
+        )
+
+def get_panning(self, crtc):
+    return GetPanning (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        )
+
+
+class SetPanning(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(29),
+        rq.RequestLength(),
+        rq.Card32('crtc'),
+        rq.Card32('timestamp'),
+        rq.Card16('left'),
+        rq.Card16('top'),
+        rq.Card16('width'),
+        rq.Card16('height'),
+        rq.Card16('track_left'),
+        rq.Card16('track_top'),
+        rq.Card16('track_width'),
+        rq.Card16('track_height'),
+        rq.Int16('border_left'),
+        rq.Int16('border_top'),
+        rq.Int16('border_right'),
+        rq.Int16('border_bottom'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Card8('status'),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('new_timestamp'),
+        rq.Pad(20),
+        )
+
+def set_panning(self, crtc, left, top, width, height, track_left, track_top, track_width, track_height, border_left, border_top, border_width, border_height, timestamp=X.CurrentTime):
+    return SetPanning (
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        crtc=crtc,
+        left=left,
+        top=top,
+        width=width,
+        height=height,
+        track_left=track_left,
+        track_top=track_top,
+        track_width=track_width,
+        track_height=track_height,
+        border_left=border_left,
+        border_top=border_top,
+        border_width=border_width,
+        border_height=border_height,
+        timestamp=timestamp,
+        )
+
+
+class SetOutputPrimary(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(30),
+        rq.RequestLength(),
+        rq.Window('window'),
+        rq.Card32('output'),
+        )
+
+def set_output_primary(self, output):
+    return SetOutputPrimary(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        output=output,
+        )
+
+
+class GetOutputPrimary(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(31),
+        rq.RequestLength(),
+        rq.Window('window'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('output'),
+        rq.Pad(20),
+        )
+
+def get_output_primary(self):
+    return GetOutputPrimary(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        )
+
+
+# Events #
+
+class ScreenChangeNotify(rq.Event):
+    _code = None
+    _fields = rq.Struct(
+        rq.Card8('type'),
+        rq.Card8('rotation'),
+        rq.Card16('sequence_number'),
+        rq.Card32('timestamp'),
+        rq.Card32('config_timestamp'),
+        rq.Window('root'),
+        rq.Window('window'),
+        rq.Card16('size_id'),
+        rq.Card16('subpixel_order'),
+        rq.Card16('width_in_pixels'),
+        rq.Card16('height_in_pixels'),
+        rq.Card16('width_in_millimeters'),
+        rq.Card16('height_in_millimeters'),
+        )
+
+
+class CrtcChangeNotify(rq.Event):
+    _code = None
+    _fields = rq.Struct(
+        rq.Card8('type'),
+        rq.Card8('sub_code'),
+        rq.Card16('sequence_number'),
+        rq.Card32('timestamp'),
+        rq.Window('window'),
+        rq.Card32('crtc'),
+        rq.Card32('mode'),
+        rq.Card16('rotation'),
+        rq.Pad(2),
+        rq.Int16('x'),
+        rq.Int16('y'),
+        rq.Card16('width'),
+        rq.Card16('height'),
+        )
+
+
+class OutputChangeNotify(rq.Event):
+    _code = None
+    _fields = rq.Struct(
+        rq.Card8('type'),
+        rq.Card8('sub_code'),
+        rq.Card16('sequence_number'),
+        rq.Card32('timestamp'),
+        rq.Card32('config_timestamp'),
+        rq.Window('window'),
+        rq.Card32('output'),
+        rq.Card32('crtc'),
+        rq.Card32('mode'),
+        rq.Card16('rotation'),
+        rq.Card8('connection'),
+        rq.Card8('subpixel_order'),
+        )
+
+
+class OutputPropertyNotify(rq.Event):
+    _code = None
+    _fields = rq.Struct(
+        rq.Card8('type'),
+        rq.Card8('sub_code'),
+        rq.Card16('sequence_number'),
+        rq.Window('window'),
+        rq.Card32('output'),
+        rq.Card32('atom'),
+        rq.Card32('timestamp'),
+        rq.Card8('state'),
+        rq.Pad(11),
+        )
+
+
+# Initialization #
+
+def init(disp, info):
+    print info.__class__
+
+    disp.extension_add_method('display', 'xrandr_query_version', query_version)
+    disp.extension_add_method('window', 'xrandr_select_input', select_input)
+    disp.extension_add_method('window', 'xrandr_get_screen_info', get_screen_info)
+    disp.extension_add_method('drawable', 'xrandr_1_0set_screen_config', _1_0set_screen_config)
+    disp.extension_add_method('drawable', 'xrandr_set_screen_config', set_screen_config)
+    disp.extension_add_method('window', 'xrandr_get_screen_size_range', get_screen_size_range)
+    disp.extension_add_method('window', 'xrandr_set_screen_size', set_screen_size)
+    disp.extension_add_method('window', 'xrandr_get_screen_resources', get_screen_resources)
+    disp.extension_add_method('display', 'xrandr_get_output_info', get_output_info)
+    disp.extension_add_method('display', 'xrandr_list_output_properties', list_output_properties)
+    disp.extension_add_method('display', 'xrandr_query_output_property', query_output_property)
+    disp.extension_add_method('display', 'xrandr_configure_output_property ', configure_output_property )
+    disp.extension_add_method('display', 'xrandr_change_output_property', change_output_property)
+    disp.extension_add_method('display', 'xrandr_delete_output_property', delete_output_property)
+    disp.extension_add_method('display', 'xrandr_get_output_property', get_output_property)
+    disp.extension_add_method('window', 'xrandr_create_mode', create_mode)
+    disp.extension_add_method('display', 'xrandr_destroy_mode', destroy_mode)
+    disp.extension_add_method('display', 'xrandr_add_output_mode', add_output_mode)
+    disp.extension_add_method('display', 'xrandr_delete_output_mode', delete_output_mode)
+    disp.extension_add_method('display', 'xrandr_get_crtc_info', get_crtc_info)
+    disp.extension_add_method('display', 'xrandr_set_crtc_config', set_crtc_config)
+    disp.extension_add_method('display', 'xrandr_get_crtc_gamma_size', get_crtc_gamma_size)
+    disp.extension_add_method('display', 'xrandr_get_crtc_gamma', get_crtc_gamma)
+    disp.extension_add_method('display', 'xrandr_set_crtc_gamma', set_crtc_gamma)
+    disp.extension_add_method('window', 'xrandr_get_screen_resources_current', get_screen_resources_current)
+    disp.extension_add_method('display', 'xrandr_set_crtc_transform', set_crtc_transform)
+    disp.extension_add_method('display', 'xrandr_get_crtc_transform', get_crtc_transform)
+    disp.extension_add_method('window', 'xrandr_set_output_primary', set_output_primary)
+    disp.extension_add_method('window', 'xrandr_get_output_primary', get_output_primary)
+    disp.extension_add_method('display', 'xrandr_get_panning', get_panning)
+    disp.extension_add_method('display', 'xrandr_set_panning', set_panning)
+
+    disp.extension_add_event(info.first_event, ScreenChangeNotify)
+    disp.extension_add_event(info.first_event + 1, CrtcChangeNotify)
+    disp.extension_add_event(info.first_event + 2, OutputChangeNotify)
+    disp.extension_add_event(info.first_event + 3, OutputPropertyNotify)
+
+    #disp.extension_add_error(BadRROutput, BadRROutputError)
+    #disp.extension_add_error(BadRRCrtc, BadRRCrtcError)
+    #disp.extension_add_error(BadRRMode, BadRRModeError)

Added: trunk/examples/xinerama.py
===================================================================
--- trunk/examples/xinerama.py	                        (rev 0)
+++ trunk/examples/xinerama.py	2009-06-02 21:14:36 UTC (rev 134)
@@ -0,0 +1,145 @@
+#!/usr/bin/python
+#
+# examples/xinerama.py -- demonstrate the Xinerama extension
+#
+#    Copyright (C) 2009 David H. Bronke <whitelynx@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+import sys, os, pprint
+
+# Change path so we find Xlib
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+
+from Xlib import X, display, Xutil
+from Xlib.ext import xinerama
+
+# Application window (only one)
+class Window:
+    def __init__(self, display):
+        self.d = display
+
+        # Check for extension
+        if not self.d.has_extension('XINERAMA'):
+            sys.stderr.write('%s: server does not have the XINERAMA extension\n'
+                             % sys.argv[0])
+            print self.d.query_extension('XINERAMA')
+            sys.stderr.write("\n".join(self.d.list_extensions()))
+            if self.d.query_extension('XINERAMA') is None:
+                sys.exit(1)
+
+        # print version
+        r = self.d.xinerama_query_version()
+        print 'XINERAMA version %d.%d' % (r.major_version, r.minor_version)
+
+
+        # Grab the current screen
+        self.screen = self.d.screen()
+
+        self.window = self.screen.root.create_window(
+            50, 50, 300, 200, 2,
+            self.screen.root_depth,
+            X.InputOutput,
+            X.CopyFromParent,
+
+            # special attribute values
+            background_pixel = self.screen.white_pixel,
+            event_mask = (X.ExposureMask |
+                          X.StructureNotifyMask |
+                          X.ButtonPressMask |
+                          X.ButtonReleaseMask |
+                          X.Button1MotionMask),
+            colormap = X.CopyFromParent,
+            )
+
+        self.gc = self.window.create_gc(
+            foreground = self.screen.black_pixel,
+            background = self.screen.white_pixel,
+            )
+
+        # Set some WM info
+
+        self.WM_DELETE_WINDOW = self.d.intern_atom('WM_DELETE_WINDOW')
+        self.WM_PROTOCOLS = self.d.intern_atom('WM_PROTOCOLS')
+
+        self.window.set_wm_name('Xlib example: xinerama.py')
+        self.window.set_wm_icon_name('xinerama.py')
+        self.window.set_wm_class('xinerama', 'XlibExample')
+
+        self.window.set_wm_protocols([self.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()
+
+        self.pp = pprint.PrettyPrinter(indent=4)
+
+        print "Xinerama active:", bool(self.d.xinerama_is_active())
+
+        print "Screen info:"
+        self.pp.pprint(self.d.xinerama_query_screens()._data)
+
+        # FIXME: This doesn't work!
+        #print "Xinerama info:"
+        #self.pp.pprint(self.d.xinerama_get_info(self.d.screen().root_visual)._data)
+
+        print "Xinerama state:"
+        self.pp.pprint(self.window.xinerama_get_state()._data)
+
+        print "Screen count:"
+        self.pp.pprint(self.window.xinerama_get_screen_count()._data)
+
+        for screennum in range(self.window.xinerama_get_screen_count().screen_count):
+            print "Screen %d size:" % (screennum, )
+            self.pp.pprint(self.window.xinerama_get_screen_size(screennum)._data)
+
+    def parseModes(self, mode_names, modes):
+        lastIdx = 0
+        modedatas = dict()
+        for mode in modes:
+            modedata = dict(mode._data)
+            modedata['name'] = mode_names[lastIdx:lastIdx + modedata['name_length']]
+            modedatas[modedata['id']] = modedata
+            lastIdx += modedata['name_length']
+        return modedatas
+
+    # Main loop, handling events
+    def loop(self):
+        current = None
+        while 1:
+            e = self.d.next_event()
+
+            # Window has been destroyed, quit
+            if e.type == X.DestroyNotify:
+                sys.exit(0)
+
+            # Somebody wants to tell us something
+            elif e.type == X.ClientMessage:
+                if e.client_type == self.WM_PROTOCOLS:
+                    fmt, data = e.data
+                    if fmt == 32 and data[0] == self.WM_DELETE_WINDOW:
+                        sys.exit(0)
+
+
+if __name__ == '__main__':
+    Window(display.Display()).loop()
+

Added: trunk/examples/xrandr.py
===================================================================
--- trunk/examples/xrandr.py	                        (rev 0)
+++ trunk/examples/xrandr.py	2009-06-02 21:14:36 UTC (rev 134)
@@ -0,0 +1,180 @@
+#!/usr/bin/python
+#
+# examples/xrandr.py -- demonstrate the RandR extension
+#
+#    Copyright (C) 2009 David H. Bronke <whitelynx@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+import sys, os, pprint
+
+# Change path so we find Xlib
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+
+from Xlib import X, display, Xutil
+from Xlib.ext import randr
+
+# Application window (only one)
+class Window:
+    def __init__(self, display):
+        self.d = display
+
+        # Check for extension
+        if not self.d.has_extension('RANDR'):
+            sys.stderr.write('%s: server does not have the RANDR extension\n'
+                             % sys.argv[0])
+            print self.d.query_extension('RANDR')
+            sys.stderr.write("\n".join(self.d.list_extensions()))
+            if self.d.query_extension('RANDR') is None:
+                sys.exit(1)
+
+        # print version
+        r = self.d.xrandr_query_version()
+        print 'RANDR version %d.%d' % (r.major_version, r.minor_version)
+
+
+        # Grab the current screen
+        self.screen = self.d.screen()
+
+        self.window = self.screen.root.create_window(
+            50, 50, 300, 200, 2,
+            self.screen.root_depth,
+            X.InputOutput,
+            X.CopyFromParent,
+
+            # special attribute values
+            background_pixel = self.screen.white_pixel,
+            event_mask = (X.ExposureMask |
+                          X.StructureNotifyMask |
+                          X.ButtonPressMask |
+                          X.ButtonReleaseMask |
+                          X.Button1MotionMask),
+            colormap = X.CopyFromParent,
+            )
+
+        self.gc = self.window.create_gc(
+            foreground = self.screen.black_pixel,
+            background = self.screen.white_pixel,
+            )
+
+        # Set some WM info
+
+        self.WM_DELETE_WINDOW = self.d.intern_atom('WM_DELETE_WINDOW')
+        self.WM_PROTOCOLS = self.d.intern_atom('WM_PROTOCOLS')
+
+        self.window.set_wm_name('Xlib example: xrandr.py')
+        self.window.set_wm_icon_name('xrandr.py')
+        self.window.set_wm_class('xrandr', 'XlibExample')
+
+        self.window.set_wm_protocols([self.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()
+
+        # Enable all RandR events.
+        self.window.xrandr_select_input(
+            randr.RRScreenChangeNotifyMask
+            | randr.RRCrtcChangeNotifyMask
+            | randr.RROutputChangeNotifyMask
+            | randr.RROutputPropertyNotifyMask
+            )
+
+        self.pp = pprint.PrettyPrinter(indent=4)
+
+        print "Screen info:"
+        self.pp.pprint(self.window.xrandr_get_screen_info()._data)
+
+        print "Screen size range:"
+        self.pp.pprint(self.window.xrandr_get_screen_size_range()._data)
+
+        print "Primary output:"
+        self.pp.pprint(self.window.xrandr_get_output_primary()._data)
+
+        resources = self.window.xrandr_get_screen_resources()._data
+
+        print "Modes:"
+        for mode_id, mode in self.parseModes(resources['mode_names'], resources['modes']).iteritems():
+            print "    %d: %s" % (mode_id, mode['name'])
+
+        for output in resources['outputs']:
+            print "Output %d info:" % (output, )
+            self.pp.pprint(self.d.xrandr_get_output_info(output, resources['config_timestamp'])._data)
+
+        for crtc in resources['crtcs']:
+            print "CRTC %d info:" % (crtc, )
+            self.pp.pprint(self.d.xrandr_get_crtc_info(crtc, resources['config_timestamp'])._data)
+
+        print "Raw screen resources:"
+        self.pp.pprint(resources)
+
+    def parseModes(self, mode_names, modes):
+        lastIdx = 0
+        modedatas = dict()
+        for mode in modes:
+            modedata = dict(mode._data)
+            modedata['name'] = mode_names[lastIdx:lastIdx + modedata['name_length']]
+            modedatas[modedata['id']] = modedata
+            lastIdx += modedata['name_length']
+        return modedatas
+
+    # Main loop, handling events
+    def loop(self):
+        current = None
+        while 1:
+            e = self.d.next_event()
+
+            # Window has been destroyed, quit
+            if e.type == X.DestroyNotify:
+                sys.exit(0)
+
+            # Screen information has changed
+            elif e.type == self.d.extension_event.ScreenChangeNotify:
+                print 'Screen change'
+                print self.pp.pprint(e._data)
+
+            # CRTC information has changed
+            elif e.type == self.d.extension_event.CrtcChangeNotify:
+                print 'CRTC change'
+                print self.pp.pprint(e._data)
+
+            # Output information has changed
+            elif e.type == self.d.extension_event.OutputChangeNotify:
+                print 'Output change'
+                print self.pp.pprint(e._data)
+
+            # Output property information has changed
+            elif e.type == self.d.extension_event.OutputPropertyNotify:
+                print 'Output property change'
+                print self.pp.pprint(e._data)
+
+            # Somebody wants to tell us something
+            elif e.type == X.ClientMessage:
+                if e.client_type == self.WM_PROTOCOLS:
+                    fmt, data = e.data
+                    if fmt == 32 and data[0] == self.WM_DELETE_WINDOW:
+                        sys.exit(0)
+
+
+if __name__ == '__main__':
+    Window(display.Display()).loop()
+


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 136
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=136&view=rev
Author:   funkiedamouse
Date:     2009-11-14 17:40:11 +0000 (Sat, 14 Nov 2009)

Log Message:
-----------
Updated NEWS with the latest changes, updated version number to 0.15rc1 in anticipation of the upcoming release, cleaned up documentation, and rewrote setup.py with some changes from PLWM.

Modified Paths:
--------------
    trunk/MANIFEST.in
    trunk/NEWS
    trunk/README
    trunk/TODO
    trunk/Xlib/__init__.py
    trunk/setup.py

Modified: trunk/MANIFEST.in
===================================================================
--- trunk/MANIFEST.in	2009-06-05 20:49:07 UTC (rev 135)
+++ trunk/MANIFEST.in	2009-11-14 17:40:11 UTC (rev 136)
@@ -1,7 +1,7 @@
 include MANIFEST.in
 include README COPYING NEWS TODO
 
-global-include .cvsignore 
+global-include .cvsignore
 
 recursive-include doc Makefile
 include doc/src/*.texi

Modified: trunk/NEWS
===================================================================
--- trunk/NEWS	2009-06-05 20:49:07 UTC (rev 135)
+++ trunk/NEWS	2009-11-14 17:40:11 UTC (rev 136)
@@ -1,9 +1,12 @@
 -*-outline-*-
 
-		      NEWS for Python X Library
+                      NEWS for Python X Library
 
-* Version 0.15 ???
+* Version 0.15rc1 - 14 Nov 2009
 
+Improved support for newer versions of Mac OS X, a couple of new
+extensions, and several bugfixes.
+
 ** Composite extension
 
 Support for the composite extension, used to implement a composition
@@ -14,7 +17,6 @@
 also need RENDER or glX or some similar method of creating fancy
 graphics.
 
-
 ** XF86 special function keysyms
 
 Keysym definitions for special function keys found on modern
@@ -26,10 +28,15 @@
 
 Xlib.XK.load_keysym_group('xf86')
 
+** RANDR extension
 
+The RANDR extension complements XINERAMA as a way of getting data about the
+physical screens making up a virtual screen in X. An example of usage can
+be found in examples/xrandr.py.
 
-* Version 0.14 1 Oct 2007 (trialed as 0.14rc1 on 10 Jun 2007)
 
+* Version 0.14 - 1 Oct 2007 (trialed as 0.14rc1 on 10 Jun 2007)
+
 A couple of new extensions, a Python 2.5 fix and a couple of aliases
 (Display.get_atom() now uses the internal cache and added
 Window.raise_window()).  Tabs converted to spaces (SF id: 1559082).
@@ -56,7 +63,7 @@
 causing failed authentication.
 
 
-* Version 0.13  6 Aug 2006 (trialed as 0.13pre1 on 22 Jul 2006)
+* Version 0.13 - 6 Aug 2006 (trialed as 0.13pre1 on 22 Jul 2006)
 
 A small release to incorporate a number of minor corrections and bug
 fixes, including small changes to keysym handling, .Xauthority parsing,
@@ -65,7 +72,7 @@
 objects.
 
 
-* Version 0.12  29 Mar 2002
+* Version 0.12 - 29 Mar 2002
 
 ** SHAPE extension
 
@@ -79,10 +86,10 @@
 
 In Python 2.2 FCNTL.FD_CLOEXEC has disappeared and FCNTL on the whole
 is deprecated, so that had to be dealt with to make the Xlib work with
-that version.  
+that version.
 
 
-* Version 0.11  23 Feb 2002
+* Version 0.11 - 23 Feb 2002
 
 ** Regression tests for the protocol definition
 
@@ -97,7 +104,7 @@
 "can't happen"-error has also been found and fixed.
 
 
-* Version 0.10  16 Dec 2001
+* Version 0.10 - 16 Dec 2001
 
 ** Event bugfix
 
@@ -120,7 +127,7 @@
 not perfect, but it's a start.
 
 
-* Version 0.9  4 Dec 2001
+* Version 0.9 - 4 Dec 2001
 
 ** Documentation improved
 
@@ -158,7 +165,7 @@
 
 
 
-* Version 0.8  12 Jan 2001
+* Version 0.8 - 12 Jan 2001
 
 ** Uses distutils
 
@@ -167,11 +174,11 @@
 
 ** Tested with Python 2.0
 
-A few incompatibilities with Python 2.0 has been fixed. 
+A few incompatibilities with Python 2.0 has been fixed.
 
-		      		      
-* Version 0.7  8 Jan 2001
 
+* Version 0.7 - 8 Jan 2001
+
 ** Fixed the 64-bit platform fix.
 
 As it turns out, the attempted fix for 64-bit platforms in v0.6 didn't
@@ -190,7 +197,7 @@
 
 
 
-* Version 0.6  29 Dec 2000
+* Version 0.6 - 29 Dec 2000
 
 ** Fix to make python-xlib work on 64-bytes architectures.
 
@@ -200,7 +207,7 @@
 probes how large each type code is to avoid this problem.
 
 
-* Version 0.5  28 Dec 2000
+* Version 0.5 - 28 Dec 2000
 
 ** Functions implemented to get and set all ICCCM WM properties on
 Window objects.
@@ -216,7 +223,7 @@
 responses, errors and events in a readable format.
 
 
-* Version 0.4  4 Oct 2000
+* Version 0.4 - 4 Oct 2000
 
 ** Thread support completed, but not really stresstested yet.
 
@@ -227,5 +234,3 @@
 
 ** The usual bunch of bugfixes.
 
-
-

Modified: trunk/README
===================================================================
--- trunk/README	2009-06-05 20:49:07 UTC (rev 135)
+++ trunk/README	2009-11-14 17:40:11 UTC (rev 136)
@@ -1,5 +1,5 @@
 
-			 The Python X Library
+                         The Python X Library
 
 *** Copyright
 
@@ -17,7 +17,7 @@
 *** Requirements
 
 The Python X Library requires Python 1.5.2 or newer.  It has been
-tested to various extents with Pythons 1.5.2, 2.0 - 2.5.
+tested to various extents with Python 1.5.2 and 2.0 through 2.6.
 
 
 *** Installation
@@ -74,11 +74,12 @@
 The high-level object oriented interface is also fully functional.
 It is possible to write client applications with the library.
 Currently, the only real application using Python Xlib is the window
-manager PLWM, starting with version 2.0.  
+manager PLWM, starting with version 2.0.
 
 There is a resource database implementation, ICCCM support and a
-framework for adding X extension code.  Currently only the XTEST
-extension has been implemented.
+framework for adding X extension code.  Several extensions have been
+implemented; (RECORD, SHAPE, Xinerama, Composite, RANDR, and XTEST)
+patches for additions are very welcome.
 
 There are most likely still bugs, but the library is at least stable
 enough to run PLWM.  A continously bigger part of the library is
@@ -106,3 +107,4 @@
 There isn't any real web page yet, only a derivative of this file.  It
 is located at http://python-xlib.sourceforge.net/.  It now also
 features the documentation for downloading or browsing.
+

Modified: trunk/TODO
===================================================================
--- trunk/TODO	2009-06-05 20:49:07 UTC (rev 135)
+++ trunk/TODO	2009-11-14 17:40:11 UTC (rev 136)
@@ -19,7 +19,7 @@
 
 * Faster, faster!  The protocol engine isn't very fast, despite the
   optimizations in version 0.7.  I've started on this, but it is a big
-  job. 
+  job.
 
 * The tread support and the protocol engine needs to be stress
   tested.  They _seem_ to work, but that's no guarantee.
@@ -31,7 +31,7 @@
   testing the protocol definitions.
 
 * Porting: the library should be runnable wherever there is a Python
-  interpreter (with the necessary IPC support, that is.)  
+  interpreter (with the necessary IPC support, that is.)
 
 * Widget set: a Python-optimized widget set using the X library would
   be really cute.  The AnyGUI project could be a good front-end to
@@ -42,3 +42,4 @@
   could be usable for writing X proxies, or for that matter, a
   complete X server in Python (this might be a little too spaced-out,
   though...)
+

Modified: trunk/Xlib/__init__.py
===================================================================
--- trunk/Xlib/__init__.py	2009-06-05 20:49:07 UTC (rev 135)
+++ trunk/Xlib/__init__.py	2009-11-14 17:40:11 UTC (rev 136)
@@ -16,9 +16,9 @@
 #    along with this program; if not, write to the Free Software
 #    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-__version__ = (0, 14)
+__version__ = (0, 15)
 
-__version_extra__ = ''
+__version_extra__ = 'rc1'
 
 __version_string__ = '.'.join(map(str, __version__)) + __version_extra__
 

Modified: trunk/setup.py
===================================================================
--- trunk/setup.py	2009-06-05 20:49:07 UTC (rev 135)
+++ trunk/setup.py	2009-11-14 17:40:11 UTC (rev 136)
@@ -1,24 +1,32 @@
 # Distutils script for python-xlib
 
 from distutils.core import setup
+import sys
 
+if sys.version < '2.3.3':
+    from distutils.dist import DistributionMetadata
+    DistributionMetadata.download_url = None
+
 import Xlib
 
-setup(name = 'python-xlib',
-      version = Xlib.__version_string__,
+setup(name='python-xlib',
+        version=Xlib.__version_string__,
 
-      description = "Python X Library",
-      url = 'http://python-xlib.sourceforge.net/',
+        description='Python X Library',
+        download_url='http://sourceforge.net/projects/python-xlib/files/',
+        url='http://python-xlib.sourceforge.net/',
+        license='GPL',
 
-      author = 'Peter Liljenberg',
-      author_email = 'petli@...',
+        author='Peter Liljenberg',
+        author_email='petli@...',
 
-      packages = [
-          'Xlib',
-          'Xlib.ext',
-          'Xlib.keysymdef',
-          'Xlib.protocol',
-          'Xlib.support',
-          'Xlib.xobject'
-          ],
-      )
+        packages=[
+            'Xlib',
+            'Xlib.ext',
+            'Xlib.keysymdef',
+            'Xlib.protocol',
+            'Xlib.support',
+            'Xlib.xobject'
+            ],
+        )
+


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 141
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=141&view=rev
Author:   forestatq
Date:     2011-07-31 19:29:44 +0000 (Sun, 31 Jul 2011)

Log Message:
-----------
Avoid a deadlock when issuing a request while another thread is reading events
from the server.  This occurs when both threads block on the select call but
the response has already been read by the event thread.

Modified Paths:
--------------
    trunk/Xlib/protocol/display.py

Added Paths:
-----------
    trunk/examples/eventthread.py

Modified: trunk/Xlib/protocol/display.py
===================================================================
--- trunk/Xlib/protocol/display.py	2011-07-23 23:11:15 UTC (rev 140)
+++ trunk/Xlib/protocol/display.py	2011-07-31 19:29:44 UTC (rev 141)
@@ -371,6 +371,9 @@
         #  If waiting for an event, we want to recv
         #  If just trying to receive anything we can, we want to recv
 
+        # FIXME: It would be good if we could also sleep when we're waiting on
+        # a response to a request that has already been sent.
+
         if (((flush or request is not None) and self.send_active)
             or ((event or recv) and self.recv_active)):
 
@@ -472,6 +475,10 @@
             # for the network to fire up
             self.send_recv_lock.release()
 
+            # There's no longer anything useful we can do here.
+            if not (sending or recieving):
+                break
+
             # If we're flushing, figure out how many bytes we
             # have to send so that we're not caught in an interminable
             # loop if other threads continuously append requests.

Added: trunk/examples/eventthread.py
===================================================================
--- trunk/examples/eventthread.py	                        (rev 0)
+++ trunk/examples/eventthread.py	2011-07-31 19:29:44 UTC (rev 141)
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+#
+# examples/eventthread.py -- Tests multithreaded event handling
+#
+#    Copyright (C) 2010-2011 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+import sys, time
+from threading import Thread
+
+from Xlib import X, Xatom, threaded
+from Xlib.display import Display
+
+
+class EventThread(Thread):
+    display = None
+    _stop = None
+
+    def __init__(self, display):
+        super(EventThread, self).__init__()
+        self.display = display
+        self.daemon = True
+
+    def run(self):
+        while True:
+            event = self.display.next_event()
+            print 'event: %r' % event
+
+
+def main(argv):
+    display = Display()
+
+    thread = EventThread(display)
+    thread.start()
+    time.sleep(1)
+
+    screen = display.screen()
+
+    # The get_property call should not deadlock, despite the blocking next_event
+    # call in the thread.
+    atom = display.intern_atom('_XROOTPMAP_ID', True)
+    response = screen.root.get_property(atom, Xatom.PIXMAP, 0, 1)
+    print 'get_property response: %r' % response
+
+    display.close()
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))


Property changes on: trunk/examples/eventthread.py
___________________________________________________________________
Added: svn:executable
   + *


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 142
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=142&view=rev
Author:   forestatq
Date:     2011-07-31 19:29:55 +0000 (Sun, 31 Jul 2011)

Log Message:
-----------
Add a partial implementation of the XFIXES extension and an example that uses
it.

Modified Paths:
--------------
    trunk/Xlib/ext/__init__.py

Added Paths:
-----------
    trunk/Xlib/ext/xfixes.py
    trunk/examples/xfixes.py

Modified: trunk/Xlib/ext/__init__.py
===================================================================
--- trunk/Xlib/ext/__init__.py	2011-07-31 19:29:44 UTC (rev 141)
+++ trunk/Xlib/ext/__init__.py	2011-07-31 19:29:55 UTC (rev 142)
@@ -27,6 +27,7 @@
     ('RECORD', 'record'),
     ('Composite', 'composite'),
     ('RANDR', 'randr'),
+    ('XFIXES', 'xfixes'),
     ]
 
 __all__ = map(lambda x: x[1], __extensions__)

Added: trunk/Xlib/ext/xfixes.py
===================================================================
--- trunk/Xlib/ext/xfixes.py	                        (rev 0)
+++ trunk/Xlib/ext/xfixes.py	2011-07-31 19:29:55 UTC (rev 142)
@@ -0,0 +1,84 @@
+# Xlib.ext.xfixes -- XFIXES extension module
+#
+#    Copyright (C) 2010-2011 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+'''
+A partial implementation of the XFIXES extension.  Only the HideCursor and
+ShowCursor requests are provided.
+'''
+
+from Xlib.protocol import rq
+
+extname = 'XFIXES'
+
+
+class QueryVersion(rq.ReplyRequest):
+    _request = rq.Struct(rq.Card8('opcode'),
+                         rq.Opcode(0),
+                         rq.RequestLength(),
+                         rq.Card32('major_version'),
+                         rq.Card32('minor_version')
+                         )
+    _reply = rq.Struct(rq.ReplyCode(),
+                       rq.Pad(1),
+                       rq.Card16('sequence_number'),
+                       rq.ReplyLength(),
+                       rq.Card32('major_version'),
+                       rq.Card32('minor_version'),
+                       rq.Pad(16)
+                       )
+
+
+def query_version(self):
+    return QueryVersion(display=self.display,
+                        opcode=self.display.get_extension_major(extname),
+                        major_version=4,
+                        minor_version=0)
+
+
+class HideCursor(rq.Request):
+    _request = rq.Struct(rq.Card8('opcode'),
+                         rq.Opcode(29),
+                         rq.RequestLength(),
+                         rq.Window('window')
+                         )
+
+def hide_cursor(self):
+    HideCursor(display=self.display,
+               opcode=self.display.get_extension_major(extname),
+               window=self)
+
+
+class ShowCursor(rq.Request):
+    _request = rq.Struct(rq.Card8('opcode'),
+                         rq.Opcode(30),
+                         rq.RequestLength(),
+                         rq.Window('window')
+                         )
+
+
+def show_cursor(self):
+    ShowCursor(display=self.display,
+               opcode=self.display.get_extension_major(extname),
+               window=self)
+
+
+def init(disp, info):
+    disp.extension_add_method('display', 'xfixes_query_version', query_version)
+    disp.extension_add_method('window', 'xfixes_hide_cursor', hide_cursor)
+    disp.extension_add_method('window', 'xfixes_show_cursor', show_cursor)

Added: trunk/examples/xfixes.py
===================================================================
--- trunk/examples/xfixes.py	                        (rev 0)
+++ trunk/examples/xfixes.py	2011-07-31 19:29:55 UTC (rev 142)
@@ -0,0 +1,65 @@
+#!/usr/bin/python
+#
+# examples/xfixes.py -- demonstrate the XFIXES extension
+#
+#    Copyright (C) 2011 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+import sys, os
+from optparse import OptionParser
+
+# Change path so we find Xlib
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+
+from Xlib.display import Display
+
+
+def main(argv):
+    parser = OptionParser()
+    parser.add_option('--hide-cursor', action='store_true', default=False)
+    parser.add_option('--show-cursor', action='store_true', default=False)
+
+    opts, args = parser.parse_args(argv[1:])
+
+    if opts.hide_cursor and opts.show_cursor:
+        parser.error('--hide-cursor and --show-cursor cannot be combined')
+
+    if not any((opts.hide_cursor, opts.show_cursor)):
+        parser.error('specify --hide-cursor or --show-cursor')
+
+    display = Display()
+
+    if not display.has_extension('XFIXES'):
+        if display.query_extension('XFIXES') is None:
+            print >>sys.stderr, 'XFIXES extension not supported'
+            return 1
+
+    xfixes_version = display.xfixes_query_version()
+    print >>sys.stderr, 'Found XFIXES version %s.%s' % (
+      xfixes_version.major_version,
+      xfixes_version.minor_version,
+    )
+
+    if opts.hide_cursor:
+        display.screen().root.xfixes_hide_cursor()
+    elif opts.show_cursor:
+        display.screen().root.xfixes_hide_cursor()
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))


Property changes on: trunk/examples/xfixes.py
___________________________________________________________________
Added: svn:executable
   + *


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 143
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=143&view=rev
Author:   forestatq
Date:     2011-07-31 19:30:08 +0000 (Sun, 31 Jul 2011)

Log Message:
-----------
Add a partial implementation of the SECURITY extension and an example that uses
it.

Modified Paths:
--------------
    trunk/Xlib/ext/__init__.py

Added Paths:
-----------
    trunk/Xlib/ext/security.py
    trunk/examples/security.py

Modified: trunk/Xlib/ext/__init__.py
===================================================================
--- trunk/Xlib/ext/__init__.py	2011-07-31 19:29:55 UTC (rev 142)
+++ trunk/Xlib/ext/__init__.py	2011-07-31 19:30:08 UTC (rev 143)
@@ -28,6 +28,7 @@
     ('Composite', 'composite'),
     ('RANDR', 'randr'),
     ('XFIXES', 'xfixes'),
+    ('SECURITY', 'security'),
     ]
 
 __all__ = map(lambda x: x[1], __extensions__)

Added: trunk/Xlib/ext/security.py
===================================================================
--- trunk/Xlib/ext/security.py	                        (rev 0)
+++ trunk/Xlib/ext/security.py	2011-07-31 19:30:08 UTC (rev 143)
@@ -0,0 +1,136 @@
+# Xlib.ext.security -- SECURITY extension module
+#
+#    Copyright (C) 2010-2011 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+'''
+A partial implementation of the SECURITY extension.  Support for the
+SecurityAuthorizationRevoked event is not implemented.
+'''
+
+from Xlib.protocol import rq
+
+
+extname = 'SECURITY'
+
+
+SecurityClientTrusted = 0
+SecurityClientUntrusted = 1
+
+SecurityAuthorizationRevokedMask = 1
+
+
+AUTHID = rq.Card32
+
+
+class QueryVersion(rq.ReplyRequest):
+    _request = rq.Struct(rq.Card8('opcode'),
+                         rq.Opcode(0),
+                         rq.RequestLength(),
+                         rq.Card16('major_version'),
+                         rq.Card16('minor_version')
+                         )
+    _reply = rq.Struct(rq.ReplyCode(),
+                       rq.Pad(1),
+                       rq.Card16('sequence_number'),
+                       rq.ReplyLength(),
+                       rq.Card16('major_version'),
+                       rq.Card16('minor_version'),
+                       rq.Pad(20)
+                       )
+
+
+def query_version(self):
+    return QueryVersion(display=self.display,
+                        opcode=self.display.get_extension_major(extname),
+                        major_version=1,
+                        minor_version=0)
+
+
+class SecurityGenerateAuthorization(rq.ReplyRequest):
+    # The order of fields here does not match the specifications I've seen
+    # online, but it *does* match with the X.org implementation.  I guess the
+    # spec is out-of-date.
+    _request = rq.Struct(rq.Card8('opcode'),
+                         rq.Opcode(1),
+                         rq.RequestLength(),
+                         rq.LengthOf('auth_proto', 2),
+                         rq.LengthOf('auth_data', 2),
+                         rq.Card32('value_mask'),
+                         rq.String8('auth_proto'),
+                         rq.String8('auth_data'),
+                         rq.List('values', rq.Card32Obj)
+                         )
+    _reply = rq.Struct(rq.ReplyCode(),
+                       rq.Pad(1),
+                       rq.Card16('sequence_number'),
+                       rq.ReplyLength(),
+                       AUTHID('authid'),
+                       rq.Pad(18),
+                       rq.LengthOf('auth_data_return', 2),
+                       rq.String8('auth_data_return')
+                       )
+
+
+def generate_authorization(self, auth_proto, auth_data='', timeout=None,
+                           trust_level=None, group=None, event_mask=None):
+    value_mask = 0
+    values = []
+    if timeout is not None:
+        value_mask |= 1
+        values.append(timeout)
+    if trust_level is not None:
+        value_mask |= 2
+        values.append(trust_level)
+    if group is not None:
+        value_mask |= 4
+        values.append(group)
+    if event_mask is not None:
+        value_mask |= 8
+        values.append(event_mask)
+    return SecurityGenerateAuthorization(display=self.display,
+                                         opcode=self.display.get_extension_major(extname),
+                                         value_mask=value_mask,
+                                         auth_proto=auth_proto,
+                                         auth_data=auth_data,
+                                         values=values)
+
+
+class SecurityRevokeAuthorization(rq.Request):
+    _request = rq.Struct(rq.Card8('opcode'),
+                         rq.Opcode(2),
+                         rq.RequestLength(),
+                         AUTHID('authid')
+                         )
+
+
+def revoke_authorization(self, authid):
+    return SecurityRevokeAuthorization(display=self.display,
+                                       opcode=self.display.get_extension_major(extname),
+                                       authid=authid)
+
+
+def init(disp, info):
+    disp.extension_add_method('display',
+                              'security_query_version',
+                              query_version)
+    disp.extension_add_method('display',
+                              'security_generate_authorization',
+                              generate_authorization)
+    disp.extension_add_method('display',
+                              'security_revoke_authorization',
+                              revoke_authorization)

Added: trunk/examples/security.py
===================================================================
--- trunk/examples/security.py	                        (rev 0)
+++ trunk/examples/security.py	2011-07-31 19:30:08 UTC (rev 143)
@@ -0,0 +1,80 @@
+#!/usr/bin/python
+#
+# examples/security.py -- demonstrate the SECURITY extension
+#
+#    Copyright (C) 2011 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+import sys, os
+from optparse import OptionParser
+
+# Change path so we find Xlib
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+
+from Xlib.display import Display
+from Xlib.ext import security
+
+
+def main(argv):
+    parser = OptionParser()
+
+    parser.add_option('--generate', action='store_true', default=False)
+    parser.add_option('--proto', default='MIT-MAGIC-COOKIE-1')
+    parser.add_option('--trusted', action='store_true', default=False)
+    parser.add_option('--untrusted', action='store_true', default=False)
+
+    parser.add_option('--revoke', action='store_true', default=False)
+
+    opts, args = parser.parse_args(argv[1:])
+
+    if opts.trusted and opts.untrusted:
+        parser.error('--trusted and --untrusted cannot be combined')
+
+    if not any((opts.generate, opts.revoke)):
+        parser.error('specify --generate or --revoke')
+
+    display = Display()
+
+    if not display.has_extension('SECURITY'):
+        if display.query_extension('SECURITY') is None:
+            print >>sys.stderr, 'SECURITY extension not supported'
+            return 1
+
+    security_version = display.security_query_version()
+    print >>sys.stderr, 'Found SECURITY version %s.%s' % (
+      security_version.major_version,
+      security_version.minor_version,
+    )
+
+    if opts.generate:
+        kwargs = {}
+        if opts.trusted:
+            kwargs['trust_level'] = security.SecurityClientTrusted
+        elif opts.untrusted:
+            kwargs['trust_level'] = security.SecurityClientUntrusted
+        reply = display.security_generate_authorization(opts.proto, **kwargs)
+        print reply.authid
+
+    elif opts.revoke:
+        for arg in args:
+            authid = int(arg, 10)
+            display.security_revoke_authorization(authid)
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))


Property changes on: trunk/examples/security.py
___________________________________________________________________
Added: svn:executable
   + *


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 151
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=151&view=rev
Author:   forestatq
Date:     2011-10-11 15:55:07 +0000 (Tue, 11 Oct 2011)
Log Message:
-----------
randr: set_crtc_config: Add missing arguments "x", "y", "outputs".

Modified Paths:
--------------
    trunk/Xlib/ext/randr.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/ext/randr.py
===================================================================
--- trunk/Xlib/ext/randr.py	2011-10-11 15:53:03 UTC (rev 150)
+++ trunk/Xlib/ext/randr.py	2011-10-11 15:55:07 UTC (rev 151)
@@ -761,14 +761,17 @@
         rq.Pad(20),
         )
 
-def set_crtc_config(self, crtc, config_timestamp, mode, rotation, timestamp=X.CurrentTime):
+def set_crtc_config(self, crtc, config_timestamp, x, y, mode, rotation, outputs, timestamp=X.CurrentTime):
     return SetCrtcConfig (
         display=self.display,
         opcode=self.display.get_extension_major(extname),
         crtc=crtc,
         config_timestamp=config_timestamp,
+        x=x,
+        y=y,
         mode=mode,
         rotation=rotation,
+        outputs=outputs,
         timestamp=timestamp,
         )
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 152
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=152&view=rev
Author:   forestatq
Date:     2012-07-01 14:26:32 +0000 (Sun, 01 Jul 2012)
Log Message:
-----------
Display: Use AssertionError instead of nonexistent exception
MethodOverrideError in method "extension_add_method".  There's not much
point in having a special exception for this case anyway.  It likely
indicates either an installation issue or a clash with some external
code trying to register its own extensions, neither of which is really
recoverable at runtime.

Modified Paths:
--------------
    trunk/Xlib/display.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/display.py
===================================================================
--- trunk/Xlib/display.py	2011-10-11 15:55:07 UTC (rev 151)
+++ trunk/Xlib/display.py	2012-07-01 14:26:32 UTC (rev 152)
@@ -261,7 +261,7 @@
 
         if object == 'display':
             if hasattr(self, name):
-                raise error.MethodOverrideError('attempting to replace display method: %s' % name)
+                raise AssertionError('attempting to replace display method: %s' % name)
 
             self.display_extension_methods[name] = function
 
@@ -270,7 +270,7 @@
             for type in types:
                 cls = _resource_baseclasses[type]
                 if hasattr(cls, name):
-                    raise error.MethodOverrideError('attempting to replace %s method: %s' % (type, name))
+                    raise AssertionError('attempting to replace %s method: %s' % (type, name))
 
                 method = new.instancemethod(function, None, cls)
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 153
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=153&view=rev
Author:   forestatq
Date:     2012-07-01 14:26:37 +0000 (Sun, 01 Jul 2012)
Log Message:
-----------
randr: get_output_property: Fix parameter names to match the request
definition.  "longOffset" and "longLength" should be "long_offset" and
"long_length", respectively.

Modified Paths:
--------------
    trunk/Xlib/ext/randr.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/ext/randr.py
===================================================================
--- trunk/Xlib/ext/randr.py	2012-07-01 14:26:32 UTC (rev 152)
+++ trunk/Xlib/ext/randr.py	2012-07-01 14:26:37 UTC (rev 153)
@@ -609,15 +609,15 @@
         rq.List('value', rq.Card8Obj),
         )
 
-def get_output_property(self, output, property, type, longOffset, longLength):
+def get_output_property(self, output, property, type, long_offset, long_length):
     return GetOutputProperty(
         display=self.display,
         opcode=self.display.get_extension_major(extname),
         output=output,
         property=property,
         type=type,
-        longOffset=longOffset,
-        longLength=longLength,
+        long_offset=long_offset,
+        long_length=long_length,
         )
 
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 154
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=154&view=rev
Author:   forestatq
Date:     2012-07-01 14:26:41 +0000 (Sun, 01 Jul 2012)
Log Message:
-----------
randr: get_output_property: Add missing parameters "delete" and "pending".

Modified Paths:
--------------
    trunk/Xlib/ext/randr.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/ext/randr.py
===================================================================
--- trunk/Xlib/ext/randr.py	2012-07-01 14:26:37 UTC (rev 153)
+++ trunk/Xlib/ext/randr.py	2012-07-01 14:26:41 UTC (rev 154)
@@ -609,7 +609,7 @@
         rq.List('value', rq.Card8Obj),
         )
 
-def get_output_property(self, output, property, type, long_offset, long_length):
+def get_output_property(self, output, property, type, long_offset, long_length, delete=False, pending=False):
     return GetOutputProperty(
         display=self.display,
         opcode=self.display.get_extension_major(extname),
@@ -618,6 +618,8 @@
         type=type,
         long_offset=long_offset,
         long_length=long_length,
+        delete=delete,
+        pending=pending,
         )
 
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 155
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=155&view=rev
Author:   forestatq
Date:     2012-07-01 14:26:44 +0000 (Sun, 01 Jul 2012)
Log Message:
-----------
randr: set_crtc_gamma: Add missing parameters "red", "green", and "blue".

Modified Paths:
--------------
    trunk/Xlib/ext/randr.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/ext/randr.py
===================================================================
--- trunk/Xlib/ext/randr.py	2012-07-01 14:26:41 UTC (rev 154)
+++ trunk/Xlib/ext/randr.py	2012-07-01 14:26:44 UTC (rev 155)
@@ -842,12 +842,15 @@
         rq.List('blue', rq.Card16Obj),
         )
 
-def set_crtc_gamma(self, crtc, size):
+def set_crtc_gamma(self, crtc, size, red, green, blue):
     return SetCrtcGamma(
         display=self.display,
         opcode=self.display.get_extension_major(extname),
         crtc=crtc,
         size=size,
+        red=red,
+        green=green,
+        blue=blue,
         )
 
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 156
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=156&view=rev
Author:   forestatq
Date:     2012-08-21 17:50:43 +0000 (Tue, 21 Aug 2012)
Log Message:
-----------
rq: Support length fields that specify the length of multiple fields.

Modified Paths:
--------------
    trunk/Xlib/protocol/rq.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/protocol/rq.py
===================================================================
--- trunk/Xlib/protocol/rq.py	2012-07-01 14:26:44 UTC (rev 155)
+++ trunk/Xlib/protocol/rq.py	2012-08-21 17:50:43 UTC (rev 156)
@@ -161,7 +161,9 @@
     may vary, e.g. List and String8.
 
     Its name should be the same as the name of the field whose size
-    it stores.
+    it stores.  The other_fields attribute can be used to specify the
+    names of other fields whose sizes are stored by this field, so
+    a single length field can set the length of multiple fields.
 
     The lf.get_binary_value() method of LengthFields is not used, instead
     a lf.get_binary_length() should be provided.
@@ -172,6 +174,7 @@
 
     structcode = 'L'
     structvalues = 1
+    other_fields = None
 
     def calc_length(self, length):
         """newlen = lf.calc_length(length)
@@ -202,7 +205,11 @@
 
 class LengthOf(LengthField):
     def __init__(self, name, size):
-        self.name = name
+        if isinstance(name, (list, tuple)):
+            self.name = name[0]
+            self.other_fields = name[1:]
+        else:
+            self.name = name
         self.structcode = unsigned_codes[size]
 
 
@@ -1222,12 +1229,16 @@
             # when treating varfields.
 
             elif isinstance(f, LengthField):
-                if f.parse_value is None:
-                    lengths[f.name] = 'val[%d]' % vno
-                else:
-                    lengths[f.name] = ('self.static_fields[%d].'
-                                       'parse_value(val[%d], display)'
-                                       % (fno, vno))
+                f_names = [f.name]
+                if f.other_fields:
+                    f_names.extend(f.other_fields)
+                for f_name in f_names:
+                    if f.parse_value is None:
+                        lengths[f_name] = 'val[%d]' % vno
+                    else:
+                        lengths[f_name] = ('self.static_fields[%d].'
+                                           'parse_value(val[%d], display)'
+                                           % (fno, vno))
 
             elif isinstance(f, FormatField):
                 formats[f.name] = 'val[%d]' % vno

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 157
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=157&view=rev
Author:   forestatq
Date:     2012-08-21 17:50:48 +0000 (Tue, 21 Aug 2012)
Log Message:
-----------
randr: Fix GetCrtcGamma reply definition to make the "size" field set the
length of the "red", "green", and "blue" fields.  Otherwise, the "red" field
receives all of the list items.

Modified Paths:
--------------
    trunk/Xlib/ext/randr.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/ext/randr.py
===================================================================
--- trunk/Xlib/ext/randr.py	2012-08-21 17:50:43 UTC (rev 156)
+++ trunk/Xlib/ext/randr.py	2012-08-21 17:50:48 UTC (rev 157)
@@ -814,7 +814,7 @@
         rq.Card8('status'),
         rq.Card16('sequence_number'),
         rq.ReplyLength(),
-        rq.Card16('size'),
+        rq.LengthOf(('red', 'green', 'blue'), 2),
         rq.Pad(22),
         rq.List('red', rq.Card16Obj),
         rq.List('green', rq.Card16Obj),

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 159
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=159&view=rev
Author:   forestatq
Date:     2012-12-09 16:04:57 +0000 (Sun, 09 Dec 2012)
Log Message:
-----------
protocol: display: Change name of Display attribute "request_length" to
"recv_packet_len" in preparation for more general use.

Modified Paths:
--------------
    trunk/Xlib/protocol/display.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/protocol/display.py
===================================================================
--- trunk/Xlib/protocol/display.py	2012-11-18 08:08:27 UTC (rev 158)
+++ trunk/Xlib/protocol/display.py	2012-12-09 16:04:57 UTC (rev 159)
@@ -82,7 +82,7 @@
 
         # Data used by the send-and-recieve loop
         self.sent_requests = []
-        self.request_length = 0
+        self.recv_packet_len = 0
         self.data_send = ''
         self.data_recv = ''
         self.data_sent_bytes = 0
@@ -634,8 +634,8 @@
         gotreq = 0
         while 1:
             # Are we're waiting for additional data for a request response?
-            if self.request_length:
-                if len(self.data_recv) < self.request_length:
+            if self.recv_packet_len:
+                if len(self.data_recv) < self.recv_packet_len:
                     return gotreq
                 else:
                     gotreq = self.parse_request_response(request) or gotreq
@@ -658,7 +658,7 @@
                 # Set reply length, and loop around to see if
                 # we have got the full response
                 rlen = int(struct.unpack('=L', self.data_recv[4:8])[0])
-                self.request_length = 32 + rlen * 4
+                self.recv_packet_len = 32 + rlen * 4
 
             # Else event response
             else:
@@ -724,11 +724,11 @@
             raise RuntimeError("Expected reply for request %s, but got %s.  Can't happen!"
                                % (req._serial, sno))
 
-        req._parse_response(self.data_recv[:self.request_length])
+        req._parse_response(self.data_recv[:self.recv_packet_len])
         # print 'recv Request:', req
 
-        self.data_recv = buffer(self.data_recv, self.request_length)
-        self.request_length = 0
+        self.data_recv = buffer(self.data_recv, self.recv_packet_len)
+        self.recv_packet_len = 0
 
 
         # Unlock any response waiting threads

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 160
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=160&view=rev
Author:   forestatq
Date:     2012-12-09 16:05:05 +0000 (Sun, 09 Dec 2012)
Log Message:
-----------
Add support for the Generic Event Extension.

While most of this functionality is implemented in the new "ge" extension
module, some changes to the core protocol implementation were also required due
to the need to read event packets longer than 32 bytes.

Modified Paths:
--------------
    trunk/Xlib/ext/__init__.py
    trunk/Xlib/protocol/display.py

Added Paths:
-----------
    trunk/Xlib/ext/ge.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/ext/__init__.py
===================================================================
--- trunk/Xlib/ext/__init__.py	2012-12-09 16:04:57 UTC (rev 159)
+++ trunk/Xlib/ext/__init__.py	2012-12-09 16:05:05 UTC (rev 160)
@@ -21,6 +21,9 @@
 # protocol.  extmod is the name of the module in this package.
 
 __extensions__ = [
+    # We load this first so other extensions can register generic event data
+    # structures.
+    ('Generic Event Extension', 'ge'),
     ('XTEST', 'xtest'),
     ('SHAPE', 'shape'),
     ('XINERAMA', 'xinerama'),

Added: trunk/Xlib/ext/ge.py
===================================================================
--- trunk/Xlib/ext/ge.py	                        (rev 0)
+++ trunk/Xlib/ext/ge.py	2012-12-09 16:05:05 UTC (rev 160)
@@ -0,0 +1,109 @@
+# Xlib.ext.ge -- Generic Event extension module
+#
+#    Copyright (C) 2012 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+'''
+ge - Generic Event Extension
+'''
+
+from Xlib.protocol import rq
+
+extname = 'Generic Event Extension'
+
+
+GenericEventCode = 35
+
+
+class GEQueryVersion(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(0),
+        rq.RequestLength(),
+        rq.Card32('major_version'),
+        rq.Card32('minor_version'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('major_version'),
+        rq.Card32('minor_version'),
+        rq.Pad(16),
+        )
+
+
+def query_version(self):
+    return GEQueryVersion(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        major_version=1,
+        minor_version=0,
+        )
+
+
+class GenericEvent(rq.Event):
+    _code = GenericEventCode
+    _fields = rq.Struct(
+        rq.Card8('type'),
+        rq.Card8('extension'),
+        rq.Card16('sequence_number'),
+        rq.Card32('length'),
+        rq.Card16('evtype'),
+        # Some generic events make use of this space, but with
+        # others the data is simply discarded.  In any case we
+        # don't need to explicitly pad this out as we are
+        # always given at least 32 bytes and we save
+        # everything after the first ten as the "data" field.
+        #rq.Pad(22),
+        )
+
+    def __init__(self, binarydata = None, display = None, **keys):
+        if binarydata:
+            data = binarydata[10:]
+            binarydata = binarydata[:10]
+        else:
+            data = ''
+
+        rq.Event.__init__(
+            self,
+            binarydata=binarydata,
+            display=display,
+            **keys
+            )
+
+        if display:
+            ge_event_data = getattr(display, 'ge_event_data', None)
+            if ge_event_data:
+                estruct = ge_event_data.get((self.extension, self.evtype), None)
+                if estruct:
+                    data, _ = estruct.parse_binary(data, display)
+
+        self._data['data'] = data
+
+
+def add_event_data(self, extension, evtype, estruct):
+    if not hasattr(self.display, 'ge_event_data'):
+        self.display.ge_event_data = {}
+    self.display.ge_event_data[(extension, evtype)] = estruct
+
+
+def init(disp, info):
+    disp.extension_add_method('display', 'ge_query_version', query_version)
+    disp.extension_add_method('display', 'ge_add_event_data', add_event_data)
+    disp.extension_add_event(GenericEventCode, GenericEvent)

Modified: trunk/Xlib/protocol/display.py
===================================================================
--- trunk/Xlib/protocol/display.py	2012-12-09 16:04:57 UTC (rev 159)
+++ trunk/Xlib/protocol/display.py	2012-12-09 16:05:05 UTC (rev 160)
@@ -27,6 +27,7 @@
 
 # Xlib modules
 from Xlib import error
+from Xlib.ext import ge
 
 from Xlib.support import lock, connect
 
@@ -633,34 +634,39 @@
         # Parse ordinary server response
         gotreq = 0
         while 1:
-            # Are we're waiting for additional data for a request response?
+            if self.data_recv:
+                # Check the first byte to find out what kind of response it is
+                rtype = ord(self.data_recv[0])
+
+            # Are we're waiting for additional data for the current packet?
             if self.recv_packet_len:
                 if len(self.data_recv) < self.recv_packet_len:
                     return gotreq
+
+                if rtype == 1:
+                    gotreq = self.parse_request_response(request) or gotreq
+                elif rtype & 0x7f == ge.GenericEventCode:
+                    self.parse_event_response(rtype)
                 else:
-                    gotreq = self.parse_request_response(request) or gotreq
+                    raise AssertionError(rtype)
 
-
             # Every response is at least 32 bytes long, so don't bother
             # until we have recieved that much
             if len(self.data_recv) < 32:
                 return gotreq
 
-            # Check the first byte to find out what kind of response it is
-            rtype = ord(self.data_recv[0])
-
             # Error resposne
             if rtype == 0:
                 gotreq = self.parse_error_response(request) or gotreq
 
-            # Request response
-            elif rtype == 1:
+            # Request response or generic event.
+            elif rtype == 1 or rtype & 0x7f == ge.GenericEventCode:
                 # Set reply length, and loop around to see if
                 # we have got the full response
                 rlen = int(struct.unpack('=L', self.data_recv[4:8])[0])
                 self.recv_packet_len = 32 + rlen * 4
 
-            # Else event response
+            # Else non-generic event
             else:
                 self.parse_event_response(rtype)
 
@@ -746,14 +752,22 @@
 
 
     def parse_event_response(self, etype):
-        # Skip bit 8 at lookup, that is set if this event came from an
-        # SendEvent
-        estruct = self.event_classes.get(etype & 0x7f, event.AnyEvent)
+        # Skip bit 8, that is set if this event came from an SendEvent
+        etype = etype & 0x7f
 
-        e = estruct(display = self, binarydata = self.data_recv[:32])
+        if etype == ge.GenericEventCode:
+            length = self.recv_packet_len
+        else:
+            length = 32
 
-        self.data_recv = buffer(self.data_recv, 32)
+        estruct = self.event_classes.get(etype, event.AnyEvent)
+        e = estruct(display = self, binarydata = self.data_recv[:length])
 
+        if etype == ge.GenericEventCode:
+            self.recv_packet_len = 0
+
+        self.data_recv = buffer(self.data_recv, length)
+
         # Drop all requests having an error handler,
         # but which obviously succeded.
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 161
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=161&view=rev
Author:   forestatq
Date:     2012-12-09 16:05:12 +0000 (Sun, 09 Dec 2012)
Log Message:
-----------
Add partial support for the XInput extension, including an example.

Modified Paths:
--------------
    trunk/Xlib/ext/__init__.py

Added Paths:
-----------
    trunk/Xlib/ext/xinput.py
    trunk/examples/xinput.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/ext/__init__.py
===================================================================
--- trunk/Xlib/ext/__init__.py	2012-12-09 16:05:05 UTC (rev 160)
+++ trunk/Xlib/ext/__init__.py	2012-12-09 16:05:12 UTC (rev 161)
@@ -32,6 +32,7 @@
     ('RANDR', 'randr'),
     ('XFIXES', 'xfixes'),
     ('SECURITY', 'security'),
+    ('XInputExtension', 'xinput'),
     ]
 
 __all__ = map(lambda x: x[1], __extensions__)

Added: trunk/Xlib/ext/xinput.py
===================================================================
--- trunk/Xlib/ext/xinput.py	                        (rev 0)
+++ trunk/Xlib/ext/xinput.py	2012-12-09 16:05:12 UTC (rev 161)
@@ -0,0 +1,260 @@
+# Xlib.ext.xinput -- XInput extension module
+#
+#    Copyright (C) 2012 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+'''
+A very incomplete implementation of the XInput extension.
+'''
+
+import sys, array
+
+from Xlib.protocol import rq
+
+
+extname = 'XInputExtension'
+
+PropertyDeleted = 0
+PropertyCreated = 1
+PropertyModified = 2
+
+NotifyNormal = 0
+NotifyGrab = 1
+NotifyUngrab = 2
+NotifyWhileGrabbed = 3
+NotifyPassiveGrab = 4
+NotifyPassiveUngrab = 5
+
+NotifyAncestor = 0
+NotifyVirtual = 1
+NotifyInferior = 2
+NotifyNonlinear = 3
+NotifyNonlinearVirtual = 4
+NotifyPointer = 5
+NotifyPointerRoot = 6
+NotifyDetailNone = 7
+
+GrabtypeButton = 0
+GrabtypeKeycode = 1
+GrabtypeEnter = 2
+GrabtypeFocusIn = 3
+
+AnyModifier = (1 << 31)
+AnyButton = 0
+AnyKeycode = 0
+
+AsyncDevice = 0
+SyncDevice = 1
+ReplayDevice = 2
+AsyncPairedDevice = 3
+AsyncPair = 4
+SyncPair = 5
+
+SlaveSwitch = 1
+DeviceChange = 2
+
+MasterAdded = (1 << 0)
+MasterRemoved = (1 << 1)
+SlaveAdded = (1 << 2)
+SlaveRemoved = (1 << 3)
+SlaveAttached = (1 << 4)
+SlaveDetached = (1 << 5)
+DeviceEnabled = (1 << 6)
+DeviceDisabled = (1 << 7)
+
+AddMaster = 1
+RemoveMaster = 2
+AttachSlave = 3
+DetachSlave = 4
+
+AttachToMaster = 1
+Floating = 2
+
+ModeRelative = 0
+ModeAbsolute = 1
+
+MasterPointer = 1
+MasterKeyboard = 2
+SlavePointer = 3
+SlaveKeyboard = 4
+FloatingSlave = 5
+
+KeyClass = 0
+ButtonClass = 1
+ValuatorClass = 2
+
+KeyRepeat = (1 << 16)
+
+AllDevices = 0
+AllMasterDevices = 1
+
+DeviceChanged = 1
+KeyPress = 2
+KeyRelease = 3
+ButtonPress = 4
+ButtonRelease = 5
+Motion = 6
+Enter = 7
+Leave = 8
+FocusIn = 9
+FocusOut = 10
+HierarchyChanged = 11
+PropertyEvent = 12
+RawKeyPress = 13
+RawKeyRelease = 14
+RawButtonPress = 15
+RawButtonRelease = 16
+RawMotion = 17
+
+DeviceChangedMask = (1 << DeviceChanged)
+KeyPressMask = (1 << KeyPress)
+KeyReleaseMask = (1 << KeyRelease)
+ButtonPressMask = (1 << ButtonPress)
+ButtonReleaseMask = (1 << ButtonRelease)
+MotionMask = (1 << Motion)
+EnterMask = (1 << Enter)
+LeaveMask = (1 << Leave)
+FocusInMask = (1 << FocusIn)
+FocusOutMask = (1 << FocusOut)
+HierarchyChangedMask = (1 << HierarchyChanged)
+PropertyEventMask = (1 << PropertyEvent)
+RawKeyPressMask = (1 << RawKeyPress)
+RawKeyReleaseMask = (1 << RawKeyRelease)
+RawButtonPressMask = (1 << RawButtonPress)
+RawButtonReleaseMask = (1 << RawButtonRelease)
+RawMotionMask = (1 << RawMotion)
+
+DEVICEID = rq.Card16
+DEVICE = rq.Card16
+DEVICEUSE = rq.Card8
+
+
+class XIQueryVersion(rq.ReplyRequest):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(47),
+        rq.RequestLength(),
+        rq.Card16('major_version'),
+        rq.Card16('minor_version'),
+        )
+    _reply = rq.Struct(
+        rq.ReplyCode(),
+        rq.Pad(1),
+        rq.Card16('sequence_number'),
+        rq.ReplyLength(),
+        rq.Card32('major_version'),
+        rq.Card32('minor_version'),
+        rq.Pad(16),
+        )
+
+
+def query_version(self):
+    return XIQueryVersion(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        major_version=2,
+        minor_version=0,
+        )
+
+
+EventMask = rq.Struct(
+        DEVICE('deviceid'),
+        rq.LengthOf('mask', 2),
+        rq.List('mask', rq.Card32),
+        )
+
+
+class XISelectEvents(rq.Request):
+    _request = rq.Struct(
+        rq.Card8('opcode'),
+        rq.Opcode(46),
+        rq.RequestLength(),
+        rq.Window('window'),
+        rq.LengthOf('masks', 2),
+        rq.Pad(2),
+        rq.List('masks', EventMask),
+        )
+
+
+def select_events(self, event_masks):
+    '''
+    select_events(event_masks)
+
+    event_masks:
+      Sequence of (deviceid, mask) pairs, where deviceid is a numerical device
+      ID, or AllDevices or AllMasterDevices, and mask is either an unsigned
+      integer or sequence of 32 byte unsigned values
+    '''
+
+    masks = []
+    for deviceid, mask in event_masks:
+        mask_seq = array.array(rq.struct_to_array_codes['L'])
+
+        if isinstance(mask, (int, long)):
+            # We need to build a "binary mask" that (as far as I can tell) is
+            # encoded in native byte order from end to end.  The simple case is
+            # with a single unsigned 32-bit value, for which we construct an
+            # array with just one item.  For values too big to fit inside 4
+            # bytes we build a longer array, being careful to maintain native
+            # byte order across the entire set of values.
+            if sys.byteorder == 'little':
+                f = lambda v: mask_seq.insert(0, v)
+            elif sys.byteorder == 'big':
+                f = mask_seq.append
+            else:
+                raise AssertionError(sys.byteorder)
+            while mask:
+                f(mask & 0xFFFFFFFF)
+                mask = mask >> 32
+        else:
+            mask_seq.extend(mask)
+
+        masks.append({'deviceid': deviceid, 'mask': mask_seq})
+
+    return XISelectEvents(
+        display=self.display,
+        opcode=self.display.get_extension_major(extname),
+        window=self,
+        masks=masks,
+        )
+
+
+HierarchyInfo = rq.Struct(
+        DEVICEID('deviceid'),
+        DEVICEID('attachment'),
+        DEVICEUSE('type'),
+        rq.Bool('enabled'),
+        rq.Pad(2),
+        rq.Card32('flags'),
+        )
+
+
+HierarchyEventData = rq.Struct(
+        DEVICEID('deviceid'),
+        rq.Card32('time'),
+        rq.Card32('flags'),
+        rq.LengthOf('info', 2),
+        rq.Pad(10),
+        rq.List('info', HierarchyInfo),
+        )
+
+
+def init(disp, info):
+    disp.extension_add_method('display', 'xinput_query_version', query_version)
+    disp.extension_add_method('window', 'xinput_select_events', select_events)
+
+    disp.ge_add_event_data(info.major_opcode, 11, HierarchyEventData)

Added: trunk/examples/xinput.py
===================================================================
--- trunk/examples/xinput.py	                        (rev 0)
+++ trunk/examples/xinput.py	2012-12-09 16:05:12 UTC (rev 161)
@@ -0,0 +1,80 @@
+#!/usr/bin/python
+#
+# examples/xinput.py -- demonstrate the XInput extension
+#
+#    Copyright (C) 2012 Outpost Embedded, LLC
+#      Forest Bond <forest.bond@...>
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+import sys
+
+from Xlib.display import Display
+from Xlib.ext import xinput
+
+
+def print_hierarchy_changed_event(event):
+    print '<deviceid=%s time=%s flags=%s info={' % (
+        event.data.deviceid,
+        event.data.time,
+        event.data.flags,
+        )
+    for info in event.data.info:
+        print_info(info)
+    print '}>'
+
+
+def print_info(info):
+    print '  <deviceid=%s attachment=%s type=%s enabled=%s flags=%s>' % (
+        info.deviceid,
+        info.attachment,
+        info.type,
+        info.enabled,
+        info.flags,
+        )
+
+
+def main(argv):
+    display = Display()
+    try:
+        extension_info = display.query_extension('XInputExtension')
+        xinput_major = extension_info.major_opcode
+
+        version_info = display.xinput_query_version()
+        print 'Found XInput version %u.%u' % (
+          version_info.major_version,
+          version_info.minor_version,
+        )
+
+        screen = display.screen()
+        screen.root.xinput_select_events([
+          (xinput.AllDevices, xinput.HierarchyChangedMask),
+        ])
+
+        while True:
+            event = display.next_event()
+            if (
+              event.type == display.extension_event.GenericEvent
+              and event.extension == xinput_major
+              and event.evtype == 11
+            ):
+                print_hierarchy_changed_event(event)
+
+    finally:
+        display.close()
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 159
          http://sourceforge.net/p/python-xlib/code/159
Author:   mwm
Date:     2013-02-07 13:35:46 +0000 (Thu, 07 Feb 2013)
Log Message:
-----------
Add the fixes & tests for nested structures.

Modified Paths:
--------------
    trunk/Xlib/protocol/rq.py

Added Paths:
-----------
    trunk/test/test_manual.py

Modified: trunk/Xlib/protocol/rq.py
===================================================================
--- trunk/Xlib/protocol/rq.py	2012-11-18 08:08:27 UTC (rev 158)
+++ trunk/Xlib/protocol/rq.py	2013-02-07 13:35:46 UTC (rev 159)
@@ -515,6 +515,8 @@
     def pack_value(self, val):
         # Single-char values, we'll assume that means integer lists.
         if self.type.structcode and len(self.type.structcode) == 1:
+            if self.type.check_value is not None:
+                val = [self.type.check_value(v) for v in val]
             data = array(struct_to_array_codes[self.type.structcode],
                                val).tostring()
         else:
@@ -568,9 +570,13 @@
             for f in self.type.fields:
                 if f.name:
                     if f.check_value is None:
-                        vals.append(val[i])
+                        v = val[i]
                     else:
-                        vals.append(f.check_value(val[i]))
+                        v = f.check_value(val[i])
+                    if f.structvalues == 1:
+                        vals.append(v)
+                    else:
+                        vals.extend(v)
                     i = i + 1
             return vals
 
@@ -585,9 +591,13 @@
         for f in self.type.fields:
             if f.name:
                 if f.check_value is None:
-                    vals.append(data[f.name])
+                    v = data[f.name]
                 else:
-                    vals.append(f.check_value(data[f.name]))
+                    v = f.check_value(data[f.name])
+                if f.structvalues == 1:
+                    vals.append(v)
+                else:
+                    vals.extend(v)
 
         return vals
 
@@ -821,6 +831,7 @@
         self.structcode = code
         self.structvalues = 1
         self.parse_value = None
+        self.check_value = None
 
 Card8Obj  = ScalarObj('B')
 Card16Obj = ScalarObj('H')
@@ -832,6 +843,7 @@
 
     def __init__(self, class_name):
         self.class_name = class_name
+        self.check_value = None
 
     def parse_value(self, value, display):
         # if not display:

Added: trunk/test/test_manual.py
===================================================================
--- trunk/test/test_manual.py	                        (rev 0)
+++ trunk/test/test_manual.py	2013-02-07 13:35:46 UTC (rev 159)
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import sys, os
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+
+import unittest
+from Xlib.protocol import rq
+
+class Custom(rq.Card32):
+    def check_value(self, value):
+        return int(value)
+    def parse_value(self, value, display):
+        return str(value)
+
+CustomObj = Custom(None)
+
+
+class TestNestedStruct(unittest.TestCase):
+    def setUp(self):
+        self.s1 = rq.Struct(rq.Card32('a1'), rq.Card32('a2'))
+        self.s2 = rq.Struct(rq.Object('b1', self.s1), rq.Object('b2', self.s1))
+        self.s3 = rq.Struct(rq.Object('c1', self.s2), rq.Object('c2', self.s2))
+
+    def testToBinary1(self):
+        self.s1.to_binary(1, 2)
+
+    def testToBinary2(self):
+        self.s2.to_binary((1, 2), (3, 4))
+
+    def testToBinary3(self):
+        self.s3.to_binary(((1, 2), (3, 4)), ((5, 6), (7, 8)))
+
+class TestNestedStructWithFancyValue(unittest.TestCase):
+    def setUp(self):
+        self.s1 = rq.Struct(Custom('a1'), Custom('a2'))
+        self.s2 = rq.Struct(rq.Object('b1', self.s1), rq.Object('b2', self.s1))
+        self.s3 = rq.Struct(rq.Object('c1', self.s2), rq.Object('c2', self.s2))
+
+    def testToBinary1(self):
+        self.s1.to_binary('1', '2')
+
+    def testToBinary2(self):
+        self.s2.to_binary(('1', '2'), ('3', '4'))
+
+    def testToBinary3(self):
+        self.s3.to_binary((('1', '2'), ('3', '4')), (('5', '6'), ('7', '8')))
+
+class TestListWithFancyValue(unittest.TestCase):
+    def setUp(self):
+        self.s1 = rq.Struct(rq.LengthOf('l', 4), rq.List('l', CustomObj))
+
+    def testToBinary1(self):
+        self.s1.to_binary(['1', '2', '3'])
+
+if __name__ == '__main__':
+    unittest.main()


Property changes on: trunk/test/test_manual.py
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 162
          http://python-xlib.svn.sourceforge.net/python-xlib/?rev=162&view=rev
Author:   forestatq
Date:     2013-03-12 13:22:17 +0000 (Tue, 12 Mar 2013)
Log Message:
-----------
security: Fix incorrect reply field order.  Somehow this worked on 32-bit
systems but not 64-bit systems.

Modified Paths:
--------------
    trunk/Xlib/ext/security.py

Property Changed:
----------------
    trunk/

Modified: trunk/Xlib/ext/security.py
===================================================================
--- trunk/Xlib/ext/security.py	2012-12-09 16:05:12 UTC (rev 161)
+++ trunk/Xlib/ext/security.py	2013-03-12 13:22:17 UTC (rev 162)
@@ -1,6 +1,6 @@
 # Xlib.ext.security -- SECURITY extension module
 #
-#    Copyright (C) 2010-2011 Outpost Embedded, LLC
+#    Copyright (C) 2010-2013 Outpost Embedded, LLC
 #      Forest Bond <forest.bond@...>
 #
 #    This program is free software; you can redistribute it and/or modify
@@ -80,8 +80,8 @@
                        rq.Card16('sequence_number'),
                        rq.ReplyLength(),
                        AUTHID('authid'),
+                       rq.LengthOf('auth_data_return', 2),
                        rq.Pad(18),
-                       rq.LengthOf('auth_data_return', 2),
                        rq.String8('auth_data_return')
                        )
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 160
          http://sourceforge.net/p/python-xlib/code/160
Author:   mggrant
Date:     2013-04-27 21:11:55 +0000 (Sat, 27 Apr 2013)
Log Message:
-----------
fixes for subcode events (xrandr being the main driver) - needs some more testing, but seems ok.  Patch by anYc from Freednode.

Modified Paths:
--------------
    trunk/Xlib/display.py
    trunk/Xlib/ext/randr.py
    trunk/Xlib/protocol/display.py
    trunk/Xlib/protocol/rq.py
    trunk/examples/xrandr.py

Modified: trunk/Xlib/display.py
===================================================================
--- trunk/Xlib/display.py	2013-02-07 13:35:46 UTC (rev 159)
+++ trunk/Xlib/display.py	2013-04-27 21:11:55 UTC (rev 160)
@@ -287,7 +287,7 @@
         the event class.  EVT will be cloned, and the attribute _code
         of the new event class will be set to CODE.
 
-        If NAME is ommitted, it will be set to the name of EVT.  This
+        If NAME is omitted, it will be set to the name of EVT.  This
         name is used to insert an entry in the DictWrapper
         extension_event.
         """
@@ -303,7 +303,30 @@
 
         setattr(self.extension_event, name, code)
 
+    def extension_add_subevent(self, code, subcode, evt, name = None):
+        """extension_add_subevent(code, evt, [name])
 
+        Add an extension subevent.  CODE is the numeric code, subcode
+        is the sub-ID of this event that shares the code ID with other
+        sub-events and EVT is the event class.  EVT will be cloned, and
+        the attribute _code of the new event class will be set to CODE.
+
+        If NAME is omitted, it will be set to the name of EVT.  This
+        name is used to insert an entry in the DictWrapper
+        extension_event.
+        """
+
+        newevt = new.classobj(evt.__name__, evt.__bases__,
+                              evt.__dict__.copy())
+        newevt._code = code
+
+        self.display.add_extension_event(code, newevt, subcode)
+
+        if name is None:
+            name = evt.__name__
+
+        setattr(self.extension_event, name, code)
+
     def add_extension_error(self, code, err):
         """add_extension_error(code, err)
 

Modified: trunk/Xlib/ext/randr.py
===================================================================
--- trunk/Xlib/ext/randr.py	2013-02-07 13:35:46 UTC (rev 159)
+++ trunk/Xlib/ext/randr.py	2013-04-27 21:11:55 UTC (rev 160)
@@ -1182,9 +1182,9 @@
     disp.extension_add_method('display', 'xrandr_set_panning', set_panning)
 
     disp.extension_add_event(info.first_event, ScreenChangeNotify)
-    disp.extension_add_event(info.first_event + 1, CrtcChangeNotify)
-    disp.extension_add_event(info.first_event + 2, OutputChangeNotify)
-    disp.extension_add_event(info.first_event + 3, OutputPropertyNotify)
+    disp.extension_add_subevent(info.first_event + 1, 0, CrtcChangeNotify)
+    disp.extension_add_subevent(info.first_event + 1, 1, OutputChangeNotify)
+    disp.extension_add_subevent(info.first_event + 1, 2, OutputPropertyNotify)
 
     #disp.extension_add_error(BadRROutput, BadRROutputError)
     #disp.extension_add_error(BadRRCrtc, BadRRCrtcError)

Modified: trunk/Xlib/protocol/display.py
===================================================================
--- trunk/Xlib/protocol/display.py	2013-02-07 13:35:46 UTC (rev 159)
+++ trunk/Xlib/protocol/display.py	2013-04-27 21:11:55 UTC (rev 160)
@@ -279,8 +279,14 @@
     def get_extension_major(self, extname):
         return self.extension_major_opcodes[extname]
 
-    def add_extension_event(self, code, evt):
-        self.event_classes[code] = evt
+    def add_extension_event(self, code, evt, subcode=None):
+       if subcode == None:
+           self.event_classes[code] = evt
+       else:
+           if not code in self.event_classes:
+               self.event_classes[code] = {subcode: evt}
+           else:
+               self.event_classes[code][subcode] = evt
 
     def add_extension_error(self, code, err):
         self.error_classes[code] = err
@@ -749,6 +755,9 @@
         # Skip bit 8 at lookup, that is set if this event came from an
         # SendEvent
         estruct = self.event_classes.get(etype & 0x7f, event.AnyEvent)
+        if type(estruct) == dict:
+            # this etype refers to a set of sub-events with individual subcodes
+            estruct = estruct[ord(self.data_recv[1])]
 
         e = estruct(display = self, binarydata = self.data_recv[:32])
 

Modified: trunk/Xlib/protocol/rq.py
===================================================================
--- trunk/Xlib/protocol/rq.py	2013-02-07 13:35:46 UTC (rev 159)
+++ trunk/Xlib/protocol/rq.py	2013-04-27 21:11:55 UTC (rev 160)
@@ -817,6 +817,9 @@
         import event
 
         estruct = display.event_classes.get(ord(data[0]) & 0x7f, event.AnyEvent)
+        if type(estruct) == dict:
+            # this etype refers to a set of sub-events with individual subcodes
+            estruct = estruct[ord(data[1])]
 
         return estruct(display = display, binarydata = data[:32]), buffer(data, 32)
 
@@ -1367,7 +1370,7 @@
 
 
 
-class GetAttrData:
+class GetAttrData(object):
     def __getattr__(self, attr):
         try:
             if self._data:

Modified: trunk/examples/xrandr.py
===================================================================
--- trunk/examples/xrandr.py	2013-02-07 13:35:46 UTC (rev 159)
+++ trunk/examples/xrandr.py	2013-04-27 21:11:55 UTC (rev 160)
@@ -148,23 +148,26 @@
                 sys.exit(0)
 
             # Screen information has changed
-            elif e.type == self.d.extension_event.ScreenChangeNotify:
+            elif e.__class__.__name__ == randr.ScreenChangeNotify.__name__:
                 print 'Screen change'
                 print self.pp.pprint(e._data)
 
             # CRTC information has changed
-            elif e.type == self.d.extension_event.CrtcChangeNotify:
+            elif e.__class__.__name__ == randr.CrtcChangeNotify.__name__:
                 print 'CRTC change'
+                #e = randr.CrtcChangeNotify(display=display.display, binarydata = e._binary)
                 print self.pp.pprint(e._data)
 
             # Output information has changed
-            elif e.type == self.d.extension_event.OutputChangeNotify:
+            elif e.__class__.__name__ == randr.OutputChangeNotify.__name__:
                 print 'Output change'
+                #e = randr.OutputChangeNotify(display=display.display, binarydata = e._binary)
                 print self.pp.pprint(e._data)
 
             # Output property information has changed
-            elif e.type == self.d.extension_event.OutputPropertyNotify:
+            elif e.__class__.__name__ == randr.OutputPropertyNotify.__name__:
                 print 'Output property change'
+                #e = randr.OutputPropertyNotify(display=display.display, binarydata = e._binary)
                 print self.pp.pprint(e._data)
 
             # Somebody wants to tell us something

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 163
          http://sourceforge.net/p/python-xlib/code/163
Author:   mggrant
Date:     2013-04-29 22:53:11 +0000 (Mon, 29 Apr 2013)
Log Message:
-----------
Treat subcodes as tuples in the (infrequently used) extension list.  Minor documentation points.

Modified Paths:
--------------
    trunk/Xlib/display.py
    trunk/Xlib/ext/randr.py
    trunk/examples/xrandr.py

Modified: trunk/Xlib/display.py
===================================================================
--- trunk/Xlib/display.py	2013-04-27 22:14:54 UTC (rev 162)
+++ trunk/Xlib/display.py	2013-04-29 22:53:11 UTC (rev 163)
@@ -97,6 +97,11 @@
         self.class_extension_dicts = {}
         self.display_extension_methods = {}
 
+        # a dict that maps the event name to the code
+        # or, when it's an event with a subcode, to a tuple of (event,subcode)
+        # note this wraps the dict so you address it as
+        # extension_event.EXTENSION_EVENT_NAME rather than
+        # extension_event["EXTENSION_EVENT_NAME"]
         self.extension_event = rq.DictWrapper({})
 
         exts = self.list_extensions()
@@ -325,7 +330,9 @@
         if name is None:
             name = evt.__name__
 
-        setattr(self.extension_event, name, code)
+        # store subcodes as a tuple of (event code, subcode) in the
+        # extension dict maintained in the display object
+        setattr(self.extension_event, name, (code,subcode))
 
     def add_extension_error(self, code, err):
         """add_extension_error(code, err)

Modified: trunk/Xlib/ext/randr.py
===================================================================
--- trunk/Xlib/ext/randr.py	2013-04-27 22:14:54 UTC (rev 162)
+++ trunk/Xlib/ext/randr.py	2013-04-29 22:53:11 UTC (rev 163)
@@ -26,6 +26,9 @@
 Version 1.2 of the protocol is documented at:
 http://cgit.freedesktop.org/xorg/proto/randrproto/tree/randrproto.txt
 
+Version 1.3.1 here:
+http://www.x.org/releases/X11R7.5/doc/randrproto/randrproto.txt
+
 """
 
 

Modified: trunk/examples/xrandr.py
===================================================================
--- trunk/examples/xrandr.py	2013-04-27 22:14:54 UTC (rev 162)
+++ trunk/examples/xrandr.py	2013-04-29 22:53:11 UTC (rev 163)
@@ -152,24 +152,30 @@
                 print 'Screen change'
                 print self.pp.pprint(e._data)
 
-            # CRTC information has changed
-            elif e.__class__.__name__ == randr.CrtcChangeNotify.__name__:
-                print 'CRTC change'
-                #e = randr.CrtcChangeNotify(display=display.display, binarydata = e._binary)
-                print self.pp.pprint(e._data)
+            # check if we're getting one of the RandR event types with subcodes
+            elif e.type == self.d.extension_event.CrtcChangeNotify[0]:
+                # yes, check the subcodes
 
-            # Output information has changed
-            elif e.__class__.__name__ == randr.OutputChangeNotify.__name__:
-                print 'Output change'
-                #e = randr.OutputChangeNotify(display=display.display, binarydata = e._binary)
-                print self.pp.pprint(e._data)
+                # CRTC information has changed
+                if (e.type, e.sub_code) == self.d.extension_event.CrtcChangeNotify:
+                    print 'CRTC change'
+                    #e = randr.CrtcChangeNotify(display=display.display, binarydata = e._binary)
+                    print self.pp.pprint(e._data)
 
-            # Output property information has changed
-            elif e.__class__.__name__ == randr.OutputPropertyNotify.__name__:
-                print 'Output property change'
-                #e = randr.OutputPropertyNotify(display=display.display, binarydata = e._binary)
-                print self.pp.pprint(e._data)
+                # Output information has changed
+                elif (e.type, e.sub_code) == self.d.extension_event.OutputChangeNotify:
+                    print 'Output change'
+                    #e = randr.OutputChangeNotify(display=display.display, binarydata = e._binary)
+                    print self.pp.pprint(e._data)
 
+                # Output property information has changed
+                elif (e.type, e.sub_code) == self.d.extension_event.OutputPropertyNotify:
+                    print 'Output property change'
+                    #e = randr.OutputPropertyNotify(display=display.display, binarydata = e._binary)
+                    print self.pp.pprint(e._data)
+                else:
+                    print "Unrecognised subcode", e.sub_code
+
             # Somebody wants to tell us something
             elif e.type == X.ClientMessage:
                 if e.client_type == self.WM_PROTOCOLS:

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.