Exemple #1
0
    def focus_window(self, win: window.WindowType, surface: Surface = None):
        if self.seat.destroyed:
            return

        if surface is None and win is not None:
            surface = win.surface.surface

        previous_surface = self.seat.keyboard_state.focused_surface
        if previous_surface == surface:
            return

        if previous_surface is not None and previous_surface.is_xdg_surface:
            # Deactivate the previously focused surface
            previous_xdg_surface = XdgSurface.from_surface(previous_surface)
            previous_xdg_surface.set_activated(False)

        if not win:
            self.seat.keyboard_clear_focus()
            return

        if isinstance(win.surface, LayerSurfaceV1):
            if not win.surface.current.keyboard_interactive:
                return

        logger.debug("Focussing new window")
        if surface.is_xdg_surface and isinstance(win.surface, XdgSurface):
            win.surface.set_activated(True)
        self.seat.keyboard_notify_enter(surface, self.seat.keyboard)
Exemple #2
0
 def _on_foreign_request_activate(
     self, _listener, event: ftm.ForeignToplevelHandleV1ActivatedEvent
 ):
     logger.debug("Signal: foreign_toplevel_management request_activate")
     if self.group:
         self.qtile.current_screen.set_group(self.group)
         self.group.focus(self)
Exemple #3
0
    def get_vol(self) -> None:
        """Get the volume value"""

        try:
            output = subprocess.check_output(["amixer sget Master"],
                                             shell=True).decode("utf-8")
            vol = int(
                self.vol_value.search(output).groups()[0])  # type: ignore
            icon = next(
                iter({k: v
                      for k, v in volume_level_icons.items() if vol >= v}))

            if re.search("off", output):
                vol = 0
                icon = "\ufa80"

            if self.show_text:
                self.text = f"{icon} <span foreground='{colors['text']}'>{vol}%</span>"
            else:
                self.text = f"{icon}"

            self.bar.draw()

        except Exception as err:
            logger.debug(f"Failed to get amixer volume level: {err}")
Exemple #4
0
def guess_terminal():
    """Try to guess terminal."""
    test_terminals = [
        'roxterm',
        'sakura',
        'hyper',
        'alacritty',
        'terminator',
        'termite',
        'gnome-terminal',
        'konsole',
        'xfce4-terminal',
        'lxterminal',
        'mate-terminal',
        'kitty',
        'yakuake',
        'tilda',
        'guake',
        'eterm',
        'st',
        'urxvt',
        'xterm',
        'x-terminal-emulator',
    ]

    for terminal in test_terminals:
        logger.debug('Guessing terminal: {}'.format(terminal))
        if not which(terminal, os.X_OK):
            continue

        logger.info('Terminal found: {}'.format(terminal))
        return terminal

    logger.error('Default terminal has not been found.')
Exemple #5
0
 def _on_map(self, _listener, data):
     logger.debug("Signal: window map")
     self.mapped = True
     self.damage()
     if self.is_layer:
         self.output.organise_layers()
         self.core.focus_window(self, self.surface.surface)
Exemple #6
0
    def execute(self, call: CommandGraphCall, args: tuple,
                kwargs: dict) -> Any:
        """Execute the given call, returning the result of the execution

        Perform the given command graph call, calling the function with the
        given arguments and keyword arguments.

        Parameters
        ----------
        call: CommandGraphCall
            The call on the command graph that is to be performed.
        args:
            The arguments to pass into the command graph call.
        kwargs:
            The keyword arguments to pass into the command graph call.
        """
        obj = self._command_object.select(call.selectors)
        cmd = None
        try:
            cmd = obj.command(call.name)
        except SelectError:
            pass

        if cmd is None:
            return "No such command."

        logger.debug("Command: %s(%s, %s)", call.name, args, kwargs)
        return cmd(*args, **kwargs)
Exemple #7
0
    async def _server_callback(self, reader: asyncio.StreamReader,
                               writer: asyncio.StreamWriter) -> None:
        """Callback when a connection is made to the server

        Read the data sent from the client, execute the requested command, and
        send the reply back to the client.
        """
        logger.debug("Connection made to server")
        data = await reader.read()
        logger.debug("EOF received by server")

        try:
            req, is_json = _IPC.unpack(data)
        except IPCError:
            logger.warn("Invalid data received, closing connection")
            writer.close()
            if sys.version_info >= (3, 7):
                await writer.wait_closed()
            return

        if req[1] == "restart":
            logger.debug("Closing connection on restart")
            writer.write_eof()

        rep = self.handler(req)

        result = _IPC.pack(rep, is_json=is_json)

        logger.debug("Sending result on receive EOF")
        writer.write(result)
        logger.debug("Closing connection on receive EOF")
        writer.write_eof()
Exemple #8
0
 def _on_new_xdg_surface(self, _listener: Listener,
                         surface: XdgSurface) -> None:
     logger.debug("Signal: xdg_shell new_surface_event")
     if surface.role == XdgSurfaceRole.TOPLEVEL:
         assert self.qtile is not None
         win = window.XdgWindow(self, self.qtile, surface)
         self.pending_windows.add(win)
Exemple #9
0
 def _on_set_title(self, _listener, _data):
     logger.debug("Signal: xwindow set_title")
     title = self.surface.title
     if title != self.name:
         self.name = title
         self.ftm_handle.set_title(title)
         hook.fire("client_name_updated", self)
Exemple #10
0
    async def _server_callback(self, reader: asyncio.StreamReader,
                               writer: asyncio.StreamWriter) -> None:
        """Callback when a connection is made to the server

        Read the data sent from the client, execute the requested command, and
        send the reply back to the client.
        """
        try:
            logger.debug("Connection made to server")
            data = await reader.read()
            logger.debug("EOF received by server")

            req, is_json = _IPC.unpack(data)
        except IPCError:
            logger.warn("Invalid data received, closing connection")
        else:
            if req[1] == "restart":
                # if we are going to restart, close the connection first, as we won't be back
                logger.debug("Closing connection on restart")
                writer.write_eof()

            rep = self.handler(req)

            result = _IPC.pack(rep, is_json=is_json)

            logger.debug("Sending result on receive EOF")
            writer.write(result)
            logger.debug("Closing connection on receive EOF")
            writer.write_eof()
        finally:
            writer.close()
            await writer.wait_closed()
Exemple #11
0
    async def async_start(self) -> None:
        """Start the server"""
        assert self.server is None

        logger.debug("Starting server")
        self.server = await asyncio.start_unix_server(self._server_callback,
                                                      sock=self.sock)
Exemple #12
0
 def _on_cursor_motion(self, _listener, event: pointer.PointerEventMotion):
     assert self.qtile is not None
     logger.debug("Signal: cursor motion")
     self.cursor.move(event.delta_x,
                      event.delta_y,
                      input_device=event.device)
     self._process_cursor_motion(event.time_msec)
Exemple #13
0
 def remove_listener(self) -> None:
     """Remove the listener from the given event loop"""
     if self.fd is not None:
         logger.debug("Removing io watch")
         loop = asyncio.get_running_loop()
         loop.remove_reader(self.fd)
         self.fd = None
Exemple #14
0
    def _on_key(self, _listener, event: KeyboardKeyEvent):
        logger.debug("Signal: keyboard key")

        if self.qtile is None:
            # shushes mypy
            self.qtile = self.core.qtile
            assert self.qtile is not None

        if event.state == KEY_PRESSED:
            # translate libinput keycode -> xkbcommon
            keycode = event.keycode + 8
            layout_index = lib.xkb_state_key_get_layout(
                self.keyboard._ptr.xkb_state, keycode)
            nsyms = lib.xkb_keymap_key_get_syms_by_level(
                self.keyboard._ptr.keymap,
                keycode,
                layout_index,
                0,
                xkb_keysym,
            )
            keysyms = [xkb_keysym[0][i] for i in range(nsyms)]
            mods = self.keyboard.modifier
            for keysym in keysyms:
                if (keysym, mods) in self.grabbed_keys:
                    self.qtile.process_key_event(keysym, mods)
                    return

        self.seat.keyboard_notify_key(event)
Exemple #15
0
 def _on_destroy(self, _listener, _data):
     logger.debug("Signal: window destroy")
     if self.mapped:
         logger.warning("Window destroyed before unmap event.")
         self.mapped = False
     self.qtile.unmanage(self.wid)
     self.finalize()
Exemple #16
0
 def enable(self):
     logger.debug("Enabling pointer constraints.")
     self.core.active_pointer_constraint = self
     self._get_region()
     self.add_listener(self.wlr_constraint.surface.commit_event,
                       self._on_commit)
     self.wlr_constraint.send_activated()
Exemple #17
0
    def focus_window(
        self, win: window.WindowType, surface: Surface = None, enter: bool = True
    ) -> None:
        if self.seat.destroyed:
            return

        if surface is None and win is not None:
            if isinstance(win, base.Internal):
                self.focused_internal = win
                self.seat.keyboard_clear_focus()
                return
            surface = win.surface.surface

        if self.focused_internal:
            self.focused_internal = None

        if isinstance(win.surface, LayerSurfaceV1):
            if not win.surface.current.keyboard_interactive:
                return

        if isinstance(win.surface, xwayland.Surface):
            if not win.surface.or_surface_wants_focus():
                return

        previous_surface = self.seat.keyboard_state.focused_surface
        if previous_surface == surface:
            return

        if previous_surface is not None:
            # Deactivate the previously focused surface
            if previous_surface.is_xdg_surface:
                previous_xdg_surface = XdgSurface.from_surface(previous_surface)
                if not win or win.surface != previous_xdg_surface:
                    previous_xdg_surface.set_activated(False)
                    if previous_xdg_surface.data:
                        previous_xdg_surface.data.set_activated(False)

            elif previous_surface.is_xwayland_surface:
                prev_xwayland_surface = xwayland.Surface.from_wlr_surface(previous_surface)
                if not win or win.surface != prev_xwayland_surface:
                    prev_xwayland_surface.activate(False)
                    if prev_xwayland_surface.data:
                        prev_xwayland_surface.data.set_activated(False)

        if not win:
            self.seat.keyboard_clear_focus()
            return

        logger.debug("Focussing new window")
        if surface.is_xdg_surface and isinstance(win.surface, XdgSurface):
            win.surface.set_activated(True)
            win.ftm_handle.set_activated(True)

        elif surface.is_xwayland_surface and isinstance(win.surface, xwayland.Surface):
            win.surface.activate(True)
            win.ftm_handle.set_activated(True)

        if enter and self.seat.keyboard._ptr:  # This pointer is NULL when headless
            self.seat.keyboard_notify_enter(surface, self.seat.keyboard)
Exemple #18
0
    def start(self) -> None:
        """Start the server"""
        assert self.server is None

        logger.debug("Starting server")
        server_coroutine = asyncio.start_unix_server(self._server_callback,
                                                     sock=self.sock)
        self.server = self.loop.run_until_complete(server_coroutine)
Exemple #19
0
 def cmd_get_state(self):
     """Get pickled state for restarting qtile"""
     buf = io.BytesIO()
     self.dump_state(buf)
     state = buf.getvalue().decode(errors="backslashreplace")
     logger.debug('State = ')
     logger.debug(''.join(state.split('\n')))
     return state
Exemple #20
0
 def _on_output_power_manager_set_mode(
         self, _listener: Listener,
         mode: OutputPowerV1SetModeEvent) -> None:
     logger.debug("Signal: output_power_manager set_mode_event")
     wlr_output = mode.output
     wlr_output.enable(enable=True if mode.mode ==
                       OutputPowerManagementV1Mode.ON else False)
     wlr_output.commit()
Exemple #21
0
 def _load_file(self, path):
     try:
         with open(path, 'r') as f:
             return float(f.read().strip())
     except FileNotFoundError:
         logger.debug('Failed to get %s' % path)
         raise RuntimeError('Unable to read status for {}'.format(
             os.path.basename(path)))
Exemple #22
0
 def _on_unmap(self, _listener, data):
     logger.debug("Signal: window unmap")
     self.mapped = False
     if self.surface.surface == self.core.seat.keyboard_state.focused_surface:
         self.core.seat.keyboard_clear_focus()
     if self.is_layer:
         self.output.organise_layers()
     self.damage()
Exemple #23
0
    async def async_close(self) -> None:
        """Close and shutdown the server"""
        logger.debug("Stopping server on close")
        assert self.server is not None
        self.server.close()
        await self.server.wait_closed()

        self.server = None
Exemple #24
0
    def _on_new_layer_surface(self, _listener, layer_surface: layer_shell_v1.LayerSurfaceV1):
        logger.debug("Signal: layer_shell new_surface_event")
        assert self.qtile is not None

        wid = max(self.qtile.windows_map.keys(), default=0) + 1
        win = window.Static(self, self.qtile, layer_surface, wid)
        logger.info(f"Managing new layer_shell window with window ID: {wid}")
        self.qtile.manage(win)
Exemple #25
0
    def _on_new_layer_surface(self, _listener, layer_surface: LayerSurfaceV1):
        logger.debug("Signal: layer_shell new_surface_event")
        assert self.qtile is not None

        wid = self.new_wid()
        win = window.Static(self, self.qtile, layer_surface, wid)
        logger.info(f"Managing new layer_shell window with window ID: {wid}")
        self.qtile.manage(win)
Exemple #26
0
 def _on_unmap(self, _listener, _data):
     logger.debug("Signal: window unmap")
     self.mapped = False
     self.damage()
     seat = self.core.seat
     if not seat.destroyed:
         if self.surface.surface == seat.keyboard_state.focused_surface:
             seat.keyboard_clear_focus()
Exemple #27
0
    def start(self) -> None:
        """Start the server"""
        assert self.server is None
        server_coroutine = self.loop.create_unix_server(
            lambda: _ServerProtocol(self.handler), sock=self.sock)

        logger.debug('Starting server')
        self.server = self.loop.run_until_complete(server_coroutine)
Exemple #28
0
    def _on_request_start_drag(self, _listener,
                               event: seat.RequestStartDragEvent):
        logger.debug("Signal: seat request_start_drag")

        if not self.live_dnd and self.seat.validate_pointer_grab_serial(
                event.origin, event.serial):
            self.seat.start_pointer_drag(event.drag, event.serial)
        else:
            event.drag.source.destroy()
Exemple #29
0
def _get_keysyms(xkb_state, keycode):
    syms_out = ffi.new("const xkb_keysym_t **")
    nsyms = lib.xkb_state_key_get_syms(xkb_state, keycode, syms_out)
    if nsyms > 0:
        assert syms_out[0] != ffi.NULL

    syms = [syms_out[0][i] for i in range(nsyms)]
    logger.debug(f"Got {nsyms} syms: {syms}")
    return syms
Exemple #30
0
def setup_monitors(action=None, device=None):
    if action == "change":
        logger.debug("qtile: display change detected...")
        return
        # setup monitors with xrandr
        import subprocess
        subprocess.call(home + "/bin/swt")
        # no need to lazy.restart() here, we just reconfigure X
        startup()
Exemple #31
0
def change_transparency(window):
    """change window transparency based on his name/type."""
    kls = window.window.get_wm_class()[1].lower()
    logger.debug("Change transparency for window: %s", kls)
    if 'urxvt' in kls:
        window.cmd_opacity(.7)
    elif 'firefox' in kls or 'chromium' in kls:
        window.cmd_opacity(.9)
    else:
        if window.floating and 'urxvt' not in kls:
            # all floating are almost transparent by default (for popups windows)
            window.cmd_opacity(.95)
        else:
            window.cmd_opacity(.8)
Exemple #32
0
def client_focus(window):
    """Change transparency on focus."""
    global last_focus

    if last_focus is not None and last_focus != window:
        try:
            change_transparency(last_focus)
        except Exception:
            pass  # ignore if error

    if last_focus != window:
        last_focus = window
        kls = window.window.get_wm_class()[1].lower()
        logger.debug("Change transparency for current window: %s", kls)
        window.cmd_opacity(1)  # current focused window: no transp
Exemple #33
0
def safe_import(module_name, class_name):
    """
    try to import a module, and if it fails because an ImporError
    it logs on WARNING, and logs the traceback on DEBUG level
    """
    if type(class_name) is list:
        for name in class_name:
            safe_import(module_name, name)
        return
    package = __package__
    # python 3.2 don't set __package__
    if not package:
        package = __name__
    try:
        module = importlib.import_module(module_name, package)
        globals()[class_name] = getattr(module, class_name)
    except ImportError as error:
        logger.warning("Can't Import Widget: '%s.%s', %s", module_name, class_name, error)
        logger.debug("%s", traceback.format_exc())