vincentbernat.i3wm-configuration/bin/dimmer

#!/usr/bin/env python3

"""Simple dimmer for xss-lock.

It dim the screen using a provided delay and display a countdown. It
will stop itself when the locker window is mapped.
"""

# It assumes we are using a compositor.

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk, GLib
import cairo
import argparse
import threading
from Xlib import display, X
from Xlib.error import BadWindow
from Xlib.protocol.event import MapNotify


def on_xevent(source, condition, xdisplay, locker):
    while xdisplay.pending_events():
        event = xdisplay.next_event()
        if event.type != X.MapNotify:
            continue
        try:
            wmclass = event.window.get_wm_class()
        except error.BadWindow:
            continue
        if wmclass and wmclass[1] == locker:
            Gtk.main_quit()
            return False
    return True


def on_realize(widget):
    window = widget.get_window()
    window.set_override_redirect(True)


def on_draw(widget, event, options, elapsed):
    def _dim():
        r = cairo.Region(cairo.RectangleInt(0, 0, *widget.get_default_size()))
        dctx = window.begin_draw_frame(r)
        cctx = dctx.get_cairo_context()
        dim(cctx)
        window.end_draw_frame(dctx)

    def dim(cctx, once=False):
        # Background
        delta = options.end_opacity - options.start_opacity
        current = elapsed[0] / options.delay
        opacity = delta * current + options.start_opacity
        cctx.set_source_rgba(0, 0, 0, opacity)
        cctx.set_operator(cairo.OPERATOR_SOURCE)
        cctx.paint()

        # Remaining time
        remaining = str(round(options.delay - elapsed[0]))
        wwidth, wheight = widget.get_default_size()
        cctx.set_source_rgba(1, 1, 1, opacity)
        cctx.select_font_face(
            options.font, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD
        )
        cctx.set_font_size(wheight // 4)
        _, _, twidth, theight, _, _ = cctx.text_extents(remaining)
        cctx.move_to(wwidth // 2 - twidth // 2, wheight // 2 + theight // 2)
        cctx.show_text(remaining)

        # Rearm timer
        if not once:
            elapsed[0] += options.step
            if elapsed[0] <= options.delay:
                GLib.timeout_add(options.step * 1000, _dim)

    window = widget.get_window()
    if not elapsed:
        # First time we are called.
        elapsed.append(0)
        dim(event)
    else:
        # Timers already running, just repaint
        dim(event, once=True)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    add = parser.add_argument
    add("--start-opacity", type=float, default=0.2, help="initial opacity")
    add("--end-opacity", type=float, default=1, help="final opacity")
    add("--step", type=float, default=0.1, help="step for changing opacity")
    add("--delay", type=float, default=10, help="delay from start to end")
    add("--font", default="DejaVu Sans", help="font for countdown")
    add("--locker", default="i3lock", help="quit if window class detected")
    options = parser.parse_args()

    # Setup dimmer windows on each monitor
    gdisplay = Gdk.Display.get_default()
    for i in range(gdisplay.get_n_monitors()):
        geom = gdisplay.get_monitor(i).get_geometry()
        once = []

        window = Gtk.Window()
        window.set_app_paintable(True)
        window.set_type_hint(Gdk.WindowTypeHint.SPLASHSCREEN)
        window.set_visual(window.get_screen().get_rgba_visual())

        window.set_default_size(geom.width, geom.height)
        window.move(geom.x, geom.y)

        window.connect("draw", on_draw, options, [])
        window.connect("delete-event", Gtk.main_quit)
        window.connect("realize", on_realize)

        window.show_all()

    # Watch for locker window
    xdisplay = display.Display()
    root = xdisplay.screen().root
    root.change_attributes(event_mask=X.SubstructureNotifyMask)
    channel = GLib.IOChannel.unix_new(xdisplay.fileno())
    channel.set_encoding(None)
    channel.set_buffered(False)
    GLib.io_add_watch(
        channel,
        GLib.PRIORITY_DEFAULT,
        GLib.IOCondition.IN,
        on_xevent,
        xdisplay,
        options.locker,
    )
    xdisplay.pending_events()  # otherwise, socket is inactive

    # Main loop
    Gtk.main()