==> menu_mods/gnome.py <==
""" Change gtk / icons themes and another gnome settings
"""
import os
import configparser
import subprocess
import glob
import path

from misc import Misc


class gnome():
    """
        Change gtk / icons themes and another gnome settings using
        gsd-xsettings.
    """

    def __init__(self, menu):
        self.menu = menu
        self.gtk_config = configparser.ConfigParser()
        self.gnome_settings_script = os.path.expanduser(
            '~/bin/scripts/gnome_settings'
        )

    def menu_params(self, length, prompt):
        """ Set menu params """
        return {
            'cnum': length / 2,
            'lnum': 2,
            'width': int(self.menu.screen_width * 0.55),
            'prompt':
                f'{self.menu.wrap_str(prompt)} {self.menu.conf("prompt")}'
        }

    def apply_settings(self, selection, *cmd_opts):
        """ Apply selected gnome settings """
        ret = ""
        if selection is not None:
            ret = selection.decode('UTF-8').strip()

            if ret is not None and ret != '':
                try:
                    subprocess.call([
                        self.gnome_settings_script, *cmd_opts, ret
                    ], check=True)
                except subprocess.CalledProcessError as proc_err:
                    Misc.print_run_exception_info(proc_err)

    def change_icon_theme(self):
        """ Changes icon theme with help of gsd-xsettings """
        icon_dirs = []
        icons_path = path.Path('~/.icons').expanduser()
        for icon in glob.glob(icons_path + '/*'):
            if icon:
                icon_dirs += [path.Path(icon).name]

        menu_params = self.menu_params(len(icon_dirs), 'icon theme')

        try:
            selection = subprocess.run(
                self.menu.args(menu_params),
                stdout=subprocess.PIPE,
                input=bytes('\n'.join(icon_dirs), 'UTF-8'),
                check=True
            ).stdout
        except subprocess.CalledProcessError as proc_err:
            Misc.print_run_exception_info(proc_err)

        self.apply_settings(selection, '-i')

    def change_gtk_theme(self):
        """ Changes gtk theme with help of gsd-xsettings """
        theme_dirs = []
        gtk_theme_path = path.Path('~/.themes').expanduser()
        for theme in glob.glob(gtk_theme_path + '/*/*/gtk.css'):
            if theme:
                theme_dirs += [path.Path(theme).dirname().dirname().name]

        menu_params = self.menu_params(len(theme_dirs), 'gtk theme')
        try:
            selection = subprocess.run(
                self.menu.args(menu_params),
                stdout=subprocess.PIPE,
                input=bytes('\n'.join(theme_dirs), 'UTF-8'),
                check=True
            ).stdout
        except subprocess.CalledProcessError as proc_err:
            Misc.print_run_exception_info(proc_err)

        self.apply_settings(selection, '-a')


==> menu_mods/i3menu.py <==
import sys
import json
import re
import subprocess

from typing import List


class i3menu():
    def __init__(self, menu):
        self.menu = menu

    def i3_cmds(self) -> List[str]:
        """ Return the list of i3 commands with magic_pie hack autocompletion.
        """
        try:
            out = subprocess.run(
                [self.menu.i3cmd, 'magic_pie'],
                stdout=subprocess.PIPE,
                stderr=subprocess.DEVNULL,
                check=False
            ).stdout
        except Exception:
            return []

        lst = [
            t.replace("'", '')
            for t in re.split('\\s*,\\s*', json.loads(
                out.decode('UTF-8')
            )[0]['error'])[2:]
        ]

        lst.remove('nop')
        lst.extend(['splitv', 'splith'])
        lst.sort()

        return lst

    def i3_cmd_args(self, cmd: str) -> List[str]:
        try:
            out = subprocess.run(
                [self.menu.i3cmd, cmd],
                stdout=subprocess.PIPE,
                stderr=subprocess.DEVNULL,
                check=False
            ).stdout
            if out is not None:
                ret = [
                    t.replace("'", '') for t in
                    re.split('\\s*, \\s*', json.loads(
                        out.decode('UTF-8')
                    )[0]['error'])[1:]
                ]
            return ret
        except Exception:
            return [""]

    def cmd_menu(self) -> int:
        """ Menu for i3 commands with hackish autocompletion.
        """
        # set default menu args for supported menus
        cmd = ''

        try:
            menu = subprocess.run(
                self.menu.args({}),
                stdout=subprocess.PIPE,
                input=bytes('\n'.join(self.i3_cmds()), 'UTF-8'),
                check=True
            ).stdout
            if menu is not None and menu:
                cmd = menu.decode('UTF-8').strip()
        except subprocess.CalledProcessError as call_e:
            sys.exit(call_e.returncode)

        if not cmd:
            # nothing to do
            return 0

        debug, ok, notify_msg = False, False, ""
        args, prev_args = None, None
        menu_params = {
            'prompt': f"{self.menu.wrap_str('i3cmd')} \
                {self.menu.conf('prompt')} " + cmd,
        }
        while not (ok or args == ['<end>'] or args == []):
            if debug:
                print(f"evaluated cmd=[{cmd}] args=[{self.i3_cmd_args(cmd)}]")
            out = subprocess.run(
                (f"{self.menu.i3cmd} " + cmd).split(),
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                check=False
            ).stdout
            if out is not None and out:
                ret = json.loads(out.decode('UTF-8').strip())[0]
                result, err = ret.get('success', ''), ret.get('error', '')
                ok = True
                if not result:
                    ok = False
                    notify_msg = ['notify-send', 'i3-cmd error', err]
                    try:
                        args = self.i3_cmd_args(cmd)
                        if args == prev_args:
                            return 0
                        cmd_rerun = subprocess.run(
                            self.menu.args(menu_params),
                            stdout=subprocess.PIPE,
                            input=bytes('\n'.join(args), 'UTF-8'),
                            check=False
                        ).stdout
                        cmd += ' ' + cmd_rerun.decode('UTF-8').strip()
                        prev_args = args
                    except subprocess.CalledProcessError as call_e:
                        return call_e.returncode

        if not ok:
            subprocess.run(notify_msg, check=False)


==> menu_mods/props.py <==
import subprocess
import re
import socket
from typing import List


class props():
    def __init__(self, menu):
        self.menu = menu

        # Magic delimiter used by add_prop / del_prop routines.
        self.delim = "@"

        # default echo server host
        self.host = self.menu.conf("host")

        # default echo server port
        self.port = int(self.menu.conf("port"))

        # create echo server socket
        self.sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)

        # negi3mods which allows add / delete property.
        # For example this feature can be used to move / delete window
        # to / from named scratchpad.
        self.possible_mods = ['ns', 'circle']

        # Window properties used by i3 to match windows.
        self.i3rules_xprop = set(self.menu.conf("rules_xprop"))

    def tag_name(self, mod: str, lst: List[str]) -> str:
        """ Returns tag name, selected by menu.

        Args:
            mod (str): module name string.
            lst (List[str]): list of menu input.
        """
        menu_params = {
            'cnum': len(lst),
            'width': int(self.menu.screen_width * 0.75),
            'prompt': f'{self.menu.wrap_str(mod)} {self.menu.conf("prompt")}',
        }
        menu_tag = subprocess.run(
            self.menu.args(menu_params),
            stdout=subprocess.PIPE,
            input=bytes('\n'.join(lst), 'UTF-8'),
            check=False
        ).stdout

        if menu_tag is not None and menu_tag:
            return menu_tag.decode('UTF-8').strip()

        return ""

    def autoprop(self) -> None:
        """ Start autoprop menu to move current module to smth.
        """
        mod = self.get_mod()
        if mod is None or not mod:
            return

        aprop_str = self.get_autoprop_as_str(with_title=False)

        lst = self.mod_data_list(mod)
        tag_name = self.tag_name(mod, lst)

        if tag_name is not None and tag_name:
            for mod in self.possible_mods:
                cmdl = [
                    f'{self.menu.i3_path}send',
                    f'{mod}', 'add_prop',
                    f'{tag_name}', f'{aprop_str}'
                ]
                subprocess.run(cmdl, check=False)
        else:
            print(f'No tag name specified for props [{aprop_str}]')

    def get_mod(self) -> str:
        """ Select negi3mod for add_prop by menu.
        """
        menu_params = {
            'cnum': len(self.possible_mods),
            'lnum': 1,
            'width': int(self.menu.screen_width * 0.75),
            'prompt': f'{self.menu.wrap_str("selmod")} \
            {self.menu.conf("prompt")}'
        }
        mod = subprocess.run(
            self.menu.args(menu_params),
            stdout=subprocess.PIPE,
            input=bytes('\n'.join(self.possible_mods), 'UTF-8'),
            check=False
        ).stdout

        if mod is not None and mod:
            return mod.decode('UTF-8').strip()

        return ""

    def show_props(self) -> None:
        """ Send notify-osd message about current properties.
        """
        aprop_str = self.get_autoprop_as_str(with_title=False)
        notify_msg = ['notify-send', 'X11 prop', aprop_str]
        subprocess.run(notify_msg, check=False)

    def get_autoprop_as_str(self, with_title: bool = False,
                            with_role: bool = False) -> str:
        """ Convert xprops list to i3 commands format.

        Args:
            with_title (bool): add WM_NAME attribute, to the list, optional.
            with_role (bool): add WM_WINDOW_ROLE attribute to the list,
            optional.
        """
        xprops = []
        win = self.menu.i3ipc.get_tree().find_focused()
        xprop = subprocess.run(
            ['xprop', '-id', str(win.window)] + self.menu.xprops_list,
            stdout=subprocess.PIPE,
            check=False
        ).stdout
        if xprop is not None:
            xprop = xprop.decode('UTF-8').split('\n')
        ret = []
        for attr in self.i3rules_xprop:
            for xattr in xprop:
                xprops.append(xattr)
                if attr in xattr and 'not found' not in xattr:
                    founded_attr = re.search("[A-Z]+(.*) = ", xattr).group(0)
                    xattr = re.sub("[A-Z]+(.*) = ", '', xattr).split(', ')
                    if "WM_CLASS" in founded_attr:
                        if xattr[0] is not None and xattr[0]:
                            ret.append(f'instance={xattr[0]}{self.delim}')
                        if xattr[1] is not None and xattr[1]:
                            ret.append(f'class={xattr[1]}{self.delim}')
                    if with_role and "WM_WINDOW_ROLE" in founded_attr:
                        ret.append(f'window_role={xattr[0]}{self.delim}')
                    if with_title and "WM_NAME" in founded_attr:
                        ret.append(f'title={xattr[0]}{self.delim}')
        return "[" + ''.join(sorted(ret)) + "]"

    def mod_data_list(self, mod: str) -> List[str]:
        """ Extract list of module tags. Used by add_prop menus.

        Args:
            mod (str): negi3mod name.
        """
        self.sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
        self.sock.connect((self.host, self.port))
        self.sock.send(bytes(f'{mod}_list\n', 'UTF-8'))

        out = self.sock.recv(1024)

        self.sock.shutdown(1)
        self.sock.close()

        lst = []
        if out is not None:
            lst = out.decode('UTF-8').strip()[1:-1].split(', ')
            lst = [t.replace("'", '') for t in lst]

        return lst


==> menu_mods/pulse_menu.py <==
import subprocess
import pulsectl


class pulse_menu():
    def __init__(self, menu):
        self.menu = menu
        self.pulse = pulsectl.Pulse('neg-pulse-selector')
        self.pulse_data = {}

    def pulseaudio_output(self):
        self.pulse_data = {
            "app_list": [],
            "sink_output_list": [],
            "app_props": {},
            "pulse_sink_list": self.pulse.sink_list(),
            "pulse_app_list": self.pulse.sink_input_list(),
        }

        for app in self.pulse_data["pulse_app_list"]:
            app_name = app.proplist["media.name"] + ' -- ' + \
                app.proplist["application.name"]
            self.pulse_data["app_list"] += [app_name]
            self.pulse_data["app_props"][app_name] = app

        if self.pulse_data["app_list"]:
            app_ret = self.pulseaudio_select_app()
            if self.pulse_data["sink_output_list"]:
                self.pulseaudio_select_output(app_ret)

    def pulseaudio_input(self):
        pass

    def pulseaudio_select_app(self):
        menu_params = {
            'cnum': 1,
            'lnum': len(self.pulse_data["app_list"]),
            'auto_selection': '-auto-select',
            'width': int(self.menu.screen_width * 0.55),
            'prompt': f'{self.menu.wrap_str("pulse app")} \
            {self.menu.conf("prompt")}',
        }
        menu_app_sel = subprocess.run(
            self.menu.args(menu_params),
            stdout=subprocess.PIPE,
            input=bytes('\n'.join(self.pulse_data["app_list"]), 'UTF-8'),
            check=False
        ).stdout

        if menu_app_sel is not None:
            app_ret = menu_app_sel.decode('UTF-8').strip()

        exclude_device_name = ""
        sel_app_props = \
            self.pulse_data["app_props"][app_ret].proplist
        for stream in self.pulse.stream_restore_list():
            if stream is not None:
                if stream.device is not None:
                    if stream.name == sel_app_props['module-stream-restore.id']:
                        exclude_device_name = stream.device

        for _, sink in enumerate(self.pulse_data["pulse_sink_list"]):
            if sink.proplist.get('udev.id', ''):
                if sink.proplist['udev.id'].split('.')[0] == \
                        exclude_device_name.split('.')[1]:
                    continue
            if sink.proplist.get('device.profile.name', ''):
                if sink.proplist['device.profile.name'] == \
                        exclude_device_name.split('.')[-1]:
                    continue
            self.pulse_data["sink_output_list"] += \
                [str(sink.index) + ' -- ' + sink.description]

        return app_ret

    def pulseaudio_select_output(self, app_ret) -> None:
        """ Create params for pulseaudio selector """
        menu_params = {
            'cnum': 1,
            'lnum': len(self.pulse_data["sink_output_list"]),
            'auto_selection': '-auto-select',
            'width': int(self.menu.screen_width * 0.55),
            'prompt':
                f'{self.menu.wrap_str("pulse output")} \
                {self.menu.conf("prompt")}'
        }
        menu_output_sel = subprocess.run(
            self.menu.args(menu_params),
            stdout=subprocess.PIPE,
            input=bytes(
                '\n'.join(self.pulse_data["sink_output_list"]),
                'UTF-8'
            ),
            check=False
        ).stdout

        if menu_output_sel is not None:
            out_ret = menu_output_sel.decode('UTF-8').strip()

        target_idx = out_ret.split('--')[0].strip()
        if int(self.pulse_data["app_props"][app_ret].index) is not None \
                and int(target_idx) is not None:
            self.pulse.sink_input_move(
                int(self.pulse_data["app_props"][app_ret].index),
                int(target_idx),
            )


==> menu_mods/winact.py <==
import subprocess
from functools import partial
from typing import Callable


class winact():
    def __init__(self, menu):
        self.menu = menu
        self.workspaces = menu.conf("workspaces")

    def win_act_simple(self, cmd: str, prompt: str) -> None:
        """ Run simple and fast selection dialog for window with given action.
            Args:
                cmd (str): action for window to run.
                prompt (str): custom prompt for menu.
        """
        leaves = self.menu.i3ipc.get_tree().leaves()
        winlist = [win.name for win in leaves]
        winlist_len = len(winlist)
        menu_params = {
            'cnum': winlist_len,
            'width': int(self.menu.screen_width * 0.75),
            'prompt': f"{prompt} {self.menu.conf('prompt')}"
        }
        if winlist and winlist_len > 1:
            win_name = subprocess.run(
                self.menu.args(menu_params),
                stdout=subprocess.PIPE,
                input=bytes('\n'.join(winlist), 'UTF-8'),
                check=False
            ).stdout
        elif winlist_len:
            win_name = winlist[0].encode()

        if win_name is not None and win_name:
            win_name = win_name.decode('UTF-8').strip()
            for win in leaves:
                if win.name == win_name:
                    win.command(cmd)

    def goto_win(self) -> None:
        """ Run menu goto selection dialog
        """
        self.win_act_simple('focus', self.menu.wrap_str('go'))

    def attach_win(self) -> None:
        """ Attach window to the current workspace.
        """
        self.win_act_simple(
            'move window to workspace current', self.menu.wrap_str('attach')
        )

    def select_ws(self, use_wslist: bool) -> str:
        """ Apply target function to workspace.
        """
        if use_wslist:
            wslist = self.workspaces
        else:
            wslist = [ws.name for ws in self.menu.i3ipc.get_workspaces()] + \
                ["[empty]"]
        menu_params = {
            'cnum': len(wslist),
            'width': int(self.menu.screen_width * 0.66),
            'prompt': f'{self.menu.wrap_str("ws")} {self.menu.conf("prompt")}',
        }
        workspace_name = subprocess.run(
            self.menu.args(menu_params),
            stdout=subprocess.PIPE,
            input=bytes('\n'.join(wslist), 'UTF-8'),
            check=False
        ).stdout

        selected_ws = workspace_name.decode('UTF-8').strip()
        return str(wslist.index(selected_ws) + 1) + ' :: ' + selected_ws

    @staticmethod
    def apply_to_ws(ws_func: Callable) -> None:
        """ Partial apply function to workspace.
        """
        ws_func()

    def goto_ws(self, use_wslist: bool = True) -> None:
        """ Go to workspace menu.
        """
        workspace_name = self.select_ws(use_wslist)
        if workspace_name is not None and workspace_name:
            self.apply_to_ws(
                partial(self.menu.i3ipc.command, f'workspace {workspace_name}')
            )

    def move_to_ws(self, use_wslist: bool = True) -> None:
        """ Move current window to the selected workspace
        """
        workspace_name = self.select_ws(use_wslist)
        if workspace_name is not None and workspace_name:
            self.apply_to_ws(
                partial(self.menu.i3ipc.command,
                        f'[con_id=__focused__] \
                        move to workspace {workspace_name}')
            )


==> menu_mods/xprop.py <==
import subprocess
from misc import Misc


class xprop():
    """ Setup screen resolution """
    def __init__(self, menu):
        self.menu = menu

    def xprop(self) -> None:
        """ Menu to show X11 atom attributes for current window.
        """
        xprops = []
        target_win = self.menu.i3ipc.get_tree().find_focused()
        try:
            xprop_ret = subprocess.run(
                ['xprop', '-id', str(target_win.window)] +
                self.menu.xprops_list,
                stdout=subprocess.PIPE,
                check=True
            ).stdout
            if xprop_ret is not None:
                xprop_ret = xprop_ret.decode().split('\n')
                for line in xprop_ret:
                    if 'not found' not in line:
                        xprops.append(line)
        except subprocess.CalledProcessError as proc_err:
            Misc.print_run_exception_info(proc_err)

        menu_params = {
            'cnum': 1,
            'lnum': len(xprops),
            'width': int(self.menu.screen_width * 0.75),
            'prompt':
                f'{self.menu.wrap_str("xprop")} {self.menu.conf("prompt")}'
        }

        ret = ""

        try:
            xprop_sel = subprocess.run(
                self.menu.args(menu_params),
                stdout=subprocess.PIPE,
                input=bytes('\n'.join(xprops), 'UTF-8'),
                check=True
            ).stdout

            if xprop_sel is not None:
                ret = xprop_sel.decode('UTF-8').strip()
        except subprocess.CalledProcessError as proc_err:
            Misc.print_run_exception_info(proc_err)

        # Copy to the clipboard
        if ret is not None and ret != '':
            try:
                subprocess.run(
                    ['xsel', '-i'],
                    input=bytes(ret.strip(), 'UTF-8'),
                    check=True
                )
            except subprocess.CalledProcessError as proc_err:
                Misc.print_run_exception_info(proc_err)

==> menu_mods/xrandr.py <==
import subprocess


class xrandr():
    def __init__(self, menu):
        self.menu = menu

    def change_resolution_xrandr(self):
        from display import Display
        xrandr_data = Display.xrandr_resolution_list()
        menu_params = {
            'cnum': 8,
            'width': int(Display.get_screen_resolution()["width"] * 0.55),
            'prompt': f'{self.menu.wrap_str("gtk_theme")} \
            {self.menu.conf("prompt")}',
        }
        resolution_sel = subprocess.run(
            self.menu.args(menu_params),
            stdout=subprocess.PIPE,
            input=bytes('\n'.join(xrandr_data), 'UTF-8'),
            check=False
        ).stdout

        if resolution_sel is not None:
            ret = resolution_sel.decode('UTF-8').strip()

        ret_list = []
        if ret and 'x' in ret:
            size_pair = ret.split(':')
            size_id = size_pair[0]
            res_str = size_pair[1:][0].strip()
            ret_list = res_str.split('x')

        width, height = ret_list[0].strip(), ret_list[1].strip()

        print(f'Set size to {width}x{height}')
        Display.set_screen_size(size_id)

==> bscratch.cfg <==
[im]
class = [ "ViberPC", "VK", "zoom", "IGdm"]
class_r = [ "[Tt]elegram.*", "[Ss]kype.*",]
geom = "548x1165+1368+3"

[ncmpcpp]
instance = [ "ncmpcpp", "Tauon Music Box"]
geom = "1381x673+276+326"
spawn = "ncmpcpp"

[ncmpcpp_fun]
class = [ "cool-retro-term",]
geom = "1389x696+276+326"
prog = "cool-retro-term --program ncmpcpp"

[mutt]
class = ["mutterfox"]
instance = [ "mutt", "mutterfox"]
geom = "1835x1114+52+0"
spawn = "mutt"

[ranger]
instance = [ "ranger",]
geom = "1916x816+3+1"
spawn = "ranger"

[teardrop]
instance = [ "teardrop",]
geom = "1844x704+39+4"
spawn = "teardrop"

[volcontrol]
class = [ "Pavucontrol",]
geom = "895x314+1023+824"
prog = "pavucontrol"

[youtube]
instance = [ "youtube-get",]
geom = "1339x866+247+13"
spawn = "youtube-get"

[webcam]
instance = [ "webcam",]
geom = "1234x771+667+363"
prog = "~/bin/webcam"

[im.tel]
prog = "proxychains telegram-desktop"
class = [ "TelegramDesktop", "Telegram-desktop", "telegram-desktop",]

[im.skype]
prog = "skypeforlinux"
class = [ "skype", "Skype",]

[discord]
prog = "discord"
class = ['discord',]
geom = "944x1036+974+127"

[transients]
match_all = [ "True" ]
geom = "1844x704+39+4"

==> circle.cfg <==
[web]
class = [ "firefox", "Waterfox", "Tor Browser", "Chromium"]
priority = "firefox"
prog = "firefox"

[web.firefox]
class = [ "Firefox", "Nightly", "Navigator"]
prog = "firefox"

[web.tor]
class = [ "Tor Browser",]
prog = "tor-browser rutracker.org"

[web.yandex]
class = [ "Yandex-browser-beta",]
prog = "yandex-browser-beta"

[vid]
class = [ "mpv", "mplayer", "mplayer2", "Vlc",]
prog = "~/bin/pl rofi 1st_level ~/vid/new"

[lutris]
class = [ "Wine", "Lutris",]
prog = "lutris"

[steam]
class = [ "Steam" ]
prog = "steam"

[doc]
class = [ "Zathura", "cr3", ]

[vm]
class = [ "vmware", "spicy",]
class_r = [ "^[Qq]emu-.*$", ]

[term]
class = [ "term",]
instance = [ "term",]
spawn = "term"

[nwim]
class = [ "nwim"]
instance = [ "nwim"]
spawn = "nwim"

[obs]
class = [ "obs", ]
prog = "obs"

[remote]
class = [ "xfreerdp", "reminna", "org.remmina.Remmina", ]

[sxiv]
class = [ "Sxiv",]
prog = "dash -c 'exec find ~/dw/ ~/tmp/shots/ -maxdepth 1 -type d -print0 |xargs -0 ~/bin/sx'"

[sxiv.wallpaper]
class = [ "Sxiv",]
prog = "~/bin/wl --show"

[looking_glass]
class = [ "looking-glass-client",]
prog = "pgrep qemu && looking-glass-client -F -o opengl:vsync=0 -k"

[bitwig]
class = [ "Bitwig Studio",]
prog = "bitwig-studio"

==> executor.cfg <==
[term]
class="term"
font="Iosevka"
font_size=18
colorscheme='dark3'

[ranger]
class="ranger"
font="Iosevka"
font_size=18
postfix='-n ranger ranger\; set status off'
colorscheme='dark3'

[teardrop]
class="teardrop"
font="Iosevka Term"
font_size=18
postfix='-n mixer ncpamixer \; neww -n atop atop \; neww -n stig stig \; neww -n tasksh tasksh \; select-window -t 2'
colorscheme='dark3'

[ncmpcpp]
class="ncmpcpp"
font="Iosevka"
font_size=18
run_tmux=0
prog='ncmpcpp'
x_padding=4
y_padding=4
colorscheme='dark3'

[mutt]
class="mutt"
font="Iosevka"
font_size=18
run_tmux=0
prog_detach='neomutt'
colorscheme='dark3'

[nwim]
class="nwim"
font="Iosevka"
font_size=15.5
font_style_normal="Medium"
run_tmux=0
prog='NVIM_LISTEN_ADDRESS=/tmp/nvimsocket nvim'
colorscheme='dark3'

[youtube-get]
class="youtube-get"
font="Iosevka"
font_size=15.5
font_style_normal="Medium"
run_tmux=0
prog='/home/neg/bin/scripts/yr'
colorscheme='dark3'

==> fs.cfg <==
panel_classes = ["polybar"]
ws_fullscreen = ["gfx", "pic", "steam"]
classes_to_hide_panel = ["mpv", "Sxiv", "Steam", "vaapi", "vdpau", "gl"]

==> menu.cfg <==
modules = ['i3menu', 'winact', 'pulse_menu', 'xprop', 'props', 'gnome', 'xrandr',]

i3cmd = "i3-msg"
host = "::"
port = 31888

workspaces = [" α:term", " β:web", " γ:doc", " δ:dev", " ε:gfx", " ζ:draw", " η:sys", " θ:ide", " ι:steam", " κ:torrent", " λ:vm", " μ:wine", " ν:spotify", " ξ:pic", " ο:remote", " ο:sound"]

# Window properties shown by xprop menu.
xprops_list = [
    "WM_CLASS",
    "WM_NAME",
    "WM_WINDOW_ROLE",
    "WM_TRANSIENT_FOR",
    "_NET_WM_WINDOW_TYPE",
    "_NET_WM_STATE",
    "_NET_WM_PID"
]

rules_xprop = [
    "WM_CLASS",
    "WM_WINDOW_ROLE",
    "WM_NAME",
    "_NET_WM_NAME"
]

font = "Iosevka Medium"
font_size = "15"
location = "south"
anchor = "south"
matching = "fuzzy"

prompt = "〉〉"
left_bracket = '⟬'
right_bracket = '⟭'
gap = '38'
use_default_width = '1920'

==> negi3mods.cfg <==
notification_color_field="\\*.color4"
prefix="〉〉"
module_list=["fs", "executor", "win_action", "circle", "win_history", "menu", "bscratch", "vol"]
port='15555'

==> polybar_vol.cfg <==
mpdaddr = '::1'
mpdport = "6600"
bufsize = 1024

delims = [" || ", "%{{O12}} ⃦%{{O8}}", " ║ "]
delimiter = "%{T3}%{F#005f87} ╲ %{F-}%{T-}"
show_volume = 'y'
vol_prefix = "Vol:"
vol_suffix = ""

bracket_color_field = '\\*.color4'
bright_color_field = 'polybar.light'
foreground_color_field = 'polybar.light'

==> polybar_ws.cfg <==
ws_color_field = "polybar.ws_color"
binding_color_field = "polybar.mode_color"

==> vol.cfg <==
mpd_inc = 1
mpd_addr = "::1"
mpd_port = "6600"
mpv_socket = "/tmp/mpv.socket"
use_mpv09 = 1
mpd_buf_size = 1024

==> win_action.cfg <==
cache_list_size = 10
quad_use_gaps = 1
x2_use_gaps = 1
grow_coeff = 1.01
shrink_coeff = 0.99

[useless_gaps]
w = 12
a = 12
s = 12
d = 12


==> win_history.cfg <==
autoback = ["pic", "gfx", "vm", ]

==> polybar_vol.py <==
#!/usr/bin/pypy3 -u

""" Volume printing daemon.

This daemon prints current MPD volume like `tail -f` echo server, so there is
no need to use busy waiting to extract information from it.

Usage:
    ./polybar_vol.py

Suppoused to be used inside polybar.

Config example:

[module/volume]
type = custom/script
interval = 0
exec = ~/.config/i3/proc/polybar_vol.py
exec-if = sleep 1
tail = true

Also you need to use unbuffered output for polybar, otherwise you will see no
output at all. I've considered that pypy3 is better choise here, because of
this application run pretty long time to get advantages of JIT compilation.

Created by :: Neg
email :: <serg.zorg@gmail.com>
github :: https://github.com/neg-serg?tab=repositories
year :: 2020

"""

import asyncio
import sys

from lib.standalone_cfg import modconfig
from lib.misc import Misc


class polybar_vol(modconfig):
    def __init__(self):
        self.loop = asyncio.get_event_loop()

        # Initialize modcfg.
        modconfig.__init__(self, self.loop)

        # default MPD address
        self.addr = self.conf("mpdaddr")

        # default MPD port
        self.port = self.conf("mpdport")

        # buffer size
        self.buf_size = self.conf("bufsize")

        # output string
        self.volume = ""

        # command to wait for mixer or player events from MPD
        self.idle_mixer = "idle mixer player\n"

        # command to get status from MPD
        self.status_cmd_str = "status\n"

        # various MPD // Volume printer delimiters
        self.delimiter = self.conf("delimiter")

        # volume prefix and suffix
        self.vol_prefix = self.conf("vol_prefix")
        self.vol_suffix = self.conf("vol_suffix")

        # xrdb-colors: use blue by default for brackets
        self.bracket_color_field = self.conf("bracket_color_field")
        self.bright_color_field = self.conf("bright_color_field")
        self.foreground_color_field = self.conf("foreground_color_field")

        self.bracket_color = Misc.extract_xrdb_value(self.bracket_color_field)
        self.bright_color = Misc.extract_xrdb_value(self.bright_color_field)
        self.foreground_color = Misc.extract_xrdb_value(
            self.foreground_color_field
        )

        self.right_bracket = ""

        # set string for the empty output
        if self.conf('show_volume').startswith('y'):
            self.empty_str = f"%{{F{self.bracket_color}}}{self.delimiter}" + \
                f"%{{F{self.bright_color}}}" + \
                f"{self.vol_prefix}%{{F{self.foreground_color}}}n/a%{{F-}}" + \
                f" %{{F{self.bracket_color}}}{self.right_bracket}%{{F-}}"
        else:
            self.empty_str = f" %{{F{self.bracket_color}}}" + \
                f"{self.right_bracket}%{{F-}}"

        # run mainloop
        self.main()

    def main(self):
        """ Mainloop starting here.
        """
        asyncio.set_event_loop(self.loop)
        try:
            self.loop.run_until_complete(
                self.update_mpd_volume(self.loop)
            )
        except ConnectionError:
            self.empty_output()
        finally:
            self.loop.close()

    def print_volume(self):
        """ Create nice and shiny output for polybar.
        """
        return f'%{{F{self.bracket_color}}}{self.delimiter}%{{F-}}' + \
            f'%{{F{self.foreground_color}}}' + \
            f'{self.vol_prefix}{self.volume}{self.vol_suffix}%{{F-}}' + \
            f'%{{F{self.bracket_color}}}{self.right_bracket}%{{F-}}'

    def empty_output(self):
        """ This output will be used if no information about volume.
        """
        sys.stdout.write(f'{self.empty_str}\n')

    async def initial_mpd_volume(self, reader, writer):
        """ Load MPD volume state when script started.
        """
        mpd_stopped = None

        data = await reader.read(self.buf_size)
        writer.write(self.status_cmd_str.encode(encoding='utf-8'))
        stat_data = await reader.read(self.buf_size)
        parsed = stat_data.decode('utf-8').split('\n')
        if 'volume' in parsed[0]:
            self.volume = parsed[0][8:]
            if int(self.volume) >= 0:
                self.volume = self.print_volume()
                sys.stdout.write(f"{self.volume}\n")
            else:
                sys.stdout.write(f" \n")
        else:
            for token in parsed:
                if token == 'state: stop':
                    mpd_stopped = True
                    break
            if mpd_stopped:
                print()
            else:
                print(self.empty_str)
        return data.startswith(b'OK')

    async def update_mpd_volume(self, loop):
        """ Update MPD volume here and print it.
        """
        prev_volume = ''
        reader, writer = await asyncio.open_connection(
            host=self.addr, port=self.port, loop=loop
        )
        if await self.initial_mpd_volume(reader, writer):
            while True:
                writer.write(self.idle_mixer.encode(encoding='utf-8'))
                data = await reader.read(self.buf_size)
                if data.decode('utf-8'):
                    writer.write(self.status_cmd_str.encode(encoding='utf-8'))
                    stat_data = await reader.read(self.buf_size)
                    parsed = stat_data.decode('utf-8').split('\n')
                    if 'state: play' in parsed and 'volume' in parsed[0]:
                        self.volume = parsed[0][8:]
                        if int(self.volume) >= 0:
                            if prev_volume != self.volume:
                                self.volume = self.print_volume()
                                sys.stdout.write(f"{self.volume}\n")
                            prev_volume = parsed[0][8:]
                    else:
                        prev_volume = ''
                        writer.close()
                        self.empty_output()
                        return
                else:
                    prev_volume = ''
                    writer.close()
                    self.empty_output()
                    return


if __name__ == '__main__':
    polybar_vol()

==> polybar_ws.py <==
#!/usr/bin/python3

""" Current workspace printing daemon.

This daemon prints current i3 workspace. You need this because of bugs inside
of polybar's i3 current workspace implementation: you will get race condition
leading to i3 wm dead-lock.

Also it print current keybinding mode.

Usage:
    ./polybar_ws.py

Suppoused to be used inside polybar.

Config example:

[module/ws]
type = custom/script
exec = ~/.config/i3/proc/polybar_ws.py
exec-if = sleep 1
format = <label>
tail = true

Also you need to use unbuffered output for polybar, otherwise you will see no
output at all. I've considered that pypy3 is better choise here, because of
this application run pretty long time to get advantages of JIT compilation.

Created by :: Neg
email :: <serg.zorg@gmail.com>
github :: https://github.com/neg-serg?tab=repositories
year :: 2020

"""

import sys
import re
import asyncio
import i3ipc
from i3ipc.aio import Connection

from lib.standalone_cfg import modconfig
from lib.misc import Misc


class polybar_ws(modconfig):
    def __init__(self):
        # initialize asyncio loop
        self.loop = asyncio.get_event_loop()

        # Initialize modcfg.
        modconfig.__init__(self, self.loop)

        self.conn = None

        self.ws_name = ""
        self.binding_mode = ""

        # regexes used to extract current binding mode.
        self.mode_regex = re.compile('.*mode ')
        self.split_by = re.compile('[;,]')

        self.ws_color_field = self.conf("ws_color_field")
        self.binding_color_field = self.conf("binding_color_field")
        self.ws_color = Misc.extract_xrdb_value(self.ws_color_field)
        self.binding_color = Misc.extract_xrdb_value(self.binding_color_field)
        self.ws_name = ""

    async def on_ws_focus(self, _, event):
        """ Get workspace name and throw event.
        """
        ws_name = event.current.name
        self.ws_name = ws_name.split(' :: ')[1:][0]
        await self.update_status()

    @staticmethod
    def colorize(s, color):
        return f"%{{T4}}%{{F{color}}}{s}%{{F-}}%{{T-}}"

    async def on_event(self, _, event):
        bind_cmd = event.binding.command
        for t in re.split(self.split_by, bind_cmd):
            if 'mode' in t:
                ret = re.sub(self.mode_regex, '', t)
                if ret[0] == ret[-1] and ret[0] in {'"', "'"}:
                    ret = ret[1:-1]
                    if ret == "default":
                        self.binding_mode = ''
                    else:
                        self.binding_mode = \
                            polybar_ws.colorize(
                                ret, color=self.binding_color
                            ) + ' '
                    await self.update_status()

    async def special_reload(self):
        """ Reload mainloop here.
        """
        asyncio.get_event_loop().close()
        self.loop = asyncio.get_event_loop()
        await self.main()

    async def main(self):
        """ Mainloop starting here.
        """
        asyncio.set_event_loop(self.loop)

        self.conn = await Connection(auto_reconnect=True).connect()
        self.conn.on(i3ipc.Event.WORKSPACE_FOCUS, self.on_ws_focus)
        self.conn.on(i3ipc.Event.BINDING, self.on_event)

        workspaces = await self.conn.get_workspaces()
        for ws in workspaces:
            if ws.focused:
                ws_name = ws.name
                self.ws_name = ws_name.split(' :: ')[1:][0]
                break

        await self.update_status()
        await self.conn.main()

    async def update_status(self):
        """ Print workspace information here. Event-based.
        """
        workspace = self.ws_name
        if not workspace[0].isalpha():
            workspace = polybar_ws.colorize(
                workspace[0], color=self.ws_color
            ) + workspace[1:]
        sys.stdout.write(f"{self.binding_mode + workspace}\n")
        await asyncio.sleep(0)


async def main():
    """ Start polybar_ws from here """
    await polybar_ws().main()


if __name__ == '__main__':
    asyncio.get_event_loop().run_until_complete(main())

#!/usr/bin/python3

""" i3 negi3mods daemon script.

This module loads all negi3mods an start it via main's manager
mailoop. Inotify-based watchers for all negi3mods TOML-based configuration
spawned here, to use it just start it from any place without parameters. Also
there is i3 config watcher to convert it from ppi3 format to plain i3
automatically. Moreover it contains pid-lock which prevents running several
times.

Usage:
    ./negi3mods.py [--debug|--tracemalloc|--start]

Options:
    --debug         disables signal handlers for debug.
    --tracemalloc   calculates and shows memory tracing with help of
                    tracemalloc.
    --start         make actions for the start, not reloading

Created by :: Neg
email :: <serg.zorg@gmail.com>
github :: https://github.com/neg-serg?tab=repositories
year :: 2020

"""

import os
import timeit
import atexit
import sys
import subprocess
import signal
import functools
import importlib
import shutil
from threading import Thread

for m in ["inotipy", "i3ipc", "docopt", "pulsectl",
          "toml", "Xlib", "yaml", "yamlloader", "ewmh"]:
    if not importlib.util.find_spec(m):
        print("Cannot import [{m}], please install")

import asyncio
import inotipy

import i3ipc
from docopt import docopt

from lib.locker import get_lock
from lib.msgbroker import MsgBroker
from lib.misc import Misc
from lib.standalone_cfg import modconfig


class negi3mods(modconfig):
    def __init__(self, cmd_args):
        """ Init function

            Using of self.intern for better performance, create i3ipc
            connection, connects to the asyncio eventloop.
        """

        # i3 path used to get i3 config path for "send" binary, _config needed
        # by ppi3 path and another configs.
        self.i3_path = Misc.i3path()
        loop = asyncio.new_event_loop()

        self.tracemalloc_enabled = False

        if cmd_args["--tracemalloc"]:
            self.tracemalloc_enabled = True
            import tracemalloc

        if self.tracemalloc_enabled:
            tracemalloc.start()

        self.first_run = False
        if cmd_args["--start"]:
            self.first_run = True

        if not (cmd_args['--debug'] or self.tracemalloc_enabled):
            def loop_exit(signame):
                print(f"Got signal {signame}: exit")
                loop.stop()
                os._exit(0)

            for signame in {'SIGINT', 'SIGTERM'}:
                loop.add_signal_handler(
                    getattr(signal, signame),
                    functools.partial(loop_exit, signame))
            loop.set_exception_handler(None)

        modconfig.__init__(self, loop)

        self.loop = loop

        self.mods = {}
        for mod in self.conf("module_list"):
            self.mods[sys.intern(mod)] = None

        self.prepare_notification_text()

        # i3 path used to get "send" binary path
        self.i3_cfg_path = self.i3_path + '/cfg/'

        # test config to check ppi3 conversion result
        self.test_cfg_path = os.path.realpath(
            os.path.expandvars('$HOME/tmp/config_test')
        )

        self.port = int(self.conf('port'))

        self.echo = Misc.echo_off
        self.notify = Misc.notify_off

        # main i3ipc connection created here and can be bypassed to the most of
        # modules here.
        self.i3 = i3ipc.Connection()

    def prepare_notification_text(self):
        """ stuff for startup notifications """
        self.notification_text = "Starting negi3mods\n\n"
        notification_color_field = self.conf("notification_color_field")
        notification_color = Misc.extract_xrdb_value(notification_color_field)
        prefix = self.conf("prefix")
        self.msg_prefix = f"<span weight='normal' \
            color='{notification_color}'> {prefix} </span>"

    def load_modules(self):
        """ Load modules.

            This function init MsgBroker, use importlib to load all the
            stuff, then add_ipc and update notification with startup
            benchmarks.
        """
        mod_startup_times = []
        self.echo('Loading modules')
        for mod in self.mods:
            start_time = timeit.default_timer()
            i3mod = importlib.import_module('lib.' + mod)
            self.mods[mod] = getattr(i3mod, mod)(self.i3, loop=self.loop)
            mod_startup_times.append(timeit.default_timer() - start_time)
            time_elapsed = f'{mod_startup_times[-1]:4f}s'
            mod_loaded_info = f'{mod:<10s} ~ {time_elapsed:>10s}'
            self.notification_text += self.msg_prefix + mod_loaded_info + '\n'
            self.echo(mod_loaded_info, flush=True)
        loading_time_msg = f'Loading time = {sum(mod_startup_times):6f}s'
        self.notification_text += loading_time_msg
        self.echo(loading_time_msg)

    def mods_cfg_watcher(self):
        """ cfg watcher to update modules config in realtime.
        """
        watcher = inotipy.Watcher.create()
        watcher.watch(self.i3_cfg_path, inotipy.IN.MODIFY)
        return watcher

    def autostart(self):
        """ Autostart auto negi3mods initialization """
        if self.first_run:
            try:
                subprocess.run(
                    [self.i3_path + 'send', 'circle', 'next', 'term'],
                    check=True
                )
            except subprocess.CalledProcessError as proc_err:
                Misc.print_run_exception_info(proc_err)

    def i3_config_watcher(self):
        """ i3 config watcher to run ppi3 on write.
        """
        watcher = inotipy.Watcher.create()
        watcher.watch(self.i3_path, inotipy.IN.CLOSE_WRITE)
        return watcher

    async def mods_cfg_worker(self, watcher, reload_one=True):
        """ Reloading configs on change. Reload only appropriate config by
            default.

            Args:
                watcher: watcher for cfg.
        """
        while True:
            event = await watcher.get()
            print(event)
            changed_mod = event.pathname[:-4]
            if changed_mod in self.mods:
                if reload_one:
                    try:
                        subprocess.run(
                            [self.i3_path + 'send', changed_mod, 'reload'],
                            check=True
                        )
                        self.notify(f'[Reloaded {changed_mod}]')
                    except subprocess.CalledProcessError as proc_err:
                        Misc.print_run_exception_info(proc_err)
                else:
                    for mod in self.mods:
                        try:
                            subprocess.run(
                                [self.i3_path + 'send', mod, 'reload'],
                                check=True
                            )
                        except subprocess.CalledProcessError as proc_err:
                            Misc.print_run_exception_info(proc_err)
                    self.notify(
                        '[Reloaded {' + ','.join(self.mods.keys()) + '}]'
                    )
        watcher.close()

    async def i3_config_worker(self, watcher):
        """ Run ppi3 when config is changed

            Args:
                watcher: watcher for i3 config.
        """
        while True:
            event = await watcher.get()
            if event.pathname == '_config':
                with open(self.test_cfg_path, "w") as fconf:
                    try:
                        subprocess.run(
                            ['ppi3', self.i3_path + '_config'],
                            stdout=fconf,
                            check=True
                        )
                        config_is_valid = self.validate_i3_config()
                    except subprocess.CalledProcessError as proc_err:
                        Misc.print_run_exception_info(proc_err)
                if config_is_valid:
                    self.echo("i3 config is valid!")
                    shutil.move(self.test_cfg_path, self.i3_path + 'config')

    def validate_i3_config(self):
        """ Checks that i3 config is ok.
        """
        try:
            check_config = subprocess.run(
                ['i3', '-c', self.test_cfg_path, '-C'],
                stdout=subprocess.PIPE,
                check=True
            ).stdout.decode('utf-8')
        except subprocess.CalledProcessError as proc_err:
            Misc.print_run_exception_info(proc_err)
        if check_config:
            error_data = check_config.encode('utf-8')
            self.echo(error_data)
            self.notify(error_data, "Error >")

            # remove invalid config
            os.remove(self.test_cfg_path)

            return False
        return True

    def run_config_watchers(self):
        """ Start all watchers here via ensure_future to run it in background.
        """
        asyncio.ensure_future(self.mods_cfg_worker(self.mods_cfg_watcher()))
        asyncio.ensure_future(self.i3_config_worker(self.i3_config_watcher()))

    def run(self):
        """ Run negi3mods here.
        """
        def start(func, args=None):
            """ Helper for pretty-printing of loading process.

                Args:
                    func (callable): callable routine to run.
                    name: routine name.
                    args: routine args, optional.
            """
            if args is None:
                func()
            elif args is not None:
                func(*args)

        start(self.load_modules)
        start(self.run_config_watchers)

        # Start modules mainloop.
        mainloop = Thread(
            target=MsgBroker.mainloop,
            args=(self.loop, self.mods, self.port,),
            daemon=True
        )
        start((mainloop).start)

        self.echo('... everything loaded ...')
        self.notify(self.notification_text)
        try:
            self.autostart()
            self.i3.main()
        except KeyboardInterrupt:
            self.i3.main_quit()
        self.echo('... exit ...')


def main():
    """ Run negi3mods from here """
    get_lock(os.path.basename(__file__))

    # We need it because of thread_wait on Ctrl-C.
    atexit.register(lambda: os._exit(0))

    cmd_args = docopt(__doc__, version='0.8')

    negi3mods_instance = negi3mods(cmd_args)
    negi3mods_instance.run()

    if negi3mods_instance.tracemalloc_enabled:
        snapshot = tracemalloc.take_snapshot()
        top_stats = snapshot.statistics('lineno')

        print("[ Top 10 ]")
        for stat in top_stats[:10]:
            print(stat)


if __name__ == '__main__':
    main()

#include <stdio.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <bsd/string.h>

#define PORT 15555

int main(int argc, char const *argv[]) {
    struct sockaddr_in serv_addr;

    int sock = 0;

    char *cmd = calloc(1024, 1);
    for (int i = 1; i < argc; i++) {
        strlcat(cmd, argv[i], 128);
        strlcat(cmd, " ", 128);
    }
    strlcat(cmd, "\n", 128);

    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        puts("\n Socket creation error \n");
        free(cmd);
        return -1;
    }

    memset(&serv_addr, '0', sizeof(serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) {
        printf("\nInvalid address/ Address not supported \n");
        free(cmd);
        return -1;
    }


    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        printf("\nConnection Failed \n");
        free(cmd);
        return -1;
    }

    if (send(sock, cmd, strnlen(cmd, 1024), 0) <= 0) {
        printf("Send failed");
    }

    free(cmd);
    return 0;
}

#!/bin/zsh
${XDG_CONFIG_HOME}/i3/negi3mods.py --start >> ${HOME}/tmp/negi3mods.log 2>&1 &
make -C ${XDG_CONFIG_HOME}/i3/ &
pkill -f 'mpc idle'
pkill sxhkd; sxhkd &

==> bscratch.py <==
""" Named scratchpad i3 module

This is a module about ion3/notion-like named scratchpad implementation.
You can think about it as floating "tabs" for windows, which can be
shown/hidden by request, with next "tab" navigation.

The foundation of it is a i3 mark function, you can create a mark with
tag+'-'+uuid format. And then this imformation used to performs all
actions.

Also I've hacked fullscreen behaviour for it, so you can always get
your scratchpad from fullscreen and also restore fullsreen state of the
window when needed.
"""

import uuid
from typing import List, Callable, Set, Optional

import geom
from cfg import cfg
from matcher import Matcher
from misc import Misc
from negewmh import NegEWMH
from negi3mod import negi3mod


class bscratch(negi3mod, cfg, Matcher):
    """ Named scratchpad class

    Parents:
        cfg: configuration manager to autosave/autoload
             TOML-configutation with inotify
        Matcher: class to check that window can be tagged with given tag by
                 WM_CLASS, WM_INSTANCE, regexes, etc
    """

    def __init__(self, i3, loop=None) -> None:
        """ Init function

        Args:
            i3: i3ipc connection
            loop: asyncio loop. It's need to be given as parameter because of
                  you need to bypass asyncio-loop to the thread
        """
        # Initialize superclasses.
        cfg.__init__(self, i3, convert_me=True)
        Matcher.__init__(self)

        # Initialization

        # winlist is used to reduce calling i3.get_tree() too many times.
        self.win = None

        # fullscreen_list is used to perform fullscreen hacks
        self.fullscreen_list = []

        # nsgeom used to respect current screen resolution in the geometry
        # settings and scale it
        self.nsgeom = geom.geom(self.cfg)

        # marked used to get the list of current tagged windows
        # with the given tag
        self.marked = {l: [] for l in self.cfg}

        # Mark all tags from the start
        self.mark_all_tags(hide=True)

        # Do not autosave geometry by default
        self.auto_save_geom(False)

        # focus_win_flag is a helper to perform attach/detach window to the
        # named scratchpad with add_prop/del_prop routines
        self.focus_win_flag = [False, ""]

        # i3ipc connection, bypassed by negi3mods runner
        self.i3ipc = i3

        self.bindings = {
            "show": self.show_scratchpad,
            "hide": self.hide_scratchpad_all_but_current,
            "next": self.next_win_on_curr_tag,
            "toggle": self.toggle,
            "hide_current": self.hide_current,
            "geom_restore": self.geom_restore_current,
            "geom_dump": self.geom_dump_current,
            "geom_save": self.geom_save_current,
            "geom_autosave_mode": self.autosave_toggle,
            "subtag": self.run_subtag,
            "add_prop": self.add_prop,
            "del_prop": self.del_prop,
            "reload": self.reload_config,
            "dialog": self.dialog_toggle,
        }

        i3.on('window::new', self.mark_tag)
        i3.on('window::close', self.unmark_tag)

    def taglist(self) -> List:
        """ Returns list of tags without transients windows.
        """
        tag_list = list(self.cfg.keys())
        tag_list.remove('transients')
        return tag_list

    @staticmethod
    def mark_uuid_tag(tag: str) -> str:
        """ Generate unique mark for the given [tag]

            Args:
                tag: tag string
        """
        return f'mark {tag}-{str(str(uuid.uuid4().fields[-1]))}'

    def show_scratchpad(self, tag: str, hide: bool = True) -> None:
        """ Show given [tag]

            Args:
                tag: tag string
                hide: optional predicate to hide all windows except current.
                      Should be used in the most cases because of better
                      performance and visual neatness
        """
        win_to_focus = None
        for win in self.marked[tag]:
            win.command('move window to workspace current')
            win_to_focus = win
        if hide and tag != 'transients':
            self.hide_scratchpad_all_but_current(tag, win_to_focus)
        if win_to_focus is not None:
            win_to_focus.command('focus')

    def hide_scratchpad(self, tag: str) -> None:
        """ Hide given [tag]

            Args:
                tag (str): scratchpad name to hide
        """
        if self.geom_auto_save:
            self.geom_save(tag)
        for win in self.marked[tag]:
            win.command('move scratchpad')
        self.restore_fullscreens()

    def hide_scratchpad_all_but_current(self, tag: str, current_win) -> None:
        """ Hide all tagged windows except current.

            Args:
                tag: tag string
        """
        if len(self.marked[tag]) > 1 and current_win is not None:
            for win in self.marked[tag]:
                if win.id != current_win.id:
                    win.command('move scratchpad')
                else:
                    win.command('move window to workspace current')

    def find_visible_windows(
            self, focused: Optional[bool] = None) -> List:
        """ Find windows on the current workspace, which is enough for
        scratchpads.

            Args:
                focused: denotes that [focused] window should be extracted from
                         i3.get_tree() or not
        """
        if focused is None:
            focused = self.i3ipc.get_tree().find_focused()
        return NegEWMH.find_visible_windows(
            focused.workspace().leaves()
        )

    def dialog_toggle(self) -> None:
        """ Show dialog windows
        """
        self.show_scratchpad('transients', hide=False)

    def toggle_fs(self, win) -> None:
        """ Toggles fullscreen on/off and show/hide requested scratchpad after.

            Args:
                w : window that fullscreen state should be on/off.
        """
        if win.fullscreen_mode:
            win.command('fullscreen toggle')
            self.fullscreen_list.append(win)

    def toggle(self, tag: str) -> None:
        """ Toggle scratchpad with given [tag].

            Args:
                tag (str): denotes the target tag.
        """
        if not self.marked.get(tag, []):
            prog_str = self.extract_prog_str(self.conf(tag))
            if prog_str:
                self.i3ipc.command(f'exec {prog_str}')
            else:
                spawn_str = self.extract_prog_str(
                    self.conf(tag), "spawn", exe_file=False
                )
                if spawn_str:
                    self.i3ipc.command(
                        f'exec ~/.config/i3/send executor run {spawn_str}'
                    )

        if self.visible_window_with_tag(tag):
            self.hide_scratchpad(tag)
            return

        # We need to hide scratchpad it is visible,
        # regardless it focused or not
        focused = self.i3ipc.get_tree().find_focused()

        if self.marked.get(tag, []):
            self.toggle_fs(focused)
            self.show_scratchpad(tag)

    def focus_sub_tag(self, tag: str, subtag_classes_set: Set) -> None:
        """ Cycle over the subtag windows.

            Args:
                tag (str): denotes the target tag.
                subtag_classes_set (set): subset of classes of target [tag]
                                          which distinguish one subtag from
                                          another.
        """
        focused = self.i3ipc.get_tree().find_focused()
        self.toggle_fs(focused)

        if focused.window_class in subtag_classes_set:
            return

        self.show_scratchpad(tag)

        for _ in self.marked[tag]:
            if focused.window_class not in subtag_classes_set:
                self.next_win_on_curr_tag()
                focused = self.i3ipc.get_tree().find_focused()

    def run_subtag(self, tag: str, subtag: str) -> None:
        """ Run-or-focus the application for subtag

            Args:
                tag (str): denotes the target tag.
                subtag (str): denotes the target subtag.
        """
        if subtag in self.conf(tag):
            class_list = [win.window_class for win in self.marked[tag]]
            subtag_classes_set = self.conf(tag, subtag, "class")
            subtag_classes_matched = [
                w for w in class_list if w in subtag_classes_set
            ]
            if not subtag_classes_matched:
                prog_str = self.extract_prog_str(self.conf(tag, subtag))
                self.i3ipc.command(f'exec {prog_str}')
                self.focus_win_flag = [True, tag]
            else:
                self.focus_sub_tag(tag, subtag_classes_set)
        else:
            self.toggle(tag)

    def restore_fullscreens(self) -> None:
        """ Restore all fullscreen windows
        """
        for win in self.fullscreen_list:
            win.command('fullscreen toggle')
        self.fullscreen_list = []

    def visible_window_with_tag(self, tag: str) -> bool:
        """ Counts visible windows for given tag

            Args:
                tag (str): denotes the target tag.
        """
        for win in self.find_visible_windows():
            for i in self.marked[tag]:
                if win.id == i.id:
                    return True
        return False

    def get_current_tag(self, focused) -> str:
        """ Get the current tag

            This function use focused window to determine the current tag.

            Args:
                focused : focused window.
        """
        for tag in self.cfg:
            for i in self.marked[tag]:
                if focused.id == i.id:
                    return tag

        return ''

    def apply_to_current_tag(self, func: Callable) -> bool:
        """ Apply function [func] to the current tag

            This is the generic function used in next_win_on_curr_tag,
            hide_current and another to perform actions on the currently
            selected tag.

            Args:
                func(Callable) : function to apply.
        """
        curr_tag = self.get_current_tag(self.i3ipc.get_tree().find_focused())
        if curr_tag:
            func(curr_tag)
        return bool(curr_tag)

    def next_win_on_curr_tag(self, hide: bool = True) -> None:
        """ Show the next window for the currently selected tag.

            Args:
                hide (bool): hide window or not. Primarly used to cleanup
                             "garbage" that can appear after i3 (re)start, etc.
                             Because of I've think that is't better to make
                             screen clear after (re)start.
        """
        def next_win(tag: str) -> None:
            self.show_scratchpad(tag, hide_)
            for idx, win in enumerate(self.marked[tag]):
                if focused_win.id != win.id:
                    self.marked[tag][idx].command(
                        'move window to workspace current'
                    )
                    self.marked[tag].insert(
                        len(self.marked[tag]),
                        self.marked[tag].pop(idx)
                    )
                    win.command('move scratchpad')
            self.show_scratchpad(tag, hide_)

        hide_ = hide
        focused_win = self.i3ipc.get_tree().find_focused()
        self.apply_to_current_tag(next_win)

    def hide_current(self) -> None:
        """ Hide the currently selected tag.
        """
        self.apply_to_current_tag(self.hide_scratchpad)

    def geom_restore(self, tag: str) -> None:
        """ Restore default window geometry

            Args:
                tag(str) : hide another windows for the current tag or not.
        """
        for idx, win in enumerate(self.marked[tag]):
            # delete previous mark
            del self.marked[tag][idx]

            # then make a new mark and move scratchpad
            win_cmd = f"{bscratch.mark_uuid_tag(tag)}, \
                move scratchpad, {self.nsgeom.get_geom(tag)}"
            win.command(win_cmd)
            self.marked[tag].append(win)

    def geom_restore_current(self) -> None:
        """ Restore geometry for the current selected tag.
        """
        self.apply_to_current_tag(self.geom_restore)

    def geom_dump(self, tag: str) -> None:
        """ Dump geometry for the given tag

            Args:
                tag(str) : denotes target tag.
        """
        focused = self.i3ipc.get_tree().find_focused()
        for win in self.marked[tag]:
            if win.id == focused.id:
                self.conf[tag]["geom"] = f"{focused.rect.width}x" + \
                    f"{focused.rect.height}+{focused.rect.x}+{focused.rect.y}"
                self.dump_config()
                break

    def geom_save(self, tag: str) -> None:
        """ Save geometry for the given tag

            Args:
                tag(str) : denotes target tag.
        """
        focused = self.i3ipc.get_tree().find_focused()
        for win in self.marked[tag]:
            if win.id == focused.id:
                self.conf[tag]["geom"] = f"{focused.rect.width}x\
                    {focused.rect.height}+{focused.rect.x}+{focused.rect.y}"
                if win.rect.x != focused.rect.x \
                    or win.rect.y != focused.rect.y \
                    or win.rect.width != focused.rect.width \
                        or win.rect.height != focused.rect.height:
                    self.nsgeom = geom.geom(self.cfg)
                    win.rect.x = focused.rect.x
                    win.rect.y = focused.rect.y
                    win.rect.width = focused.rect.width
                    win.rect.height = focused.rect.height
                break

    def auto_save_geom(self, save: bool = True,
                       with_notification: bool = False) -> None:
        """ Set geometry autosave option with optional notification.

            Args:
                save(bool): predicate that shows that want to enable/disable
                             autosave mode.
                with_notification(bool): to create notify-osd-based
                                         notification or not.
        """
        self.geom_auto_save = save
        if with_notification:
            Misc.notify_msg(f"geometry autosave={save}")

    def autosave_toggle(self) -> None:
        """ Toggle autosave mode.
        """
        if self.geom_auto_save:
            self.auto_save_geom(False, with_notification=True)
        else:
            self.auto_save_geom(True, with_notification=True)

    def geom_dump_current(self) -> None:
        """ Dump geometry for the current selected tag.
        """
        self.apply_to_current_tag(self.geom_dump)

    def geom_save_current(self) -> None:
        """ Save geometry for the current selected tag.
        """
        self.apply_to_current_tag(self.geom_save)

    def add_prop(self, tag_to_add: str, prop_str: str) -> None:
        """ Add property via [prop_str] to the target [tag].

            Args:
                tag_to_add (str): denotes the target tag.
                prop_str (str): string in i3-match format used to add/delete
                                target window in/from scratchpad.
        """
        if tag_to_add in self.cfg:
            self.add_props(tag_to_add, prop_str)

        for tag in self.cfg:
            if tag != tag_to_add:
                self.del_props(tag, prop_str)
                if self.marked[tag] != []:
                    for win in self.marked[tag]:
                        win.command('unmark')

        self.initialize(self.i3ipc)

    def del_prop(self, tag: str, prop_str: str) -> None:
        """ Delete property via [prop_str] to the target [tag].

            Args:
                tag (str): denotes the target tag.
                prop_str (str): string in i3-match format used to add/delete
                                target window in/from scratchpad.
        """
        self.del_props(tag, prop_str)

    def mark_tag(self, _, event) -> None:
        """ Add unique mark to the new window.

            Args:
                _: i3ipc connection.
                event: i3ipc event. We can extract window from it using
                event.container.
        """
        win = event.container
        is_dialog_win = NegEWMH.is_dialog_win(win)

        self.win = win
        for tag in self.cfg:
            if not is_dialog_win and tag != "transients":
                if self.match(win, tag):
                    # scratch_move
                    win.command(
                        f"{bscratch.mark_uuid_tag(tag)}, move scratchpad, \
                        {self.nsgeom.get_geom(tag)}")
                    self.marked[tag].append(win)
            elif is_dialog_win and tag == "transients":
                win.command(
                    f"{bscratch.mark_uuid_tag('transients')}, \
                    move scratchpad")
                self.marked["transients"].append(win)

        # Special hack to invalidate windows after subtag start
        if self.focus_win_flag[0]:
            special_tag = self.focus_win_flag[1]
            if special_tag in self.cfg:
                self.show_scratchpad(special_tag, hide=True)
            self.focus_win_flag[0] = False
            self.focus_win_flag[1] = ""

        self.dialog_toggle()

    def unmark_tag(self, _, event) -> None:
        """ Delete unique mark from the closed window.

            Args:
                _: i3ipc connection.
                event: i3ipc event. We can extract window from it using
                event.container.
        """
        win_ev = event.container
        self.win = win_ev
        for tag in self.taglist():
            for win in self.marked[tag]:
                if win.id == win_ev.id:
                    self.marked[tag].remove(win)
                    self.show_scratchpad(tag)
                    break

        if win_ev.fullscreen_mode:
            self.apply_to_current_tag(self.hide_scratchpad)

        for transient in self.marked["transients"]:
            if transient.id == win_ev.id:
                self.marked["transients"].remove(transient)

    def mark_all_tags(self, hide: bool = True) -> None:
        """ Add marks to the all tags.

            Args:
                hide (bool): hide window or not. Primarly used to cleanup
                             "garbage" that can appear after i3 (re)start, etc.
                             Because of I've think that is't better to make
                             screen clear after (re)start.
        """
        winlist = self.i3ipc.get_tree().leaves()
        hide_cmd = ''

        for win in winlist:
            is_dialog_win = NegEWMH.is_dialog_win(win)
            for tag in self.cfg:
                if not is_dialog_win and tag != "transients":
                    if self.match(win, tag):
                        if hide:
                            hide_cmd = '[con_id=__focused__] scratchpad show'
                        win_cmd = f"{bscratch.mark_uuid_tag(tag)}, \
                            move scratchpad, \
                            {self.nsgeom.get_geom(tag)}, {hide_cmd}"
                        win.command(win_cmd)
                        self.marked[tag].append(win)
                if is_dialog_win:
                    win_cmd = f"{bscratch.mark_uuid_tag('transients')}, \
                        move scratchpad"
                    win.command(win_cmd)
                    self.marked["transients"].append(win)
            self.win = win

==> cfg.py <==
""" Dynamic TOML-based config for negi3mods.

This is a superclass for negi3mods which want to store configuration via TOML
files. It supports inotify-based updating of self.cfg dynamically and has
pretty simple API. I've considered that inheritance here is good idea.
"""

import re
import os
import sys
from typing import Set, Callable
import traceback

import toml
from misc import Misc


class cfg(object):
    def __init__(self, i3, convert_me: bool = False, loop=None) -> None:
        # detect current negi3mod
        self.mod = self.__class__.__name__

        # negi3mod config path
        self.i3_cfg_mod_path = Misc.i3path() + '/cfg/' + self.mod + '.cfg'

        # convert config values or not
        self.convert_me = convert_me

        # load current config
        self.load_config()

        # used for props add / del hacks
        self.win_attrs = {}

        # bind numbers to cfg names
        self.conv_props = {
            'class': 'class',
            'instance': 'instance',
            'window_role': 'window_role',
            'title': 'name',
        }

        self.i3ipc = i3
        self.loop = None
        if loop is not None:
            self.loop = loop

    def conf(self, *conf_path):
        """ Helper to extract config for current tag.

        Args:
            conf_path: path of config from where extract.
        """
        ret = {}
        for part in conf_path:
            if not ret:
                ret = self.cfg.get(part)
            else:
                ret = ret.get(part)
        return ret

    @staticmethod
    def extract_prog_str(conf_part: str,
                         prog_field: str = "prog", exe_file: bool = True):
        """ Helper to extract prog(by default) string from config

        Args:
            conf_part (str): part of config from where you want to extract it.
            prog_field (str): string name to extract.
        """
        if conf_part is None:
            return ""

        if exe_file:
            return re.sub(
                "~",
                os.path.realpath(os.path.expandvars("$HOME")),
                conf_part.get(prog_field, "")
            )

        return conf_part.get(prog_field, "")

    @staticmethod
    def cfg_regex_props() -> Set[str]:
        """ Props with regexes """
        # regex cfg properties
        return {"class_r", "instance_r", "name_r", "role_r"}

    def win_all_props(self):
        """ All window props """
        # basic + regex props
        return self.cfg_props() | self.cfg_regex_props()

    @staticmethod
    def possible_props() -> Set[str]:
        """ Possible window props """
        # windows properties used for props add / del
        return {'class', 'instance', 'window_role', 'title'}

    @staticmethod
    def cfg_props() -> Set[str]:
        """ basic window props """
        # basic cfg properties, without regexes
        return {'class', 'instance', 'name', 'role'}

    @staticmethod
    def subtag_attr_list() -> Set[str]:
        """ Helper to create subtag attr list. """
        return cfg.possible_props()

    def reload_config(self, *arg) -> None:
        """ Reload config for current selected module.
            Call load_config, print debug messages and reinit all stuff.
        """
        prev_conf = self.cfg
        try:
            self.load_config()
            if self.loop is None:
                self.__init__(self.i3ipc)
            else:
                self.__init__(self.i3ipc, loop=self.loop)
            print(f"[{self.mod}] config reloaded")
        except Exception:
            print(f"[{self.mod}] config reload failed")
            traceback.print_exc(file=sys.stdout)
            self.cfg = prev_conf
            self.__init__()

    def dict_converse(self) -> None:
        """ Convert list attributes to set for the better performance.
        """
        self.dict_apply(lambda key: set(key), cfg.convert_subtag)

    def dict_deconverse(self) -> None:
        """ Convert set attributes to list, because of set cannot be saved
            / restored to / from TOML-files corretly.
        """
        self.dict_apply(lambda key: list(key), cfg.deconvert_subtag)

    @staticmethod
    def convert_subtag(subtag: str) -> None:
        """ Convert subtag attributes to set for the better performance.

            Args:
                subtag (str): target subtag.
        """
        cfg.subtag_apply(subtag, lambda key: set(key))

    @staticmethod
    def deconvert_subtag(subtag: str) -> None:
        """ Convert set attributes to list, because of set cannot be saved
        / restored to / from TOML-files corretly.

            Args:
                subtag (str): target subtag.
        """
        cfg.subtag_apply(subtag, lambda key: list(key))

    def dict_apply(self, field_conv: Callable, subtag_conv: Callable) -> None:
        """ Convert list attributes to set for the better performance.

            Args:
                field_conv (Callable): function to convert dict field.
                subtag_conv (Callable): function to convert subtag inside dict.
        """
        for string in self.cfg.values():
            for key in string:
                if key in self.win_all_props():
                    string[sys.intern(key)] = field_conv(
                        string[sys.intern(key)]
                    )
                elif key == "subtag":
                    subtag_conv(string[sys.intern(key)])

    @staticmethod
    def subtag_apply(subtag: str, field_conv: Callable) -> None:
        """ Convert subtag attributes to set for the better performance.

            Args:
                subtag (str): target subtag name.
                field_conv (Callable): function to convert dict field.
        """
        for val in subtag.values():
            for key in val:
                if key in cfg.subtag_attr_list():
                    val[sys.intern(key)] = field_conv(val[sys.intern(key)])

    def load_config(self) -> None:
        """ Reload config itself and convert lists in it to sets for the better
            performance.
        """
        with open(self.i3_cfg_mod_path, "r") as negi3modcfg:
            self.cfg = toml.load(negi3modcfg)
        if self.convert_me:
            self.dict_converse()

    def dump_config(self) -> None:
        """ Dump current config, can be used for debugging.
        """
        with open(self.i3_cfg_mod_path, "r+") as negi3modcfg:
            if self.convert_me:
                self.dict_deconverse()
            toml.dump(self.cfg, negi3modcfg)
            self.cfg = toml.load(negi3modcfg)
        if self.convert_me:
            self.dict_converse()

    def property_to_winattrib(self, prop_str: str) -> None:
        """ Parse property string to create win_attrs dict.
            Args:
                prop_str (str): property string in special format.
        """
        self.win_attrs = {}
        prop_str = prop_str[1:-1]
        for token in prop_str.split('@'):
            if token:
                toks = token.split('=')
                attr = toks[0]
                value = toks[1]
                if value[0] == value[-1] and value[0] in {'"', "'"}:
                    value = value[1:-1]
                if attr in cfg.subtag_attr_list():
                    self.win_attrs[self.conv_props.get(attr, {})] = value

    def add_props(self, tag: str, prop_str: str) -> None:
        """ Move window to some tag.
            Args:
                tag (str): target tag
                prop_str (str): property string in special format.
        """
        self.property_to_winattrib(prop_str)
        ftors = self.cfg_props() & set(self.win_attrs.keys())
        if tag in self.cfg:
            for tok in ftors:
                if self.win_attrs[tok] not in \
                        self.cfg.get(tag, {}).get(tok, {}):
                    if tok in self.cfg[tag]:
                        if isinstance(self.cfg[tag][tok], str):
                            self.cfg[tag][tok] = {self.win_attrs[tok]}
                        elif isinstance(self.cfg[tag][tok], set):
                            self.cfg[tag][tok].add(self.win_attrs[tok])
                    else:
                        self.cfg[tag].update({tok: self.win_attrs[tok]})
                    # special fix for the case where attr
                    # is just attr not {attr}
                    if isinstance(self.conf(tag, tok), str):
                        self.cfg[tag][tok] = {self.win_attrs[tok]}

    def del_direct_props(self, target_tag: str) -> None:
        """ Remove basic(non-regex) properties of window from target tag.
            Args:
                tag (str): target tag
        """
        # Delete 'direct' props:
        for prop in self.cfg[target_tag].copy():
            if prop in self.cfg_props():
                if isinstance(self.conf(target_tag, prop), str):
                    del self.cfg[target_tag][prop]
                elif isinstance(self.conf(target_tag, prop), set):
                    for tok in self.cfg[target_tag][prop].copy():
                        if self.win_attrs[prop] == tok:
                            self.cfg[target_tag][prop].remove(tok)

    def del_regex_props(self, target_tag: str) -> None:
        """ Remove regex properties of window from target tag.
            Args:
                target_tag (str): target tag
        """
        def check_for_win_attrs(win, prop):
            class_r_check = \
                (prop == "class_r" and winattr == win.window_class)
            instance_r_check = \
                (prop == "instance_r" and winattr == win.window_instance)
            role_r_check = \
                (prop == "role_r" and winattr == win.window_role)
            if class_r_check or instance_r_check or role_r_check:
                self.cfg[target_tag][prop].remove(target_tag)

        # Delete appropriate regexes
        for prop in self.cfg[target_tag].copy():
            if prop in self.cfg_regex_props():
                for reg in self.cfg[target_tag][prop].copy():
                    if prop == "class_r":
                        lst_by_reg = self.i3ipc.get_tree().find_classed(reg)
                    if prop == "instance_r":
                        lst_by_reg = self.i3ipc.get_tree().find_instanced(reg)
                    if prop == "role_r":
                        lst_by_reg = self.i3ipc.get_tree().find_by_role(reg)
                    winattr = self.win_attrs[prop[:-2]]
                    for win in lst_by_reg:
                        check_for_win_attrs(win, prop)

    def del_props(self, tag: str, prop_str: str) -> None:
        """ Remove window from some tag.
            Args:
                tag (str): target tag
                prop_str (str): property string in special format.
        """
        self.property_to_winattrib(prop_str)
        self.del_direct_props(tag)
        self.del_regex_props(tag)

        # Cleanup
        for prop in self.cfg_regex_props() | self.cfg_props():
            if prop in self.conf(tag) and self.conf(tag, prop) == set():
                del self.cfg[tag][prop]

==> circle.py <==
""" Circle over windows module.

This is a module about better run-or-raise features like in ion3, stumpwm and
others. As the result user can get not only the usual run the appropriate
application if it is not started, but also create a list of application, which
I call "tag" and then switch to the next of it, instead of just simple focus.

The foundation of it is pretty complicated go_next function, which use counters
with incrementing of the current "position" of the window in the tag list over
the finite field. As the result you get circle over all tagged windows.

Also I've hacked fullscreen behaviour for it, so you can always switch to the
window with the correct fullscreen state, where normal i3 behaviour has a lot
of issues here in detection of existing/visible windows, etc.
"""

from negi3mod import negi3mod
from matcher import Matcher
from cfg import cfg


class circle(negi3mod, cfg, Matcher):
    """ Circle over windows class

    Parents:
        cfg: configuration manager to autosave/autoload
             TOML-configutation with inotify
        Matcher: class to check that window can be tagged with given tag by
                 WM_CLASS, WM_INSTANCE, regexes, etc

    """

    def __init__(self, i3, loop=None) -> None:
        """ Init function

        Main part is in self.initialize, which performs initialization itself.

        Args:
            i3: i3ipc connection
            loop: asyncio loop. It's need to be given as parameter because of
                  you need to bypass asyncio-loop to the thread
        """
        # Initialize superclasses.
        cfg.__init__(self, i3, convert_me=True)
        Matcher.__init__(self)

        # i3ipc connection, bypassed by negi3mods runner.
        self.i3ipc = i3

        # map of tag to the tagged windows.
        self.tagged = {}

        # current_position for the tag [tag]
        self.current_position = {}

        # list of windows which fullscreen state need to be restored.
        self.restore_fullscreen = []

        # is the current action caused by user actions or not? It's needed for
        # corrent fullscreen on/off behaviour.
        self.interactive = True

        # how many attempts taken to find window with priority
        self.repeats = 0

        # win cache for the fast matching
        self.win = None

        # used for subtag info caching
        self.subtag_info = {}

        # Should the special fullscreen-related actions to be performed or not.
        self.need_handle_fullscreen = True

        # Initialize
        i3tree = self.i3ipc.get_tree()

        # prepare for prefullscreen
        self.fullscreened = i3tree.find_fullscreen()

        # store the current window here to cache get_tree().find_focused value.
        self.current_win = i3tree.find_focused()

        # winlist is used to reduce calling i3.get_tree() too many times.
        self.winlist = i3tree.leaves()
        for tag in self.cfg:
            self.tagged[tag] = []
            self.current_position[tag] = 0

        # tag all windows after start
        self.tag_windows(invalidate_winlist=False)

        self.bindings = {
            "next": self.go_next,
            "subtag": self.go_subtag,
            "add_prop": self.add_prop,
            "del_prop": self.del_prop,
            "reload": self.reload_config,
        }

        self.i3ipc.on('window::new', self.add_wins)
        self.i3ipc.on('window::close', self.del_wins)
        self.i3ipc.on("window::focus", self.set_curr_win)
        self.i3ipc.on("window::fullscreen_mode", self.handle_fullscreen)

    def run_prog(self, tag: str, subtag: str = '') -> None:
        """ Run the appropriate application for the current tag/subtag.

        Args:
            tag (str): denotes target [tag]
            subtag (str): denotes the target [subtag], optional.
        """
        if tag is not None and self.cfg.get(tag) is not None:
            if not subtag:
                prog_str = self.extract_prog_str(self.conf(tag))
            else:
                prog_str = self.extract_prog_str(
                    self.conf(tag, subtag)
                )
            if prog_str:
                self.i3ipc.command(f'exec {prog_str}')
            else:
                spawn_str = self.extract_prog_str(
                    self.conf(tag), "spawn", exe_file=False
                )
                if spawn_str:
                    self.i3ipc.command(
                        f'exec ~/.config/i3/send executor run {spawn_str}'
                    )

    def find_next_not_the_same_win(self, tag: str) -> None:
        """ It was used as the guard to infinite loop in the past.
        Args:
            tag (str): denotes target [tag]
        """
        if len(self.tagged[tag]) > 1:
            self.current_position[tag] += 1
            self.go_next(tag)

    def prefullscreen(self, tag: str) -> None:
        """ Prepare to go fullscreen.
        """
        for win in self.fullscreened:
            if self.current_win.window_class in set(self.conf(tag, "class")) \
                    and self.current_win.id == win.id:
                self.need_handle_fullscreen = False
                win.command('fullscreen disable')

    def postfullscreen(self, tag: str, idx: int) -> None:
        """ Exit from fullscreen.
        """
        now_focused = self.twin(tag, idx).id
        for win_id in self.restore_fullscreen:
            if win_id == now_focused:
                self.need_handle_fullscreen = False
                self.i3ipc.command(
                    f'[con_id={now_focused}] fullscreen enable'
                )

    def focus_next(self, tag: str, idx: int,
                   inc_counter: bool = True,
                   fullscreen_handler: bool = True,
                   subtagged: bool = False) -> None:
        """ Focus next window. Used by go_next function.
        Tag list is a list of windows by some factor, which determined by
        config settings.

        Args:
            tag (str): target tag.
            idx (int): index inside tag list.
            inc_counter (bool): increase counter or not.
            fullscreen_handler (bool): for manual set / unset fullscreen,
                                        because of i3 is not perfect in it.
                                        For example you need it for different
                                        workspaces.
            subtagged (bool): this flag denotes to subtag using.
        """
        if fullscreen_handler:
            self.prefullscreen(tag)

        self.twin(tag, idx, subtagged).command('focus')

        if inc_counter:
            self.current_position[tag] += 1

        if fullscreen_handler:
            self.postfullscreen(tag, idx)

        self.need_handle_fullscreen = True

    def twin(self, tag: str, idx: int, with_subtag: bool = False):
        """ Detect target window.
            Args:
                tag (str): selected tag.
                idx (int): index in tag list.
                with_subtag (bool): contains subtag, special behaviour then.
        """
        if not with_subtag:
            return self.tagged[tag][idx]

        subtag_win_classes = self.subtag_info.get("class", {})
        for subidx, win in enumerate(self.tagged[tag]):
            if win.window_class in subtag_win_classes:
                return self.tagged[tag][subidx]

        return self.tagged[tag][0]

    def need_priority_check(self, tag):
        """ Checks that priority string is defined, then thecks that currrent
        window not in class set.

            Args:
                tag(str): target tag name

        """
        return "priority" in self.conf(tag) and \
            self.current_win.window_class not in set(self.conf(tag, "class"))

    def not_priority_win_class(self, tag, win):
        """ Window class is not priority class for the given tag

            Args:
                tag(str): target tag name
                win: window
        """
        return win.window_class in self.conf(tag, "class") and \
            win.window_class != self.conf(tag, "priority")

    def no_prioritized_wins(self, tag):
        """ Checks all tagged windows for the priority win.

            Args:
                tag(str): target tag name
        """
        return not [
            win for win in self.tagged[tag]
            if win.window_class == self.conf(tag, "priority")
        ]

    def go_next(self, tag: str) -> None:
        """ Circle over windows. Function "called" from the user-side.

        Args:
            tag (str): denotes target [tag]
        """
        self.sort_by_parent(tag)
        if not self.tagged[tag]:
            self.run_prog(tag)
        elif len(self.tagged[tag]) == 1:
            idx = 0
            self.focus_next(tag, idx, fullscreen_handler=False)
        else:
            idx = self.current_position[tag] % len(self.tagged[tag])
            if self.need_priority_check(tag):
                for win in self.tagged[tag]:
                    if self.no_prioritized_wins(tag):
                        self.run_prog(tag)
                        return
                for idx, win in enumerate(self.tagged[tag]):
                    if win.window_class == self.conf(tag, "priority"):
                        self.focus_next(tag, idx, inc_counter=False)
            elif self.current_win.id == self.twin(tag, idx).id:
                self.find_next_not_the_same_win(tag)
            else:
                self.focus_next(tag, idx)

    def go_subtag(self, tag: str, subtag: str) -> None:
        """ Circle over subtag windows. Function "called" from the user-side.

        Args:
            tag (str): denotes target [tag]
            subtag (str): denotes the target [subtag].
        """
        self.subtag_info = self.conf(tag, subtag)
        self.tag_windows()

        if self.subtag_info:
            subtagged_class_set = set(self.subtag_info.get("class", {}))
            tagged_win_classes = {
                w.window_class for w in self.tagged.get(tag, {})
            }
            if not tagged_win_classes & subtagged_class_set:
                self.run_prog(tag, subtag)
            else:
                idx = 0
                self.focus_next(tag, idx, subtagged=True)

    def add_prop(self, tag_to_add: str, prop_str: str) -> None:
        """ Add property via [prop_str] to the target [tag].

        Args:
            tag (str): denotes the target tag.
            prop_str (str): string in i3-match format used to add/delete
                            target window in/from scratchpad.
        """
        if tag_to_add in self.cfg:
            self.add_props(tag_to_add, prop_str)

        for tag in self.cfg:
            if tag != tag_to_add:
                self.del_props(tag, prop_str)

        self.initialize(self.i3ipc)

    def del_prop(self, tag: str, prop_str: str) -> None:
        """ Delete property via [prop_str] to the target [tag].

            Args:
                tag (str): denotes the target tag.
                prop_str (str): string in i3-match format used to add/delete
                                target window in/from scratchpad.
        """
        self.del_props(tag, prop_str)

    def find_acceptable_windows(self, tag: str) -> None:
        """ Wrapper over Matcher.match to find acceptable windows and add it to
            tagged[tag] list.

            Args:
                tag (str): denotes the target tag.
        """
        for win in self.winlist:
            if self.match(win, tag):
                self.tagged.get(tag, {}).append(win)

    def tag_windows(self, invalidate_winlist=True) -> None:
        """ Find acceptable windows for the all tags and add it to the
            tagged[tag] list.

            Args:
                tag (str): denotes the target tag.
        """
        if invalidate_winlist:
            self.winlist = self.i3ipc.get_tree().leaves()
        self.tagged = {}

        for tag in self.cfg:
            self.tagged[tag] = []
            self.find_acceptable_windows(tag)

    def sort_by_parent(self, tag: str) -> None:
        """
            Sort windows by some infernal logic: At first sort by parent
            container order, than in any order.

            Args:
                tag (str): target tag to sort.
        """
        i = 0

        try:
            for tagged_win in self.tagged[tag]:
                for container_win in tagged_win.parent:
                    if container_win in self.tagged[tag]:
                        oldidx = self.tagged[tag].index(container_win)
                        self.tagged[tag].insert(
                            i, self.tagged[tag].pop(oldidx)
                        )
                        i += 1
        except TypeError:
            pass

    def add_wins(self, _, event) -> None:
        """ Tag window if it is match defined rules.

            Args:
                _: i3ipc connection.
                event: i3ipc event. We can extract window from it using
                event.container.
        """
        win = event.container
        for tag in self.cfg:
            if self.match(win, tag):
                self.tagged[tag].append(win)
        self.win = win

    def del_wins(self, _, event) -> None:
        """ Delete tag from window if it's closed.

            Args:
                _: i3ipc connection.
                event: i3ipc event. We can extract window from it using
                event.container.
        """
        win_con = event.container
        for tag in self.cfg:
            if self.match(win_con, tag):
                for win in self.tagged[tag]:
                    if win.id in self.restore_fullscreen:
                        self.restore_fullscreen.remove(win.id)

        for tag in self.cfg:
            for win in self.tagged[tag]:
                if win.id == win_con.id:
                    self.tagged[tag].remove(win)
        self.subtag_info = {}

    def set_curr_win(self, _, event) -> None:
        """ Cache the current window.

            Args:
                _: i3ipc connection.
                event: i3ipc event. We can extract window from it using
                event.container.
        """
        self.current_win = event.container

    def handle_fullscreen(self, _, event) -> None:
        """ Performs actions over the restore_fullscreen list.

            This function memorize the current state of the fullscreen property
            of windows for the future reuse it in functions which need to
            set/unset fullscreen state of the window correctly.

            Args:
                _: i3ipc connection.
                event: i3ipc event. We can extract window from it using
                event.container.
        """
        win = event.container
        self.fullscreened = self.i3ipc.get_tree().find_fullscreen()
        if self.need_handle_fullscreen:
            if win.fullscreen_mode:
                if win.id not in self.restore_fullscreen:
                    self.restore_fullscreen.append(win.id)
                    return
            if not win.fullscreen_mode:
                if win.id in self.restore_fullscreen:
                    self.restore_fullscreen.remove(win.id)
                    return