Python prop.prop_get函数代码示例

 def property_changed(self, widget, event):
     statelog("%s.property_changed(%s, %s) : %s", self, widget, event, event.atom)
     if event.atom=="_NET_WM_DESKTOP" and self._been_mapped and not self._override_redirect:
         self.do_workspace_changed(event)
     elif event.atom=="XKLAVIER_STATE":
         #unused for now, but log it:
         xklavier_state = prop_get(self.get_window(), "XKLAVIER_STATE", ["integer"], ignore_errors=False)
         keylog("XKLAVIER_STATE=%s", [hex(x) for x in (xklavier_state or [])])
     elif event.atom=="_NET_WM_STATE":
         wm_state_atoms = prop_get(self.get_window(), "_NET_WM_STATE", ["atom"], ignore_errors=False)
         #code mostly duplicated from gtk_x11/window.py:
         WM_STATE_NAME = {
                          "fullscreen"            : ("_NET_WM_STATE_FULLSCREEN", ),
                          "maximized"             : ("_NET_WM_STATE_MAXIMIZED_VERT", "_NET_WM_STATE_MAXIMIZED_HORZ"),
                          "shaded"                : ("_NET_WM_STATE_SHADED", ),
                          "sticky"                : ("_NET_WM_STATE_STICKY", ),
                          "skip-pager"            : ("_NET_WM_STATE_SKIP_PAGER", ),
                          "skip-taskbar"          : ("_NET_WM_STATE_SKIP_TASKBAR", ),
                          "above"                 : ("_NET_WM_STATE_ABOVE", ),
                          "below"                 : ("_NET_WM_STATE_BELOW", ),
                          }
         state_atoms = set(wm_state_atoms or [])
         state_updates = {}
         for state, atoms in WM_STATE_NAME.items():
             var = "_" + state.replace("-", "_")           #ie: "skip-pager" -> "_skip_pager"
             cur_state = getattr(self, var)
             wm_state_is_set = set(atoms).issubset(state_atoms)
             if wm_state_is_set and not cur_state:
                 state_updates[state] = True
             elif cur_state and not wm_state_is_set:
                 state_updates[state] = False
         log("_NET_WM_STATE=%s, state_updates=%s", wm_state_atoms, state_updates)
         if state_updates:
             self.update_window_state(state_updates)

def wm_check(display, upgrading=False):
    #there should only be one screen... but let's check all of them
    for i in range(display.get_n_screens()):
        screen = display.get_screen(i)
        root = screen.get_root_window()
        wm_prop = "WM_S%s" % i
        cwm_prop = "_NEW_WM_CM_S%s" % i
        wm_so = X11Window.XGetSelectionOwner(wm_prop)
        cwm_so = X11Window.XGetSelectionOwner(cwm_prop)
        log("ewmh selection owner for %s: %s", wm_prop, wm_so)
        log("compositing window manager %s: %s", cwm_prop, cwm_so)

        try:
            ewmh_wm = prop_get(root, "_NET_SUPPORTING_WM_CHECK", "window", ignore_errors=True, raise_xerrors=False)
        except:
            #errors here generally indicate that the window is gone
            #which is fine: it means the previous window manager is no longer active
            continue
        log("_NET_SUPPORTING_WM_CHECK for screen %s: %s", i, ewmh_wm)
        if ewmh_wm:
            try:
                name = prop_get(ewmh_wm, "_NET_WM_NAME", "utf8", ignore_errors=False, raise_xerrors=False)
            except:
                name = None
            if upgrading and name and name==WM_WINDOW_NAME:
                log.info("found previous Xpra instance")
            else:
                log.warn("Warning: found an existing window manager on screen %s using window %#x: %s", i, ewmh_wm.xid, name or "unknown")
            if (wm_so is None or wm_so==0) and (cwm_so is None or cwm_so==0):
                log.error("it does not own the selection '%s' or '%s' so we cannot take over and make it exit", wm_prop, cwm_prop)
                log.error("please stop %s so you can run xpra on this display", name or "the existing window manager")
                return False
    return True

 def property_changed(self, widget, event):
     statelog("property_changed(%s, %s) : %s", widget, event, event.atom)
     if event.atom=="_NET_WM_DESKTOP" and self._been_mapped and not self._override_redirect:
         self.do_workspace_changed(event)
     elif event.atom=="_NET_FRAME_EXTENTS":
         v = prop_get(self.get_window(), "_NET_FRAME_EXTENTS", ["u32"], ignore_errors=False)
         statelog("_NET_FRAME_EXTENTS: %s", v)
         if v:
             if v==self._current_frame_extents:
                 #unchanged
                 return
             if not self._been_mapped:
                 #map event will take care of sending it
                 return
             if self.is_OR() or self.is_tray():
                 #we can't do it: the server can't handle configure packets for OR windows!
                 return
             if not self._client.window_configure_skip_geometry or not self._client.server_window_frame_extents:
                 #can't send cheap "skip-geometry" packets or frame-extents feature not supported:
                 return
             #tell server about new value:
             #TODO: don't bother if unchanged
             self._current_frame_extents = v
             statelog("sending configure event to update _NET_FRAME_EXTENTS to %s", v)
             self._window_state["frame"] = self._client.crect(*v)
             self.send_configure_event(True)
     elif event.atom=="XKLAVIER_STATE":
         #unused for now, but log it:
         xklavier_state = prop_get(self.get_window(), "XKLAVIER_STATE", ["integer"], ignore_errors=False)
         keylog("XKLAVIER_STATE=%s", [hex(x) for x in (xklavier_state or [])])
     elif event.atom=="_NET_WM_STATE":
         wm_state_atoms = prop_get(self.get_window(), "_NET_WM_STATE", ["atom"], ignore_errors=False)
         #code mostly duplicated from gtk_x11/window.py:
         WM_STATE_NAME = {
                          "fullscreen"            : ("_NET_WM_STATE_FULLSCREEN", ),
                          "maximized"             : ("_NET_WM_STATE_MAXIMIZED_VERT", "_NET_WM_STATE_MAXIMIZED_HORZ"),
                          "shaded"                : ("_NET_WM_STATE_SHADED", ),
                          "sticky"                : ("_NET_WM_STATE_STICKY", ),
                          "skip-pager"            : ("_NET_WM_STATE_SKIP_PAGER", ),
                          "skip-taskbar"          : ("_NET_WM_STATE_SKIP_TASKBAR", ),
                          "above"                 : ("_NET_WM_STATE_ABOVE", ),
                          "below"                 : ("_NET_WM_STATE_BELOW", ),
                          "focused"               : ("_NET_WM_STATE_FOCUSED", ),
                          }
         state_atoms = set(wm_state_atoms or [])
         state_updates = {}
         for state, atoms in WM_STATE_NAME.items():
             var = "_" + state.replace("-", "_")           #ie: "skip-pager" -> "_skip_pager"
             cur_state = getattr(self, var)
             wm_state_is_set = set(atoms).issubset(state_atoms)
             if wm_state_is_set and not cur_state:
                 state_updates[state] = True
             elif cur_state and not wm_state_is_set:
                 state_updates[state] = False
         log("_NET_WM_STATE=%s, state_updates=%s", wm_state_atoms, state_updates)
         if state_updates:
             self.update_window_state(state_updates)

def wm_check(display, wm_name, upgrading=False):
    # there should only be one screen... but let's check all of them
    for i in range(display.get_n_screens()):
        screen = display.get_screen(i)
        root = screen.get_root_window()
        wm_prop = "WM_S%s" % i
        cwm_prop = "_NEW_WM_CM_S%s" % i
        wm_so = X11Window.XGetSelectionOwner(wm_prop)
        cwm_so = X11Window.XGetSelectionOwner(cwm_prop)
        log("ewmh selection owner for %s: %s", wm_prop, wm_so)
        log("compositing window manager %s: %s", cwm_prop, cwm_so)

        try:
            ewmh_wm = prop_get(root, "_NET_SUPPORTING_WM_CHECK", "window", ignore_errors=True, raise_xerrors=False)
        except:
            # errors here generally indicate that the window is gone
            # which is fine: it means the previous window manager is no longer active
            continue

        def xid(w):
            if w:
                return "%#x" % w.xid
            return None

        log("_NET_SUPPORTING_WM_CHECK for screen %i: %s (root=%s)", i, xid(ewmh_wm), xid(root))
        if ewmh_wm:
            try:
                name = prop_get(ewmh_wm, "_NET_WM_NAME", "utf8", ignore_errors=False, raise_xerrors=False)
            except:
                name = None
            if upgrading and name and name == wm_name:
                log.info("found previous Xpra instance")
            else:
                log.warn(
                    "Warning: found an existing window manager on screen %s using window %#x: %s",
                    i,
                    ewmh_wm.xid,
                    name or "unknown",
                )
            if (wm_so is None or wm_so == 0) and (cwm_so is None or cwm_so == 0):
                if FORCE_REPLACE_WM:
                    log.warn("XPRA_FORCE_REPLACE_WM is set, replacing it forcibly")
                else:
                    log.error(
                        "it does not own the selection '%s' or '%s' so we cannot take over and make it exit",
                        wm_prop,
                        cwm_prop,
                    )
                    log.error(
                        "please stop %s so you can run xpra on this display", name or "the existing window manager"
                    )
                    log.warn("if you are certain that the window manager is already gone,")
                    log.warn(" you may set XPRA_FORCE_REPLACE_WM=1 to force xpra to continue, at your own risk")
                    return False
    return True

def _get_xresources():
    try:
        from xpra.x11.gtk_x11.prop import prop_get
        import gtk.gdk
        root = gtk.gdk.get_default_root_window()
        v = prop_get(root, "RESOURCE_MANAGER", "latin1", ignore_errors=True)
        log("RESOURCE_MANAGER=%s", v)
        if v is None:
            return None
        value = v.decode("utf-8")
        #parse the resources into a dict:
        values={}
        options = value.split("\n")
        for option in options:
            if not option:
                continue
            parts = option.split(":\t", 1)
            if len(parts)!=2:
                log("skipped invalid option: '%s'", option)
                continue
            values[parts[0]] = parts[1]
        return values
    except Exception as e:
        log("_get_xresources error: %s", e)
    return None

 def do_xpra_client_message_event(self, event):
     # FIXME
     # Need to listen for:
     #   _NET_ACTIVE_WINDOW
     #   _NET_CURRENT_DESKTOP
     #   _NET_WM_PING responses
     # and maybe:
     #   _NET_RESTACK_WINDOW
     #   _NET_WM_STATE
     log("do_xpra_client_message_event(%s)", event)
     if event.message_type=="_NET_SHOWING_DESKTOP":
         show = bool(event.data[0])
         self.emit("show-desktop", show)
     elif event.message_type=="_NET_REQUEST_FRAME_EXTENTS":
         #if we're here, that means the window model does not exist
         #(or it would have processed the event)
         #so this must be a an unmapped window
         frame = (0, 0, 0, 0)
         if not X11Window.is_override_redirect(event.window.xid):
             #use the global default:
             frame = prop_get(self._root, "DEFAULT_NET_FRAME_EXTENTS", ["u32"], ignore_errors=True)
         if not frame:
             #fallback:
             frame = (0, 0, 0, 0)
         log("_NET_REQUEST_FRAME_EXTENTS: setting _NET_FRAME_EXTENTS=%s on %#x", frame, event.window.xid)
         with xswallow:
             prop_set(event.window, "_NET_FRAME_EXTENTS", ["u32"], frame)

 def do_selection_request_event(self, event):
     debug("do_selection_request_event(%s)", event)
     self._selection_request_events += 1
     if not self._enabled:
         gtk.Invisible.do_selection_request_event(self, event)
         return
     # Black magic: the superclass default handler for this signal
     # implements all the hards parts of selection handling, occasionally
     # calling back to the do_selection_get handler (below) to actually get
     # the data to be sent.  However, it only does this for targets that
     # have been registered ahead of time; other targets fall through to a
     # default implementation that cannot be overridden.  So, we swoop in
     # ahead of time and add whatever target was requested to the list of
     # targets we want to handle!
     #
     # Special cases (magic targets defined by ICCCM):
     #   TIMESTAMP: the remote side has a different timeline than us, so
     #     sending TIMESTAMPS across the wire doesn't make any sense. We
     #     ignore TIMESTAMP requests, and let them fall through to GTK+'s
     #     default handler.
     #   TARGET: GTK+ has default handling for this, but we don't want to
     #     use it. Fortunately, if we tell GTK+ that we can handle TARGET
     #     requests, then it will pass them on to us rather than fall
     #     through to the default handler.
     #   MULTIPLE: Ugh. To handle this properly, we need to go out
     #     ourselves and fetch the magic property off the requesting window
     #     (with proper error trapping and all), and interpret its
     #     contents. Probably doable (FIXME), just a pain.
     #
     # Another special case is that if an app requests the contents of a
     # clipboard that it currently owns, then GTK+ will short-circuit the
     # normal logic and request the contents directly (i.e. it calls
     # gtk_selection_invoke_handler) -- without giving us a chance to
     # assert that we can handle the requested sort of target. Fortunately,
     # Xpra never needs to request the clipboard when it owns it, so that's
     # okay.
     assert str(event.selection) == self._selection
     target = str(event.target)
     if target == "TIMESTAMP":
         pass
     elif target == "MULTIPLE":
         try:
             from xpra.x11.gtk_x11.prop import prop_get
         except ImportError:
             debug("MULTIPLE for property '%s' not handled due to missing xpra.x11.gtk_x11 bindings", event.property)
             gtk.Invisible.do_selection_request_event(self, event)
             return
         atoms = prop_get(event.window, event.property, ["multiple-conversion"])
         debug("MULTIPLE clipboard atoms: %r", atoms)
         if atoms:
             targets = atoms[::2]
             for t in targets:
                 self.selection_add_target(self._selection, t, 0)
     else:
         debug("target for %s: %r", self._selection, target)
         self.selection_add_target(self._selection, target, 0)
     debug("do_selection_request_event(%s) target=%s, selection=%s", event, target, self._selection)
     gtk.Invisible.do_selection_request_event(self, event)

 def _handle_motif_wm_hints_change(self):
     #motif_hints = self.prop_get("_MOTIF_WM_HINTS", "motif-hints")
     motif_hints = prop_get(self.client_window, "_MOTIF_WM_HINTS", "motif-hints", ignore_errors=False, raise_xerrors=True)
     metalog("_MOTIF_WM_HINTS=%s", motif_hints)
     if motif_hints:
         if motif_hints.flags & (2**MotifWMHints.DECORATIONS_BIT):
             self._updateprop("decorations", motif_hints.decorations)
         if motif_hints.flags & (2**MotifWMHints.INPUT_MODE_BIT):
             self._updateprop("modal", bool(motif_hints.input_mode))

 def show_current_workspace(self, *args):
     try:
         workspace = prop_get(self.window.get_window(), "_NET_WM_DESKTOP", "u32")
         if workspace is None:
             workspace = ""
         self.entry.set_text(str(workspace))
         self.warn.set_text("")
     except Exception as e:
         self.warn.set_text(str(e))

 def print_extents():
     v = prop_get(win.get_window(), "_NET_FRAME_EXTENTS", ["u32"], ignore_errors=False)
     print("_NET_FRAME_EXTENTS: %s" % str(v))
     with xsync:
         event_mask = SubstructureNotifyMask | SubstructureRedirectMask
         X11Window.sendClientMessage(root.xid, win.get_window().xid, False, event_mask,
                   "_NET_REQUEST_FRAME_EXTENTS")
         print("sending _NET_REQUEST_FRAME_EXTENTS to %#x for %#x" % (root.xid, win.get_window().xid))
     return v is None

 def prop_get(self, key, ptype, ignore_errors=None, raise_xerrors=False):
     """
         Get an X11 property from the client window,
         using the automatic type conversion code from prop.py
         Ignores property errors during setup_client.
     """
     if ignore_errors is None and (not self._setup_done or not self._managed):
         ignore_errors = True
     return prop_get(self.client_window, key, ptype, ignore_errors=bool(ignore_errors), raise_xerrors=raise_xerrors)

 def dock_tray(self, xid):
     root = gtk.gdk.get_default_root_window()
     window = gtk.gdk.window_foreign_new(xid)
     if window is None:
         log.warn("could not find gdk window for tray window %#x", xid)
         return
     w, h = window.get_geometry()[2:4]
     event_mask = gtk.gdk.STRUCTURE_MASK | gtk.gdk.EXPOSURE_MASK | gtk.gdk.PROPERTY_CHANGE_MASK
     window.set_events(event_mask=event_mask)
     add_event_receiver(window, self)
     w = max(1, min(64, w))
     h = max(1, min(64, h))
     title = prop_get(window, "_NET_WM_NAME", "utf8", ignore_errors=True)
     if title is None:
         title = prop_get(window, "WM_NAME", "latin1", ignore_errors=True)
     if title is None:
         title = ""
     log("dock_tray(%#x) gdk window=%#x, geometry=%s, title=%s, visual.depth=%s", xid, window.xid, window.get_geometry(), title, window.get_visual().depth)
     event_mask = gtk.gdk.STRUCTURE_MASK | gtk.gdk.EXPOSURE_MASK | gtk.gdk.PROPERTY_CHANGE_MASK
     tray_window = gtk.gdk.Window(root, width=w, height=h,
                                        window_type=gtk.gdk.WINDOW_TOPLEVEL,
                                        event_mask = event_mask,
                                        wclass=gtk.gdk.INPUT_OUTPUT,
                                        title=title,
                                        x=-200, y=-200,
                                        override_redirect=True,
                                        visual=window.get_visual(),
                                        colormap=window.get_colormap())
     log("dock_tray(%#x) setting tray properties", xid)
     set_tray_window(tray_window, window)
     tray_window.show()
     self.tray_windows[window] = tray_window
     self.window_trays[tray_window] = window
     log("dock_tray(%#x) resizing and reparenting", xid)
     window.resize(w, h)
     xwin = window.xid
     xtray = tray_window.xid
     X11Window.Withdraw(xwin)
     X11Window.Reparent(xwin, xtray, 0, 0)
     X11Window.MapRaised(xwin)
     log("dock_tray(%#x) new tray container window %#x", xid, xtray)
     tray_window.invalidate_rect(gtk.gdk.Rectangle(width=w, height=h), True)
     X11Window.send_xembed_message(xwin, XEMBED_EMBEDDED_NOTIFY, 0, xtray, XEMBED_VERSION)

def get_x11_window_value(filter_object, window):
    xid = get_xid(window)
    #log("get_x11_window_value(%s, %s) xid=%#x", filter_object, window, xid)
    with xsync:
        x11type = window_bindings.GetWindowPropertyType(xid, filter_object.property_name)
        ptype = get_python_type(x11type)
        #log("%s: %s (%s)", filter_object.property_name, x11type, ptype)
        assert ptype, "type '%s' is not handled!" % x11type
        v = prop_get(window, filter_object.property_name, ptype)
    log("%s=%s", filter_object.property_name, v)
    return v

 def get_settings(self):
     owner = self.xsettings_owner()
     log("Fetching current XSettings data, owner=%s", owner)
     if owner is None:
         return None
     try:
         with xsync:
             return prop_get(owner, XSETTINGS, XSETTINGS_TYPE)
     except XError:
         log("X error while fetching XSettings data; ignored")
         return None

 def get_resource_manager(self):
     try:
         import gtk.gdk
         root = gtk.gdk.get_default_root_window()
         from xpra.x11.gtk_x11.prop import prop_get
         value = prop_get(root, "RESOURCE_MANAGER", "latin1", ignore_errors=True)
         if value is not None:
             return value.encode("utf-8")
     except:
         log.error("failed to get RESOURCE_MANAGER", exc_info=True)
     return None