dotfiles/config/lemonbar/pip.py

#!/usr/bin/env python3

"""
Beautiful script
"""

import subprocess
import time
import datetime
import os
import multiprocessing
import i3ipc
import difflib

# Constants
FONT = "DejaVu Sans Mono for Powerline"

# TODO Update to be in sync with base16
thm = [
    "#002b36",
    "#dc322f",
    "#859900",
    "#b58900",
    "#268bd2",
    "#6c71c4",
    "#2aa198",
    "#93a1a1",
    "#657b83",
    "#dc322f",
    "#859900",
    "#b58900",
    "#268bd2",
    "#6c71c4",
    "#2aa198",
    "#fdf6e3",
]
fg = "#93a1a1"
bg = "#002b36"

THEMES = {
    "CENTER": (fg, bg),
    "DEFAULT": (thm[0], thm[8]),
    "1": (thm[0], thm[9]),
    "2": (thm[0], thm[10]),
    "3": (thm[0], thm[11]),
    "4": (thm[0], thm[12]),
    "5": (thm[0], thm[13]),
    "6": (thm[0], thm[14]),
    "7": (thm[0], thm[15]),
}

# Utils


def fitText(text, size):
    """
    Add spaces or cut a string to be `size` characters long
    """
    if size > 0:
        t = len(text)
        if t >= size:
            return text[:size]
        else:
            diff = size - t
            return text + " " * diff
    else:
        return ""


def fgColor(theme):
    global THEMES
    return THEMES[theme][0]


def bgColor(theme):
    global THEMES
    return THEMES[theme][1]


class Section:
    def __init__(self, theme="DEFAULT"):
        self.text = ""
        self.size = 0
        self.toSize = 0
        self.theme = theme
        self.visible = False
        self.name = ""

    def update(self, text):
        if text == "":
            self.toSize = 0
        else:
            if len(text) < len(self.text):
                self.text = text + self.text[len(text) :]
            else:
                self.text = text
            self.toSize = len(text) + 3

    def updateSize(self):
        """
        Set the size for the next frame of animation
        Return if another frame is needed
        """
        if self.toSize > self.size:
            self.size += 1
        elif self.toSize < self.size:
            self.size -= 1
        self.visible = self.size
        return self.toSize == self.size

    def draw(self, left=True, nextTheme="DEFAULT"):
        s = ""
        if self.visible:
            if not left:
                if self.theme == nextTheme:
                    s += ""
                else:
                    s += "%{F" + bgColor(self.theme) + "}"
                    s += "%{B" + bgColor(nextTheme) + "}"
                    s += ""
            s += "%{F" + fgColor(self.theme) + "}"
            s += "%{B" + bgColor(self.theme) + "}"
            s += " " if self.size > 1 else ""
            s += fitText(self.text, self.size - 3)
            s += " " if self.size > 2 else ""
            if left:
                if self.theme == nextTheme:
                    s += ""
                else:
                    s += "%{F" + bgColor(self.theme) + "}"
                    s += "%{B" + bgColor(nextTheme) + "}"
                    s += ""
        return s


# Section definition
sTime = Section("3")

hostname = os.environ["HOSTNAME"].split(".")[0]
sHost = Section("2")
sHost.update(
    os.environ["USER"] + "@" + hostname.split("-")[-1] if "-" in hostname else hostname
)


# Groups definition
gLeft = []
gRight = [sTime, sHost]

# Bar handling
bar = subprocess.Popen(["lemonbar", "-f", FONT, "-b"], stdin=subprocess.PIPE)


def updateBar():
    global timeLastUpdate, timeUpdate
    global gLeft, gRight
    global outputs

    text = ""
    for oi in range(len(outputs)):
        output = outputs[oi]
        gLeftFiltered = list(
            filter(
                lambda s: s.visible and (not s.output or s.output == output.name), gLeft
            )
        )
        tLeft = ""
        l = len(gLeftFiltered)
        for gi in range(l):
            g = gLeftFiltered[gi]
            # Next visible section for transition
            nextTheme = gLeftFiltered[gi + 1].theme if gi + 1 < l else "CENTER"
            tLeft = tLeft + g.draw(True, nextTheme)

        tRight = ""
        for gi in range(len(gRight)):
            g = gRight[gi]
            nextTheme = "CENTER"
            for gn in gRight[gi + 1 :]:
                if gn.visible:
                    nextTheme = gn.theme
                    break
            tRight = g.draw(False, nextTheme) + tRight
        text += (
            "%{l}"
            + tLeft
            + "%{r}"
            + tRight
            + "%{B"
            + bgColor("CENTER")
            + "}"
            + "%{S"
            + str(oi + 1)
            + "}"
        )

    bar.stdin.write(bytes(text + "\n", "utf-8"))
    bar.stdin.flush()


# Values
i3 = i3ipc.Connection()
outputs = []


def on_output():
    global outputs
    outputs = sorted(
        sorted(
            list(filter(lambda o: o.active, i3.get_outputs())), key=lambda o: o.rect.y
        ),
        key=lambda o: o.rect.x,
    )


on_output()


def on_workspace_focus():
    global i3
    global gLeft
    workspaces = i3.get_workspaces()
    wNames = [w.name for w in workspaces]
    sNames = [s.name for s in gLeft]

    newGLeft = []

    def actuate(section, workspace):
        if workspace:
            section.name = workspace.name
            section.output = workspace.output
            if workspace.visible:
                section.update(workspace.name)
            else:
                section.update(workspace.name.split(" ")[0])

            if workspace.focused:
                section.theme = "4"
            elif workspace.urgent:
                section.theme = "1"
            else:
                section.theme = "6"
        else:
            section.update("")
            section.theme = "6"

    for tag, i, j, k, l in difflib.SequenceMatcher(None, sNames, wNames).get_opcodes():
        if tag == "equal":  # If the workspaces didn't changed
            for a in range(j - i):
                workspace = workspaces[k + a]
                section = gLeft[i + a]
                actuate(section, workspace)
                newGLeft.append(section)
        if tag in ("delete", "replace"):  # If the workspaces were removed
            for section in gLeft[i:j]:
                if section.visible:
                    actuate(section, None)
                    newGLeft.append(section)
                else:
                    del section
        if tag in ("insert", "replace"):  # If the workspaces were removed
            for workspace in workspaces[k:l]:
                section = Section()
                actuate(section, workspace)
                newGLeft.append(section)
    gLeft = newGLeft

    updateBar()


on_workspace_focus()


def i3events(i3childPipe):
    global i3

    # Proxy functions
    def on_workspace_focus(i3, e):
        global i3childPipe
        i3childPipe.send("on_workspace_focus")

    i3.on("workspace::focus", on_workspace_focus)

    def on_output(i3, e):
        global i3childPipe
        i3childPipe.send("on_output")

    i3.on("output", on_output)

    i3.main()


i3parentPipe, i3childPipe = multiprocessing.Pipe()
i3process = multiprocessing.Process(target=i3events, args=(i3childPipe,))
i3process.start()


def updateValues():
    # Time
    now = datetime.datetime.now()
    sTime.update(now.strftime("%x %X"))


def updateAnimation():
    for s in set(gLeft + gRight):
        s.updateSize()
    updateBar()


lastUpdate = 0
while True:
    now = time.time()
    if i3parentPipe.poll():
        msg = i3parentPipe.recv()
        if msg == "on_workspace_focus":
            on_workspace_focus()
        elif msg == "on_output":
            on_output()
            # TODO Restart lemonbar
        else:
            print(msg)
    updateAnimation()
    if now >= lastUpdate + 1:
        updateValues()
        lastUpdate = now

    time.sleep(0.05)