Ticket #190: xpra-compoundtext-hooks.patch

wimpiggy/lowlevel/bindings.pyx

@@ -474 +479 @@
     pass
 class NoSuchProperty(PropertyError):
     pass
-def XGetWindowProperty(pywindow, property, req_type):
+def XGetWindowProperty(pywindow, property, req_types):
     # NB: Accepts req_type == 0 for AnyPropertyType
     # "64k is enough for anybody"
     # (Except, I've found window icons that are strictly larger, hence the
@@ -485 +490 @@
     cdef unsigned long nitems = 0, bytes_after = 0
     cdef unsigned char * prop = <unsigned char*> 0
     cdef Status status
-    xreq_type = get_xatom(req_type)
+    xreq_type = 0
+    if len(req_types)>0:
+        xreq_type = get_xatom(req_types[0])
     # This is the most bloody awful API I have ever seen.  You will probably
     # not be able to understand this code fully without reading
     # XGetWindowProperty's man page at least 3 times, slowly.
@@ -500 +507 @@
                                  xreq_type, &xactual_type,
                                  &actual_format, &nitems, &bytes_after, &prop)
     if status != Success:
-        raise PropertyError, "no such window"
+        raise PropertyError("no such window for %s" % pywindow)
     if xactual_type == XNone:
-        raise NoSuchProperty, property
-    if xreq_type and xreq_type != xactual_type:
-        raise BadPropertyType, xactual_type
+        raise NoSuchProperty("%s on %s" % (property, pywindow))
+    actual_type = get_pyatom(pywindow, xactual_type)
+    if req_types and actual_type not in req_types:
+        raise BadPropertyType("expected %s but found %s for %s" % (req_types, actual_type, property))
     # This should only occur for bad property types:
     assert not (bytes_after and not nitems)
     # actual_format is in (8, 16, 32), and is the number of bits in a logical
@@ -527 +535 @@
     data = PyString_FromStringAndSize(<char *>prop, nbytes)
     XFree(prop)
     if actual_format == 32:
-        return _munge_packed_longs_to_ints(data)
+        return actual_type, _munge_packed_longs_to_ints(data)
     else:
-        return data
+        return actual_type, data
 
 def XDeleteProperty(pywindow, property):
     cXDeleteProperty(get_xdisplay_for(pywindow),

wimpiggy/prop.py

@@ -51 +51 @@
     return data[:length]
 
 class WMSizeHints(object):
-    def __init__(self, disp, data):
+    def __init__(self, disp, t, data):
         # pre-ICCCM size is 15
         data = _force_length("WM_SIZE_HINTS", data, 18*4, noerror_length=15*4)
         (flags,
@@ -92 +92 @@
             self.min_aspect_ratio, self.max_aspect_ratio = (None, None)
 
 class WMHints(object):
-    def __init__(self, disp, data):
+    def __init__(self, disp, t, data):
         data = _force_length("WM_HINTS", data, 9 * 4)
         (flags, _input, initial_state,  #@UnusedVariable
          icon_pixmap, icon_window,      #@UnusedVariable
@@ -115 +115 @@
             self.input = None
 
 class NetWMStrut(object):
-    def __init__(self, disp, data):
+    def __init__(self, disp, t, data):
         # This eats both _NET_WM_STRUT and _NET_WM_STRUT_PARTIAL.  If we are
         # given a _NET_WM_STRUT instead of a _NET_WM_STRUT_PARTIAL, then it
         # will be only length 4 instead of 12, but _force_length will zero-pad
@@ -129 +129 @@
          self.bottom_start_x, self.bottom_stop_x,
          ) = struct.unpack("=" + "I" * 12, data)
 
-def _read_image(disp, stream):
+def _read_image(disp, t, stream):
     try:
         header = stream.read(2 * 4)
         if not header:
@@ -163 +163 @@
 
 # This returns a cairo ImageSurface which contains the largest icon defined in
 # a _NET_WM_ICON property.
-def NetWMIcons(disp, data):
+def NetWMIcons(disp, t, data):
     icons = []
     stream = StringIO(data)
     while True:
-        size_image = _read_image(disp, stream)
+        size_image = _read_image(disp, t, stream)
         if size_image is None:
             break
         icons.append(size_image)
@@ -176 +176 @@
     icons.sort()
     return icons[-1][1]
 
-def _get_atom(disp, d):
+def _get_atom(disp, t, d):
     unpacked = struct.unpack("@I", d)[0]
     pyatom = get_pyatom(disp, unpacked)
     if not pyatom:
@@ -184 +184 @@
         return  None
     return str(pyatom)
 
-def _get_multiple(disp, d):
+def _get_multiple(disp, t, d):
     uint_struct = struct.Struct("@I")
     log("get_multiple struct size=%s, len(%s)=%s", uint_struct.size, d, len(d))
     if len(d)!=uint_struct.size and False:
         log.info("get_multiple value is not an atom: %s", d)
         return  str(d)
-    return _get_atom(disp, d)
+    return _get_atom(disp, t, d)
 
 
 def set_xsettings_format(use_tuple=True):
     log("set_xsettings_format(%s)", use_tuple)
     global _prop_types
     if use_tuple:
-        _prop_types["xsettings-settings"] = (tuple, "_XSETTINGS_SETTINGS", 8,
+        _prop_types["xsettings-settings"] = (tuple, ["_XSETTINGS_SETTINGS"], 8,
                            set_settings,
                            get_settings,
                            None)
     else:
         #for old clients that rely on the old raw string format:
-        _prop_types["xsettings-settings"] = (str, "_XSETTINGS_SETTINGS", 8,
+        _prop_types["xsettings-settings"] = (str, ["_XSETTINGS_SETTINGS"], 8,
                            lambda disp, c: c,
                            lambda disp, d: d,
                            None)
 
+def encode_latin1(disp, t, u):
+    log.info("encode_latin1(%s,%s,%s)", disp, t, u)
+    return u.encode("latin1")
+def decode_latin1(disp, t, d):
+    log.info("decode_latin1(%s,%s,%s)", disp, t, d)
+    if t=="STRING":
+        return d.decode("latin1")
+    elif t=="COMPOUND_TEXT":
+        return  "VBLA"
+    else:
+        raise Exception("invalid encoding type: %s" % t)
 
+
 _prop_types = {
     # Python type, X type Atom, formatbits, serializer, deserializer, list
     # terminator
-    "utf8": (unicode, "UTF8_STRING", 8,
-             lambda disp, u: u.encode("UTF-8"),
-             lambda disp, d: d.decode("UTF-8"),
-             "\0"),
+    "utf8":          (unicode, ["UTF8_STRING"], 8,
+                      lambda disp, t, u: u.encode("UTF-8"),
+                      lambda disp, t, d: d.decode("UTF-8"),
+                      "\0"),
     # In theory, there should be something clever about COMPOUND_TEXT here.  I
     # am not sufficiently clever to deal with COMPOUNT_TEXT.  Even knowing
     # that Xutf8TextPropertyToTextList exists.
-    "latin1": (unicode, "STRING", 8,
-               lambda disp, u: u.encode("latin1"),
-               lambda disp, d: d.decode("latin1"),
-               "\0"),
-    "atom": (str, "ATOM", 32,
-             lambda disp, a: struct.pack("@I", get_xatom(a)),
-              _get_atom,
-             ""),
-    "u32": ((int, long), "CARDINAL", 32,
-            lambda disp, c: struct.pack("=I", c),
-            lambda disp, d: struct.unpack("=I", d)[0],
-            ""),
-    "window": (gtk.gdk.Window, "WINDOW", 32,
-               lambda disp, c: struct.pack("=I", get_xwindow(c)),
-               lambda disp, d: get_pywindow(disp, struct.unpack("=I", d)[0]),
-               ""),
-    "wm-size-hints": (WMSizeHints, "WM_SIZE_HINTS", 32,
+    "latin1":        (unicode, ["STRING", "COMPOUND_TEXT"], 8,
+                      encode_latin1,
+                      decode_latin1,
+                      "\0"),
+    "atom":          (str, ["ATOM"], 32,
+                      lambda disp, t, a: struct.pack("@I", get_xatom(a)),
+                      _get_atom,
+                      ""),
+    "u32":           ((int, long), ["CARDINAL"], 32,
+                      lambda disp, t, c: struct.pack("=I", c),
+                      lambda disp, t, d: struct.unpack("=I", d)[0],
+                      ""),
+    "window":        (gtk.gdk.Window, ["WINDOW"], 32,
+                      lambda disp, t, c: struct.pack("=I", get_xwindow(c)),
+                      lambda disp, t, d: get_pywindow(disp, struct.unpack("=I", d)[0]),
+                      ""),
+    "wm-size-hints": (WMSizeHints, ["WM_SIZE_HINTS"], 32,
                       unsupported,
                       WMSizeHints,
                       None),
-    "wm-hints": (WMHints, "WM_HINTS", 32,
-                 unsupported,
-                 WMHints,
-                 None),
-    "strut": (NetWMStrut, "CARDINAL", 32,
-              unsupported, NetWMStrut, None),
-    "strut-partial": (NetWMStrut, "CARDINAL", 32,
-                      unsupported, NetWMStrut, None),
-    "icon": (cairo.ImageSurface, "CARDINAL", 32,
-             unsupported, NetWMIcons, None),
-    "xsettings-settings": (tuple, "_XSETTINGS_SETTINGS", 8,
-                           set_settings,
-                           get_settings,
-                           None),
+    "wm-hints":      (WMHints, ["WM_HINTS"], 32,
+                      unsupported,
+                      WMHints,
+                      None),
+    "strut":         (NetWMStrut, ["CARDINAL"], 32,
+                      unsupported,
+                      NetWMStrut,
+                      None),
+    "strut-partial": (NetWMStrut, ["CARDINAL"], 32,
+                      unsupported,
+                      NetWMStrut,
+                      None),
+    "icon":          (cairo.ImageSurface, ["CARDINAL"], 32,
+                      unsupported,
+                      NetWMIcons,
+                      None),
+    "xsettings-settings": (tuple, ["_XSETTINGS_SETTINGS"], 8,
+                      set_settings,
+                      get_settings,
+                      None),
     # For uploading ad-hoc instances of the above complex structures to the
     # server, so we can test reading them out again:
-    "debug-CARDINAL": (str, "CARDINAL", 32,
-                       lambda disp, c: c,
-                       lambda disp, d: d,
-                       None),
+    "debug-CARDINAL":(str, ["CARDINAL"], 32,
+                      lambda disp, t, c: c,
+                      lambda disp, t, d: d,
+                      None),
     # For fetching the extra information on a MULTIPLE clipboard conversion
     # request. The exciting thing about MULTIPLE is that it's not actually
     # specified what 'type' one should use; you just fetch with
     # AnyPropertyType and assume that what you get is a bunch of pairs of
     # atoms.
-    "multiple-conversion": (str, 0, 32, unsupported, _get_multiple, None),
+    "multiple-conversion": (str, [0], 32,
+                      unsupported,
+                      _get_multiple,
+                      None),
     }
 
 def _prop_encode(disp, etype, value):
@@ -274 +295 @@
         return _prop_encode_scalar(disp, etype, value)
 
 def _prop_encode_scalar(disp, etype, value):
-    (pytype, atom, formatbits, serialize, _, _) = _prop_types[etype]
-    assert isinstance(value, pytype), "value for atom %s is not a %s: %s" % (atom, pytype, type(value))
-    return (atom, formatbits, serialize(disp, value))
+    pytype, atoms, formatbits, serialize, _, _ = _prop_types[etype]
+    assert isinstance(value, pytype), "value for atoms %s is not a %s: %s" % (atoms, pytype, type(value))
+    return atoms[0], formatbits, serialize(disp, atoms[0], value)
 
 def _prop_encode_list(disp, etype, value):
-    (_, atom, formatbits, _, _, terminator) = _prop_types[etype]
+    _, atoms, formatbits, _, _, terminator = _prop_types[etype]
     value = list(value)
     serialized = [_prop_encode_scalar(disp, etype, v)[2] for v in value]
     no_none = [x for x in serialized if x is not None]
     # Strings in X really are null-separated, not null-terminated (ICCCM
     # 2.7.1, see also note in 4.1.2.5)
-    return (atom, formatbits, terminator.join(no_none))
+    return atoms[0], formatbits, terminator.join(no_none)
 
 
 def prop_set(target, key, etype, value):
-    trap.call_unsynced(XChangeProperty, target, key,
-                       _prop_encode(target, etype, value))
+    enc = _prop_encode(target, etype, value)
+    log.info("prop_set(%s,%s,%s,%s) enc=%s", target, key, etype, value, enc)
+    trap.call_unsynced(XChangeProperty, target, key, enc)
 
-def _prop_decode(disp, etype, data):
+def _prop_decode(disp, actual_type, etype, data):
     if isinstance(etype, list):
-        return _prop_decode_list(disp, etype[0], data)
+        return _prop_decode_list(disp, actual_type, etype[0], data)
     else:
-        return _prop_decode_scalar(disp, etype, data)
+        return _prop_decode_scalar(disp, actual_type, etype, data)
 
-def _prop_decode_scalar(disp, etype, data):
-    (pytype, _, _, _, deserialize, _) = _prop_types[etype]
-    value = deserialize(disp, data)
+def _prop_decode_scalar(disp, actual_type, etype, data):
+    pytype, _, _, _, deserialize, _ = _prop_types[etype]
+    value = deserialize(disp, actual_type, data)
     assert value is None or isinstance(value, pytype), "expected a %s but value is a %s" % (pytype, type(value))
     return value
 
-def _prop_decode_list(disp, etype, data):
-    (_, _, formatbits, _, _, terminator) = _prop_types[etype]
+def _prop_decode_list(disp, actual_type, etype, data):
+    _, _, formatbits, _, _, terminator = _prop_types[etype]
     if terminator:
         datums = data.split(terminator)
     else:
@@ -314 +336 @@
         while data:
             datums.append(data[:nbytes])
             data = data[nbytes:]
-    props = [_prop_decode_scalar(disp, etype, datum) for datum in datums]
+    props = [_prop_decode_scalar(disp, actual_type, etype, datum) for datum in datums]
     #assert None not in props
     return [x for x in props if x is not None]
 
@@ -324 +346 @@
         scalar_type = etype[0]
     else:
         scalar_type = etype
-    (_, atom, _, _, _, _) = _prop_types[scalar_type]
+    log.info("prop_get(%s, %s, %s, %s) scalar_type=%s", target, key, etype, ignore_errors, scalar_type)
+    _, atoms, _, _, _, _ = _prop_types[scalar_type]
     try:
         #print(atom)
-        data = trap.call_synced(XGetWindowProperty, target, key, atom)
+        actual_type, data = trap.call_synced(XGetWindowProperty, target, key, atoms)
         #print(atom, repr(data[:100]))
     except NoSuchProperty:
         log.debug("Missing property %s (%s)", key, etype)
@@ -338 +361 @@
             traceback.print_exc()
         return None
     try:
-        return _prop_decode(target, etype, data)
+        log.info("prop_get(..) actual_type=%s, data=%s", actual_type, data)
+        return _prop_decode(target, actual_type, etype, data)
     except:
         log.warn("Error parsing property %s (type %s); this may be a"
                  + " misbehaving application, or bug in Wimpiggy\n"

wimpiggy/xsettings_prop.py

@@ -35 +35 @@
 XSettingsTypeColor = 2
 
 
-def get_settings(disp, d):
+def get_settings(disp, t, d):
     #parse xsettings according to
     #http://standards.freedesktop.org/xsettings-spec/xsettings-spec-0.5.html
     assert len(d)>=12, "_XSETTINGS_SETTINGS property is too small: %s" % len(d)
@@ -77 +77 @@
     debug("parse_xsettings(..) settings=%s", settings)
     return  serial, settings
 
-def set_settings(disp, d):
+def set_settings(disp, t, d):
     #TODO: detect old clients
     assert len(d)==2, "invalid format for XSETTINGS: %s" % str(d)
     serial, settings = d