コード例 #1
0
ファイル: screen.py プロジェクト: Anthony25/barython
def get_randr_screens():
    conn = xcffib.connect()
    conn.randr = conn(xcffib.randr.key)

    window = conn.get_setup().roots[0].root
    resources = conn.randr.GetScreenResourcesCurrent(window).reply()
    outputs = OrderedDict()

    for rroutput in resources.outputs:
        try:
            cookie = conn.randr.GetOutputInfo(
                rroutput, resources.config_timestamp
            )
            info = cookie.reply()
            name = "".join(map(chr, info.name))
            cookie = conn.randr.GetCrtcInfo(
                info.crtc, resources.config_timestamp
            )
            info = cookie.reply()
            if info:
                outputs[name] = (info.width, info.height, info.x, info.y)
        except Exception as e:
            logger.debug("Error when trying to fetch screens infos")
            logger.debug(e)
            continue
    return outputs
コード例 #2
0
ファイル: conftest.py プロジェクト: AlexTalker/qtile
def xvfb():
    display = ":{:d}".format(_find_display())
    args = ["Xvfb", display, "-screen", "0", "800x600x16"]
    proc = subprocess.Popen(args)

    try:
        # wait for X display to come up
        start = time.time()
        while proc.poll() is None and time.time() < start + max_sleep:
            try:
                conn = xcffib.connect(display)
            except xcffib.ConnectionException:
                time.sleep(sleep_time)
            else:
                conn.disconnect()
                break
        else:
            raise OSError("Xvfb did not come up")

        os.environ["DISPLAY"] = display

        yield
    finally:
        proc.terminate()
        proc.wait()
コード例 #3
0
ファイル: xcb_backend.py プロジェクト: lereldarion/slam
    def init_randr_connection (self, **kwd):
        """ Starts connection, construct an initial state, setup events. """
        # Connection
        self.conn = xcffib.connect (display = kwd.get ("display"))
        
        # Randr init
        self.conn.randr = self.conn (xcffib.randr.key)
        version = Pair.from_struct (self.conn.randr.QueryVersion (*Backend.randr_version).reply (), "major_version", "minor_version")
        if (not version >= Backend.randr_version):
            raise BackendFatalError ("version: requested >= {}, got {}".format (Client.randr_version, version))

        # Properties query object
        self.prop_manager = PropertyQuery (self.conn) # TODO

        # Internal state 
        screen_setup = self.conn.setup.roots[kwd.get ("screen", self.conn.pref_screen)]
        self.root = screen_setup.root
        
        limits = self.conn.randr.GetScreenSizeRange (self.root).reply ()
        self.screen_limit_min = Pair.from_size (limits, "min_{}")
        self.screen_limit_max = Pair.from_size (limits, "max_{}")
        
        self.reload_state ()

        # Randr register for events
        masks = xcffib.randr.NotifyMask.ScreenChange | xcffib.randr.NotifyMask.CrtcChange
        masks |= xcffib.randr.NotifyMask.OutputChange | xcffib.randr.NotifyMask.OutputProperty
        self.conn.randr.SelectInput (self.root, masks)
        self.conn.flush ()
コード例 #4
0
 def run_single_trial_one_library(self, library):
     """Runs a single trial with one library"""
     connection = connect()
     setup = connection.get_setup()
     root_window = setup.roots[0].root
     window = self.warp_to_random_window(connection, root_window)
     position = self.get_pointer_position(connection, window)
     connection.disconnect()
     pointer_window = library()
     lib = pointer_window.library
     timing = pointer_window.find_window()[2]
     del pointer_window
     self.write_result_row({
         'library': lib,
         'root_x': position.root_x,
         'root_y': position.root_y,
         'window': window,
         'win_x': position.win_x,
         'win_y': position.win_y,
         'start': timing[0],
         'gather_basics': timing[1],
         'root_window': timing[2],
         'recursion': timing[3],
         'get_names': timing[4],
         'parse_names': timing[5],
         'exit': timing[6]
     })
コード例 #5
0
def get_window_id(prop, value):
    window_id = 0

    c = xcffib.connect()
    root = c.get_setup().roots[0].root

    _NET_CLIENT_LIST = c.core.InternAtom(True, len('_NET_CLIENT_LIST'),
                                         '_NET_CLIENT_LIST').reply().atom

    raw_clientlist = c.core.GetProperty(False, root, _NET_CLIENT_LIST,
                                        xcffib.xproto.GetPropertyType.Any,
                                        0, 2 ** 32 - 1).reply()
    clientlist = get_property_value(raw_clientlist)

    cookies = {}
    for ident in clientlist:
        if prop in dir(xcffib.xproto.Atom):
            atom = getattr(xcffib.xproto.Atom, prop)
        else:
            atom = c.core.InternAtom(True, len(prop), prop).reply().atom
        cookies[ident] = c.core.GetProperty(False, ident, atom,
                                            xcffib.xproto.GetPropertyType.Any,
                                            0, 2 ** 32 - 1)

    for ident in cookies:
        winclass = get_property_value(cookies[ident].reply())
        if isinstance(winclass, list):
            if value in winclass:
                window_id = ident
                break

    c.disconnect()
    return window_id
コード例 #6
0
ファイル: xcbq.py プロジェクト: JasonXJ/qtile
    def __init__(self, display):
        self.conn = xcffib.connect(display=display)
        self._connected = True
        self.cursors = Cursors(self)
        self.setup = self.conn.get_setup()
        extensions = self.extensions()
        self.screens = [Screen(self, i) for i in self.setup.roots]
        self.default_screen = self.screens[self.conn.pref_screen]
        for i in extensions:
            if i in self._extmap:
                setattr(self, i, self._extmap[i](self))

        self.pseudoscreens = []
        if "xinerama" in extensions:
            for i, s in enumerate(self.xinerama.query_screens()):
                scr = PseudoScreen(self, s.x_org, s.y_org, s.width, s.height)
                self.pseudoscreens.append(scr)
        elif "randr" in extensions:
            for i in self.randr.query_crtcs(self.screens[0].root.wid):
                scr = PseudoScreen(self, i["x"], i["y"], i["width"], i["height"])
                self.pseudoscreens.append(scr)

        self.atoms = AtomCache(self)

        self.code_to_syms = {}
        self.first_sym_to_code = None
        self.refresh_keymap()

        self.modmap = None
        self.refresh_modmap()
コード例 #7
0
 def __init__(self, size=DEFAULT_SIZE, color=DEFAULT_COLOR):
     self.size = size
     self.color = color
     self.connection = xcffib.connect()
     setup = self.connection.get_setup()
     self.screen = setup.roots[self.connection.pref_screen]
     self.windows = BorderWindows._make(self.create_window()
                                        for _ in range(4))
コード例 #8
0
 def gather_basics(self):
     """Gets the connection and setup"""
     self.logger.info('Gathering X connection')
     connection = connect()
     self.logger.debug("Connection: %s", connection)
     setup = connection.get_setup()
     self.logger.debug("Setup: %s", setup)
     return [connection, setup]
コード例 #9
0
    def test_auth_connect(self):
        authname = six.b("MIT-MAGIC-COOKIE-1")
        authdata = six.b("\xa5\xcf\x95\xfa\x19\x49\x03\x60\xaf\xe4\x1e\xcd\xa3\xe2\xad\x47")

        authstr = authname + six.b(':') + authdata

        conn = xcffib.connect(display=os.environ['DISPLAY'], auth=authstr)

        assert conn.get_setup().roots[0].root > 0
コード例 #10
0
    def test_auth_connect(self):
        authname = six.b("MIT-MAGIC-COOKIE-1")
        authdata = six.b("\xa5\xcf\x95\xfa\x19\x49\x03\x60\xaf\xe4\x1e\xcd\xa3\xe2\xad\x47")

        authstr = authname + six.b(':') + authdata

        conn = xcffib.connect(display=os.environ['DISPLAY'], auth=authstr)

        assert conn.get_setup().roots[0].root > 0
コード例 #11
0
 def set_up_xcffib(self):
     self.connection = xcffib.connect()
     self.root = self.connection.get_setup().roots[0].root
     self.connection.core.ChangeWindowAttributesChecked(
         self.root,
         xcffib.xproto.CW.EventMask,
         [xcffib.xproto.EventMask.PropertyChange],
     ).check()
     print(int(self.connection.core.GetWindowAttributes(
         self.root).reply().your_event_mask))
コード例 #12
0
def is_withdrawn(window_id: int) -> bool:
    c = xcffib.connect()

    atom = c.core.InternAtom(True, len('WM_STATE'), 'WM_STATE').reply().atom
    property_reply = c.core.GetProperty(False, window_id, atom,
                                        xcffib.xproto.GetPropertyType.Any,
                                        0, 2 ** 32 - 1).reply()
    property_value = get_property_value(property_reply)
    c.disconnect()
    withdrawn = not property_value or property_value[0] == 0
    return withdrawn
コード例 #13
0
    def property_change(self, prop, prop_type, form, mode, data):
        # Gobject has no API to set properties (strangely), so we have to use xcb instead
        conn = xcb.connect()

        def get_atom(atom):
            ia = conn.core.InternAtom(False, len(atom), atom)
            return ia.reply().atom

        conn.core.ChangePropertyChecked(int(mode),
                                        self.get_window().get_xid(),
                                        get_atom(prop), get_atom(prop_type),
                                        form, int(len(data) / form * 8),
                                        data).check()
コード例 #14
0
ファイル: utils.py プロジェクト: Davidbrcz/qtile
    def _waitForXephyr(self):
        # Wait until Xephyr process dies
        while self.xephyr.poll() is None:
            try:
                conn = xcffib.connect(self.display)
                break
            except xcffib.ConnectionException:
                pass
            time.sleep(0.1)
        else:
            raise AssertionError("Error launching Xephyr, quit with return code: %d" % self.xephyr.returncode)

        conn.disconnect()
        del conn
コード例 #15
0
def get(DISPLAY=None, defaults=None):
    """
    Get the X resources in an X servers resource manager.

    Parameters
    ==========
    DISPLAY : str (optional)
        DISPLAY name to query. This will be taken from the environment if not specified.

    defaults : dict (optional)
        Default values to act as a fallback for missing values or in the event of a
        failed connection.

    Returns
    =======
    resources: dict
        Dictionary containing all (available) X resources. Resources that are specified
        in an Xresources/Xdefaults file as wildcards e.g. '*.color1' have the leading
        '*.' stripped.

    """
    if DISPLAY is None:
        DISPLAY = os.environ.get("DISPLAY")

    if defaults is None:
        resources = {}
    else:
        resources = defaults

    try:
        conn = xcffib.connect(display=DISPLAY)
    except xcffib.ConnectionException as e:
        logger.exception(e)
        return resources

    root = conn.get_setup().roots[0].root
    atom = conn.core.InternAtom(False, 16, 'RESOURCE_MANAGER').reply().atom

    reply = conn.core.GetProperty(False, root, atom, xcffib.xproto.Atom.STRING,
                                  0, (2**32) - 1).reply()
    conn.disconnect()

    resource_string = reply.value.buf().decode("utf-8")
    resource_list = filter(None, resource_string.split('\n'))

    for resource in resource_list:
        key, value = resource.split(':\t')
        resources[key.strip('*.')] = value

    return resources
コード例 #16
0
def xcb_conn(request):
    """
    Fixture that will setup and take down a xcffib.Connection object running on
    a display spawned by xvfb
    """
    display = os.environ.get('DISPLAY')
    if display:
        conn = xcffib.connect(display)

        def teardown_conn():
            conn.disconnect()
    else:
        pytest.skip('DISPLAY environment variable not set')

    request.addfinalizer(teardown_conn)
    return conn
コード例 #17
0
    def start_xephyr(self):
        """Start Xephyr instance

        Starts the Xephyr instance and sets the `self.display` to the display
        which is used to setup the instance.
        """
        # we'll try twice to open Xephyr
        for _ in range(2):
            # get a new display
            self.display = ":{}".format(_find_display())

            # build up arguments
            args = [
                "Xephyr", "-name", "qtile_test", self.display, "-ac",
                "-screen",
                "%sx%s" % (self.width, self.height)
            ]
            if self.two_screens:
                args.extend([
                    "-origin",
                    "%s,0" % self.xoffset, "-screen",
                    "%sx%s" % (SECOND_WIDTH, SECOND_HEIGHT)
                ])
            if self.xinerama:
                args.extend(["+xinerama"])
            if self.randr:
                args.extend(["+extension", "RANDR"])

            self.proc = subprocess.Popen(args)

            start = time.time()
            # wait for X display to come up
            while self.proc.poll() is None and time.time() < start + max_sleep:
                try:
                    conn = xcffib.connect(self.display)
                except xcffib.ConnectionException:
                    time.sleep(sleep_time)
                else:
                    conn.disconnect()
                    return
        else:
            # we wern't able to get a display up
            self.display = None
            raise AssertionError(
                "Unable to start Xephyr, quit with return code {:d}".format(
                    self.proc.returncode))
コード例 #18
0
ファイル: py3lock.py プロジェクト: jwu910/dotfiles
def xcb_fetch_windows():
    """ Returns an array of rects of currently visible windows. """

    x = xcffib.connect()
    root = x.get_setup().roots[0].root

    rects = []

    #iterate through top-level windows
    for child in x.core.QueryTree(root).reply().children:
        # make sure we only consider windows that are actually visible
        attributes = x.core.GetWindowAttributes(child).reply()
        if attributes.map_state != XCB_MAP_STATE_VIEWABLE:
            continue

        rects += [x.core.GetGeometry(child).reply()]

    return rects
コード例 #19
0
ファイル: xbacklight.py プロジェクト: ichigo-0/xbacklight.py
 def __init__(self, con=None, ext=None):
   """
       con: Optional existing xcb connection or display string.
       ext: RandR extension object associated with con.
   """
   if con is None or isinstance(con, str):
     self.con = con = xcffib.connect(display=con)
   if ext is None:
     self.ext = con(randr.key)
   # BackLight Atoms
   bla = [con.core.InternAtom(True, len(a), a.encode('latin-1')).reply().atom
       for a in ('Backlight', 'BACKLIGHT')]
   self.bla = [a for a in bla if a]
   if not bla:
     raise IOError("No outputs have backlight property")
   a = 'INTEGER'
   self.intatom = con.core.InternAtom(
       False, len(a), a.encode('latin-1')).reply().atom
コード例 #20
0
ファイル: lock.py プロジェクト: jbaiter/dotfiles
def xcb_fetch_windows():
  """ Returns an array of rects of currently visible windows. """

  x = xcb.connect()
  root = x.get_setup().roots[0].root

  rects = []

  # iterate through top-level windows
  for child in x.core.QueryTree(root).reply().children:
    # make sure we only consider windows that are actually visible
    attributes = x.core.GetWindowAttributes(child).reply()
    if attributes.map_state != XCB_MAP_STATE_VIEWABLE:
      continue

    rects += [x.core.GetGeometry(child).reply()]

  return rects
コード例 #21
0
ファイル: conftest.py プロジェクト: AlexTalker/qtile
    def start_xephyr(self):
        """Start Xephyr instance

        Starts the Xephyr instance and sets the `self.display` to the display
        which is used to setup the instance.
        """
        # we'll try twice to open Xephyr
        for _ in range(2):
            # get a new display
            self.display = ":{}".format(_find_display())

            # build up arguments
            args = [
                "Xephyr", "-name", "qtile_test",
                self.display, "-ac",
                "-screen", "%sx%s" % (self.width, self.height)]
            if self.two_screens:
                args.extend(["-origin", "%s,0" % self.xoffset, "-screen",
                             "%sx%s" % (SECOND_WIDTH, SECOND_HEIGHT)])
            if self.xinerama:
                args.extend(["+xinerama"])
            if self.randr:
                args.extend(["+extension", "RANDR"])

            self.proc = subprocess.Popen(args)

            start = time.time()
            # wait for X display to come up
            while self.proc.poll() is None and time.time() < start + max_sleep:
                try:
                    conn = xcffib.connect(self.display)
                except xcffib.ConnectionException:
                    time.sleep(sleep_time)
                else:
                    conn.disconnect()
                    return
        else:
            # we wern't able to get a display up
            self.display = None
            raise AssertionError("Unable to start Xephyr, quit with return code {:d}".format(
                self.proc.returncode
            ))
コード例 #22
0
ファイル: utils.py プロジェクト: s-hell/qtile
    def _waitForXephyr(self):
        # Wait until Xephyr process dies
        while self.xephyr.poll() is None:
            try:
                conn = xcffib.connect(self.display)
                break
            except xcffib.ConnectionException:
                pass
            time.sleep(0.1)
        else:
            (stdout_data, stderr_data) = self.xephyr.communicate()
            raise AssertionError("Error launching Xephyr, quit with return code: {:d}\n"
                                 "stderr: {}\n"
                                 "stdout: {}".format(
                                     self.xephyr.returncode,
                                     stderr_data.decode(),
                                     stdout_data.decode()
                                 )
            )

        conn.disconnect()
        del conn
コード例 #23
0
ファイル: wm.py プロジェクト: kopchik/swm
    def __init__(self, display=None, desktops=None, loop=None):
        self.log = Log("WM")
        # INIT SOME BASIC STUFF
        self.hook = Hook()
        self.windows = {}  # mapping between window id and Window
        self.win2desk = {}

        if not display:
            display = os.environ.get("DISPLAY")

        try:
            self._conn = xcffib.connect(display=display)
        except xcffib.ConnectionException:
            sys.exit("cannot connect to %s" % display)

        self.atoms = AtomVault(self._conn)
        self.desktops = desktops or [Desktop()]
        self.cur_desktop = self.desktops[0]
        self.cur_desktop.show()

        # CREATE ROOT WINDOW
        xcb_setup = self._conn.get_setup()
        xcb_screens = [i for i in xcb_setup.roots]
        self.xcb_default_screen = xcb_screens[self._conn.pref_screen]
        root_wid = self.xcb_default_screen.root
        self.root = Window(self, wid=root_wid, atoms=self.atoms, mapped=True)
        self.windows[root_wid] = self.root
#        for desktop in self.desktops:
#            desktop.windows.append(self.root)

        self.root.set_attr(
            eventmask=(
                  EventMask.StructureNotify
                | EventMask.SubstructureNotify
                | EventMask.FocusChange
                # | EventMask.SubstructureRedirect
                | EventMask.EnterWindow
                # | EventMask.LeaveWindow
                # | EventMask.PropertyChange
                | EventMask.OwnerGrabButton
            )
        )

        # INFORM X WHICH FEATURES WE SUPPORT
        self.root.props[self.atoms._NET_SUPPORTED] = [self.atoms[a] for a in SUPPORTED_ATOMS]

        # PRETEND TO BE A WINDOW MANAGER
        supporting_wm_check_window = self.create_window(-1, -1, 1, 1)
        supporting_wm_check_window.props['_NET_WM_NAME'] = "SWM"
        self.root.props['_NET_SUPPORTING_WM_CHECK'] = supporting_wm_check_window.wid
        self.root.props['_NET_NUMBER_OF_DESKTOPS'] = len(self.desktops)
        self.root.props['_NET_CURRENT_DESKTOP'] = 0

        # TODO: set cursor

        # EVENTS THAT HAVE LITTLE USE FOR US...
        self.ignoreEvents = {
            "KeyRelease",
            "ReparentNotify",
            # "CreateNotify",
            # DWM handles this to help "broken focusing windows".
            # "MapNotify",
            "ConfigureNotify",
            "LeaveNotify",
            "FocusOut",
            "FocusIn",
            "NoExposure",
        }
        # KEYBOARD
        self.kbd = Keyboard(xcb_setup, self._conn)
        self.mouse = Mouse(conn=self._conn, root=self.root)

        # FLUSH XCB BUFFER
        self.xsync()    # apply settings
        # the event loop is not yet there, but we might have some pending
        # events...
        self._xpoll()
        # TODO: self.grabMouse

        # NOW IT'S TIME TO GET PHYSICAL SCREEN CONFIGURATION
        self.xrandr = Xrandr(root=self.root, conn=self._conn)

        # TODO: self.update_net_desktops()

        # SETUP EVENT LOOP
        if not loop:
            loop = asyncio.new_event_loop()
        self._eventloop = loop
        self._eventloop.add_signal_handler(signal.SIGINT, self.stop)
        self._eventloop.add_signal_handler(signal.SIGTERM, self.stop)
        self._eventloop.add_signal_handler(signal.SIGCHLD, self.on_sigchld)
        self._eventloop.set_exception_handler(
            lambda loop, ctx: self.log.error(
                "Got an exception in {}: {}".format(loop, ctx))
        )
        fd = self._conn.get_file_descriptor()
        self._eventloop.add_reader(fd, self._xpoll)

        # HANDLE STANDARD EVENTS
        self.hook.register("MapRequest", self.on_map_request)
        self.hook.register("MapNotify", self.on_map_notify)
        self.hook.register("UnmapNotify", self.on_window_unmap)
        self.hook.register("KeyPress", self.on_key_press)
        # self.hook.register("KeyRelease", self.on_key_release)
        # self.hook.register("CreateNotify", self.on_window_create)
        self.hook.register("PropertyNotify", self.on_property_notify)
        self.hook.register("ClientMessage", self.on_client_message)
        self.hook.register("DestroyNotify", self.on_window_destroy)
        self.hook.register("EnterNotify", self.on_window_enter)
        self.hook.register("ConfigureRequest", self.on_configure_window)
        self.hook.register("MotionNotify", self.on_mouse_event)
        self.hook.register("ButtonPress", self.on_mouse_event)
        self.hook.register("ButtonRelease", self.on_mouse_event)
コード例 #24
0
ファイル: system_hotkey.py プロジェクト: byunei/system_hotkey
 def __init__(self, consumer='callback', check_queue_interval=0.01, use_xlib=False, conn=None, verbose=False):
     '''
     if the consumer param = 'callback', -> All hotkeys will require
     a callback function
     
     - Experimental! - 
     Otherwise set consumer to a function to hanlde the event.
     parameters sent will be - event, hotkey, callbacks
     event is the xwindow/microsoft keyboard eventm
     hotkey is a tuple,
     callback is any info that you registerd with the hotkey
     
     check_queue_interval is in seconds and sets the sleep time on
     checking the queue for hotkey presses
     
     set use_xlib to true to use the xlib python bindings (GPL) instead of the xcb ones (BSD) 
     You can pass an exisiting X display or connection using the conn keyword,
     otherwise one will be created for you.
     '''
     # Changes the class methods to point to differenct functions 
     # Depening on the operating system and library used
     # Consumer can be set to a function also, which will be sent the event
     # as well as the key and mask already broken out
     # Last option for consumer is False, then you have to listen to the queue yourself
     # data_queue
     self.verbose = verbose
     self.use_xlib = use_xlib
     self.consumer = consumer
     self.check_queue_interval = check_queue_interval
     def mark_event_type(event):
         # event gets an event_type attribute so the user has a portiabble way
         # actually on windows as far as i know you dont have the option of binding on keypress or release so... 
         # anyway ahve to check it but for now u dont! 
         if os.name == 'posix':
             if self.use_xlib:
                 if event.type == X.KeyPress:
                     event.event_type = 'keypress'
                 elif event.type == X.KeyRelease:
                     event.event_type = 'keyrelease'
             else:
                 if isinstance(event, xproto.KeyPressEvent):
                     event.event_type = 'keypress'
                 if isinstance(event, xproto.KeyReleaseEvent):
                     event.event_type = 'keyrelease'
         else:
             event.event_type = 'keypress'
         return event
         
     self.data_queue = queue.Queue()
     if os.name == 'nt':
         self.hk_action_queue = queue.Queue()
         self.modders = win_modders
         self._the_grab = self._nt_the_grab
         self.get_keycode = self._nt_get_keycode         
         self._get_keysym = self._nt_get_keysym
         
         thread.start_new_thread(self._nt_wait,(),)
         
     elif use_xlib:
         # Use the python-xlib library bindings, GPL License
         self.modders = xlib_modifiers
         self.trivial_mods = xlib_trivial_mods
         self._the_grab = self._xlib_the_grab
         self.get_keycode = self._xlib_get_keycode
         self._get_keysym = self._xlib_get_keysym
         if not conn:
             self.disp = Display()
         else:
             self.disp = conn
         self.xRoot = self.disp.screen().root
         self.xRoot.change_attributes(event_mask=X.KeyPressMask)
         
         thread.start_new_thread(self._xlib_wait,(),)
     
     else:
         # Using xcb and the xcffib python bindings Apache 2 http://stackoverflow.com/questions/40100/apache-license-vs-bsd-vs-mit
         self.modders = xcb_modifiers
         self.trivial_mods = xcb_trivial_mods
         self._the_grab = self._xcb_the_grab
         self.get_keycode = self._xcb_get_keycode
         self._get_keysym = self._xcb_get_keysym
         if not conn:
             self.conn = xcffib.connect()
         else:
             self.conn = conn
         self.root = self.conn.get_setup().roots[0].root
         
         thread.start_new_thread(self._xcb_wait,(),)
     
     if consumer == 'callback':
         if self.verbose:
             print('In Callback')
         def thread_me():
             while 1:
                 time.sleep(self.check_queue_interval)
                 try:
                     event = self.data_queue.get(block=False)
                 except queue.Empty:
                     pass    
                 else:
                     event = mark_event_type(event) 
                     hotkey = self.parse_event(event)
                     #~ for cb in self.get_callback(hotkey, event.event_type):   #when i was using the keypress / keyrelease shit
                     for cb in self.get_callback(hotkey):
                         if event.event_type == 'keypress':
                             if self.verbose:
                                 print('calling ', repr(cb))
                             cb(event)   # TBD either throw these up in a thread, or pass in a queue to be put onto
         thread.start_new_thread(thread_me,(),)
         
     elif callable(consumer):
         def thread_me():
             while 1:
                 time.sleep(self.check_queue_interval)
                 try:
                     event = self.data_queue.get(block=False)
                 except queue.Empty:
                     pass    
                 else:
                     hotkey = self.parse_event(mark_event_type(event))
                     if event.event_type == 'keypress':
                         args = [cb for cb in self.get_callback(hotkey)]
                         #~ callbacks = [cb for cb in self.get_callback(hotkey, event.event_type)]
                         consumer(event, hotkey, args)
         thread.start_new_thread(thread_me,(),)
     else:
         print('You need to handle grabbing events yourself!')
コード例 #25
0
ファイル: conftest.py プロジェクト: flacjacket/qtile
def can_connect_x11(disp=':0'):
    conn = xcffib.connect(display=disp)
    conn.disconnect()
    return True
コード例 #26
0
ファイル: atom_test.py プロジェクト: kopchik/swm
from atom import AtomVault
import xcffib
from xcffib import xproto

conn = xcffib.connect()


def test_get_atom():
    # lookup a standard atom
    atoms = AtomVault(conn)
    WM_NAME = atoms.WM_NAME
    assert WM_NAME.id == xproto.Atom.WM_NAME

    # sanity check
    _NET_WM_NAME = atoms._NET_WM_NAME
    _NET_WM_NAME.name == "_NET_WM_NAME"
    assert _NET_WM_NAME.type == ('UTF8_STRING', 8)
    assert _NET_WM_NAME.name in atoms._atoms

    # lookup by integer id
    assert atoms[_NET_WM_NAME.id] == _NET_WM_NAME
コード例 #27
0
ファイル: xcb.py プロジェクト: rbn42/kd_tree_tile
import os

import xcffib
from xcffib.testing import XvfbTest
from xcffib.xproto import Atom, ConfigWindow, EventMask, GetPropertyType

conn = xcffib.connect(os.environ['DISPLAY'])
xproto = xcffib.xproto.xprotoExtension(conn)


def arrange(layout, windowids):
    for lay, winid in zip(layout, windowids):
        xproto.ConfigureWindow(winid, ConfigWindow.X | ConfigWindow.Y | ConfigWindow.Width | ConfigWindow.Height, lay)
    conn.flush()


def move(winid, x, y, sync=True):
    xproto.ConfigureWindow(winid, ConfigWindow.X | ConfigWindow.Y, [x, y])
    if sync:
        conn.flush()
コード例 #28
0
    def test_the_script(self):
        NAME = "one"
        for i in range(20):
            try:
                conn = xcffib.connect(os.environ['DISPLAY'])
            except xcffib.ConnectionException:
                time.sleep(0.1)
                continue
            except Exception as v:
                print("Error opening test window: ", type(v), v, file=sys.stderr)
                sys.exit(1)
            break
        else:
            print("Could not open window on display %s" % (sys.argv[1]), file=sys.stderr)
            sys.exit(1)

        screen = conn.get_setup().roots[conn.pref_screen]

        window = conn.generate_id()
        background = conn.core.AllocColor(screen.default_colormap, 0x2828, 0x8383, 0xCECE).reply().pixel # Color "#2883ce"
        conn.core.CreateWindow(xcffib.CopyFromParent, window, screen.root,
                100, 100, 100, 100, 1,
                xcffib.xproto.WindowClass.InputOutput, screen.root_visual,
                xcffib.xproto.CW.BackPixel | xcffib.xproto.CW.EventMask,
                [background, xcffib.xproto.EventMask.StructureNotify | xcffib.xproto.EventMask.Exposure])

        conn.core.ChangeProperty(xcffib.xproto.PropMode.Replace,
                window, xcffib.xproto.Atom.WM_NAME,
                xcffib.xproto.Atom.STRING, 8, len(NAME),
                NAME)

        wm_protocols = "WM_PROTOCOLS"
        wm_protocols = conn.core.InternAtom(0, len(wm_protocols), wm_protocols).reply().atom

        wm_delete_window = "WM_DELETE_WINDOW"
        wm_delete_window = conn.core.InternAtom(0, len(wm_delete_window), wm_delete_window).reply().atom

        conn.core.ChangeProperty(xcffib.xproto.PropMode.Replace,
                window, wm_protocols,
                xcffib.xproto.Atom.ATOM, 32, 1,
                [wm_delete_window])

        conn.core.ConfigureWindow(window,
                xcffib.xproto.ConfigWindow.X | xcffib.xproto.ConfigWindow.Y |
                xcffib.xproto.ConfigWindow.Width | xcffib.xproto.ConfigWindow.Height |
                xcffib.xproto.ConfigWindow.BorderWidth,
                [0, 0, 100, 100, 1])
        conn.core.MapWindow(window)
        conn.flush()
        conn.core.ConfigureWindow(window,
                xcffib.xproto.ConfigWindow.X | xcffib.xproto.ConfigWindow.Y |
                xcffib.xproto.ConfigWindow.Width | xcffib.xproto.ConfigWindow.Height |
                xcffib.xproto.ConfigWindow.BorderWidth,
                [0, 0, 100, 100, 1])

        # now kill the window from the "wm" side via WM_DELETE_WINDOW protocol
        WM_PROTOCOLS = self.conn.core.InternAtom(False, len("WM_PROTOCOLS"), "WM_PROTOCOLS").reply().atom
        WM_DELETE_WINDOW = self.conn.core.InternAtom(False, len("WM_DELETE_WINDOW"), "WM_DELETE_WINDOW").reply().atom
        vals = [
            33,  # ClientMessageEvent
            32,  # Format
            0,
            window,
            WM_PROTOCOLS,
            WM_DELETE_WINDOW,
            xcffib.xproto.Time.CurrentTime,
            0,
            0,
            0,
        ]
        e = struct.pack('BBHII5I', *vals)
        self.conn.core.SendEvent(False, window, EventMask.NoEvent, e)

        self.conn.flush()

        while 1:
            conn.flush()
            event = conn.wait_for_event()
            if event.__class__ == xcffib.xproto.ClientMessageEvent:
                atom = conn.core.GetAtomName(event.type).reply().name.to_string()
                print(atom)
                if atom == "WM_PROTOCOLS":
                    break
コード例 #29
0
ファイル: window.py プロジェクト: 20after4/qtile
import time
import xcffib
import xcffib.xproto

def configure(window):
    window.configure(
        width=100,
        height=100,
        x=0,
        y=0,
        border_width=1,
    )

for i in range(20):
    try:
        conn = xcffib.connect(display=sys.argv[1])
    except xcffib.ConnectionException:
        time.sleep(0.1)
        continue
    except Exception as v:
        print("Error opening test window: ", type(v), v, file=sys.stderr)
        sys.exit(1)
    break
else:
    print("Could not open window on display %s" % (sys.argv[1]), file=sys.stderr)
    sys.exit(1)

screen = conn.get_setup().roots[conn.pref_screen]

window = conn.generate_id()
background = conn.core.AllocColor(screen.default_colormap, 0x2828, 0x8383, 0xCECE).reply().pixel # Color "#2883ce"
コード例 #30
0
 def test_wrap(self):
     c = xcffib.connect()
     c.invalid()
     c2 = xcffib.wrap(xcffib.ffi.cast("long", c._conn))
     c2.invalid()
     c2.disconnect()
コード例 #31
0
 def test_connect(self):
     c = xcffib.connect()
     c.invalid()
     assert c.has_error() == 0
     c.disconnect()