path: root/freedowm.py

#!/usr/bin/env python3.7

import configparser
import os
import sys

from Xlib import X, XK
from Xlib import error
from Xlib.display import Display
from Xlib.ext import randr


class FreedoWM(object):
    def __init__(self):
        """
        Initializes several class-level variables
        """
        self.config = configparser.ConfigParser()
        self.config.read(os.environ['HOME'] + "/.config/freedowm.ini")
        self.general = self.config["GENERAL"]
        self.keys = self.config["KEYMAP"]
        self.colors = self.config["COLORS"]
        self.programs = self.config["PROGRAMS"]
        self.mod = X.Mod1Mask if self.keys["MOD"] == "alt" else X.Mod4Mask

        self.display = Display()
        self.screen = self.display.screen()
        self.root = self.screen.root
        self.event = self.display.next_event()
        self.colormap = self.screen.default_colormap
        self.currently_focused = None
        self.tiling_state = False
        self.tiling_windows = []
        self.start = None
        self.ignore_actions = False
        self.program_stack = []
        self.program_stack_index = -1
        self.monitors = []
        self.monitor_id = self.zero_coordinate = self.x_center = self.y_center = 0

        self.NET_WM_NAME = self.display.intern_atom('_NET_WM_NAME')
        self.NET_ACTIVE_WINDOW = self.display.intern_atom('_NET_ACTIVE_WINDOW')

        self.get_monitors()

    def set_listeners(self):
        """
        Gets executed at program start - sets the initial listener masks
        :return:
        """

        # Listen for window changes
        self.root.change_attributes(
            event_mask=X.PropertyChangeMask | X.FocusChangeMask | X.StructureNotifyMask | X.SubstructureNotifyMask | X.PointerMotionMask
        )

        # Keyboard listener
        self.root.grab_key(X.AnyKey, self.mod, 1, X.GrabModeAsync, X.GrabModeAsync)

        # Button (Mouse) listeners
        self.root.grab_button(X.AnyButton, self.mod, 1,
                              X.ButtonPressMask | X.ButtonReleaseMask | X.PointerMotionMask,
                              X.GrabModeAsync, X.GrabModeAsync, X.NONE, X.NONE)

    def log(self, message):
        """
        Logging utility - only logs when it's enabled in the config
        :param message: The message being logged
        :return:
        """
        if self.general["DEBUG"] != "0":
            print(message)

    def get_monitors(self):
        """
        Gets/sets your monitor setup using the Xlib xrandr helper functions
        :return:
        """
        try:
            window = self.root.create_window(0, 0, 1, 1, 1, self.screen.root_depth)
            res = randr.get_screen_resources(window).outputs

            for i in range(self.display.screen_count() + 1):
                info = randr.get_output_info(window, res[i], 0)
                crtc_info = randr.get_crtc_info(window, info.crtc, 0)
                self.monitors.append({"width": crtc_info.width, "height": crtc_info.height})

            self.log(self.monitors)
            window.destroy()
        except (error.BadWindow, error.BadDrawable):
            self.log("BAD WINDOW OR DRAWABLE!")

    def is_key(self, key_name):
        """
        Checks whether a key has been pressed
        :param key_name: The key that should be checked
        :return:
        """
        return self.event.type == X.KeyPress \
               and self.event.detail == self.display.keysym_to_keycode(XK.string_to_keysym(key_name))

    def window_focused(self):
        """
        Checks whether the pointer hovers a window or the event has a child
        :return:
        """
        return hasattr(self.event, "child") and self.event.child != X.NONE or self.root.query_pointer().child != 0

    def set_border(self, child, color):
        """
        Sets a border to the requested window
        :param child: The requested window child
        :param color: The requested color as string (HEX)
        :return:
        """
        if child is not None and child is not X.NONE:
            border_color = self.colormap.alloc_named_color(color).pixel
            child.configure(border_width=int(self.general["BORDER"]))
            child.change_attributes(None, border_pixel=border_color)

    def center_window(self, window):
        try:
            window.configure(
                width=round(self.monitors[self.monitor_id]["width"] / 2),
                height=round(self.monitors[self.monitor_id]["height"] / 2),
            )

            window.configure(
                x=self.x_center - round(window.get_geometry().width / 2),
                y=self.y_center - round(window.get_geometry().height / 2),
            )
            window.configure(stack_mode=X.Above)
            self.root.warp_pointer(self.x_center, self.y_center)
        except Exception:
            self.log("GPU OVERFLOW!?")

    def update_tiling(self):
        """
        Updated/rearranges the tiling scene
        :return:
        """
        self.log("UPDATE TILING")
        monitor = self.monitors[self.monitor_id]
        count = (len(self.tiling_windows[self.monitor_id]))
        width = 0 if count == 0 else round(monitor["width"] / count)
        for i, child in enumerate(self.root.query_tree().children):
            child.configure(
                stack_mode=X.Above,
                width=width - 2 * int(self.general["BORDER"]),
                height=monitor["height"] - 2 * int(self.general["BORDER"]),
                x=self.zero_coordinate + width * i,
                y=0,
            )
            if child not in self.tiling_windows[self.monitor_id]:
                self.tiling_windows[self.monitor_id].append(child)

    def update_windows(self):
        """
        Handles several window events
        :return:
        """

        # Configure new window
        if self.event.type == X.CreateNotify:
            try:
                if not self.ignore_actions:
                    self.log("NEW WINDOW")
                    window = self.event.window
                    self.program_stack.append(window)
                    self.program_stack_index = len(self.program_stack) - 1
                    if self.tiling_state:
                        self.tiling_windows[self.monitor_id].append(window)
                        self.update_tiling()
                        monitor_width = self.monitors[self.monitor_id]["width"]
                        self.root.warp_pointer(
                            round(self.zero_coordinate + monitor_width -
                                  (monitor_width / len(self.tiling_windows[self.monitor_id]) + 1) / 2),
                            self.y_center
                        )
                    else:
                        self.center_window(window)
            except (error.BadWindow, error.BadDrawable):
                self.log("BAD WINDOW OR DRAWABLE!")

        # Remove closed window from stack
        if self.event.type == X.DestroyNotify:
            try:
                if not self.ignore_actions:
                    self.log("CLOSE WINDOW")
                    if self.event.window in self.program_stack:
                        self.program_stack.remove(self.event.window)
                    if self.tiling_state:
                        self.tiling_windows[self.monitor_id].remove(self.event.window)
                        self.update_tiling()
                    elif len(self.program_stack) > 0:
                        focused_window = self.program_stack[0]
                        focused_window.configure(stack_mode=X.Above)
                        self.root.warp_pointer(
                            round(focused_window.get_geometry().x + focused_window.get_geometry().width / 2),
                            round(focused_window.get_geometry().y + focused_window.get_geometry().height / 2)
                        )
                elif self.ignore_actions:
                    self.ignore_actions = False
            except (error.BadWindow, error.BadDrawable):
                self.log("BAD WINDOW OR DRAWABLE!")

        # Set focused window "in focus"
        if self.window_focused() and not self.ignore_actions:
            if hasattr(self.event, "child") and self.event.child != X.NONE \
                    and self.event.child != self.currently_focused:
                if self.currently_focused is not None:
                    self.log("RESET BORDER")
                    self.set_border(self.currently_focused, self.colors["INACTIVE_BORDER"])
                self.log("FOCUS BORDER")
                self.currently_focused = self.event.child
                self.set_border(self.currently_focused, self.colors["ACTIVE_BORDER"])
                self.currently_focused.configure(stack_mode=X.Above)
                self.program_stack_index = self.program_stack.index(self.currently_focused)
            elif self.root.query_pointer().child not in (self.currently_focused, X.NONE):
                if self.currently_focused is not None:
                    self.log("RESET BORDER")
                    self.set_border(self.currently_focused, self.colors["INACTIVE_BORDER"])
                self.log("FOCUS BORDER")
                self.currently_focused = self.root.query_pointer().child
                self.set_border(self.currently_focused, self.colors["ACTIVE_BORDER"])
                self.currently_focused.configure(stack_mode=X.Above)
                self.program_stack_index = self.program_stack.index(self.currently_focused)

        # Update current monitor
        if self.event.type == X.NotifyPointerRoot:
            self.log("UPDATE MONITOR ID")
            if self.root.query_pointer().root_x > self.monitors[0]["width"]:
                self.monitor_id = 1
                self.zero_coordinate = self.monitors[0]["width"]
                self.x_center = round(self.monitors[1]["width"] / 2 + self.monitors[0]["width"])
                self.y_center = round(self.monitors[1]["height"] / 2)
            else:
                self.monitor_id = 0
                self.x_center = round(self.monitors[0]["width"] / 2)
                self.y_center = round(self.monitors[0]["height"] / 2)

        self.display.sync()

    def main_loop(self):
        """
        Loops until the program is closed - handles keyboard, window and mouse events
        :return:
        """
        self.set_listeners()
        self.root.warp_pointer(0, 0)

        while 1:
            self.event = self.display.next_event()
            self.update_windows()

            # Move window (MOD + left click)
            if self.event.type == X.ButtonPress and self.event.child != X.NONE:
                attribute = self.event.child.get_geometry()
                self.start = self.event

            # Resize window (MOD + right click)
            elif self.event.type == X.MotionNotify and self.start:
                x_diff = self.event.root_x - self.start.root_x
                y_diff = self.event.root_y - self.start.root_y
                self.start.child.configure(
                    width=max(1, attribute.width + (self.start.detail == 3 and x_diff or 0)),
                    height=max(1, attribute.height + (self.start.detail == 3 and y_diff or 0)),
                    x=attribute.x + (self.start.detail == 1 and x_diff or 0),
                    y=attribute.y + (self.start.detail == 1 and y_diff or 0)
                )

            # Cycle between windows (MOD + Tab) // X11's "tab" keysym is 0, but it's 23
            if self.event.type == X.KeyPress and self.event.detail == int(self.keys["CYCLE"]) \
                    and len(self.program_stack) > 0:
                if self.program_stack_index + 1 >= len(self.program_stack):
                    self.program_stack_index = 0
                else:
                    self.program_stack_index += 1
                active_window = self.program_stack[self.program_stack_index]
                active_window.configure(stack_mode=X.Above)
                self.root.warp_pointer(
                    round(active_window.get_geometry().x + active_window.get_geometry().width / 2),
                    round(active_window.get_geometry().y + active_window.get_geometry().height / 2)
                )

            # Toggle tiling state (MOD + T)
            elif self.is_key(self.keys["TILE"]):
                if not self.tiling_state:
                    for i in range(self.display.screen_count() + 1):
                        self.tiling_windows.append([])
                    if self.window_focused():
                        self.tiling_windows[self.monitor_id].append(self.event.child)
                        self.update_tiling()
                        self.tiling_state = True
                else:
                    self.tiling_windows = []
                    self.tiling_state = False

            # Toggle maximization (MOD + M)
            elif self.is_key(self.keys["MAX"]):
                if self.window_focused():
                    full_width = self.monitors[self.monitor_id]["width"] - 2 * int(self.general["BORDER"])
                    full_height = self.monitors[self.monitor_id]["height"] - 2 * int(self.general["BORDER"])

                    if self.event.child.get_geometry().width == full_width \
                            and self.event.child.get_geometry().height == full_height \
                            and self.event.child.get_geometry().x == self.zero_coordinate \
                            and self.event.child.get_geometry().y == 0:
                        self.center_window(self.event.child)
                    else:
                        self.event.child.configure(
                            width=full_width,
                            height=full_height,
                            x=self.zero_coordinate,
                            y=0
                        )

            # Center window (MOD + C)
            elif self.is_key(self.keys["CENTER"]) and self.window_focused():
                self.center_window(self.event.child)

            # Close window (MOD + Q)
            elif self.is_key(self.keys["CLOSE"]) and self.window_focused():
                self.event.child.destroy()

            # Open terminal (MOD + Enter) // X11's "enter" keysym is 0, but it's 36
            elif self.event.type == X.KeyPress and self.event.detail == int(self.keys["TERMINAL"]):
                os.system(self.programs["TERMINAL"] + " &")

            # Open dmenu (MOD + D)
            elif self.is_key(self.keys["MENU"]):
                self.ignore_actions = True
                os.system(self.programs["MENU"] + " &")

            # Exit window manager (MOD + P)
            elif self.is_key(self.keys["QUIT"]):
                self.display.close()
                sys.exit()

            elif self.event.type == X.ButtonRelease:
                self.start = None


FreedoWM = FreedoWM()
try:
    FreedoWM.main_loop()
except Exception as err:
    FreedoWM.log(str(err))