vincentbernat.i3wm-configuration/bin/xsecurelock-saver

#!/usr/bin/python3

"""Saver module for xsecurelock.

It displays a background image, clock and weather. Configuration is
done through environment variables:

 - XSECURELOCK_SAVER_IMAGE: path to the background image to use
 - XSECURELOCK_SAVER_WEATHER: path to weather text
 - XSECURELOCK_SAVER_FONT: font family to use to display clock and weather
 - XSECURELOCK_SAVER_CLOCK_FONT_SIZE: font size to use to display clock
 - XSECURELOCK_SAVER_WEATHER_FONT_SIZE: font size to use to display weather

"""

# In case I want to put a video instead of an image:
# https://gist.github.com/NBonaparte/89fb1b645c99470bc0f6. Check
# `bin/wallpaper' for some sources.

import os
import types
import datetime
import re
import socket
import time
import cairo
import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk, GdkX11, GLib, GdkPixbuf, Gio


def on_win_realize(widget, ctx):
    """On realization, embed into XSCREENSAVER_WINDOW and remember parent position."""
    parent_wid = int(os.getenv("XSCREENSAVER_WINDOW", 0))
    if not parent_wid:
        return
    parent = GdkX11.X11Window.foreign_new_for_display(widget.get_display(), parent_wid)
    x, y, w, h = parent.get_geometry()
    ctx.position = x, y
    window = widget.get_window()
    window.resize(w, h)
    window.reparent(parent, 0, 0)


def on_win_draw(widget, cctx, ctx):
    """Draw background image."""
    x, y = ctx.position
    wwidth, wheight = widget.get_size()
    scale = widget.get_scale_factor()
    bg = None

    if ctx.background:
        bg = ctx.background.new_subpixbuf(
            x * scale, y * scale, wwidth * scale, wheight * scale
        )

    cctx.set_operator(cairo.OPERATOR_SOURCE)
    if not bg:
        cctx.set_source_rgba(0, 0, 0, 1)
        cctx.paint()
        return

    cctx.save()
    cctx.scale(1 / scale, 1 / scale)
    Gdk.cairo_set_source_pixbuf(cctx, bg, 0, 0)
    cctx.paint()
    cctx.restore()


def on_overlay_draw(widget, cctx, ctx):
    """Draw overlay (clock and weather)."""
    if not ctx.leader:
        return
    wwidth, wheight = widget.get_parent().get_size()
    cctx.set_operator(cairo.OPERATOR_OVER)

    def draw(what):
        x, y = cctx.get_current_point()
        cctx.set_source_rgba(0, 0, 0, 0.3)
        cctx.move_to(x + 2, y + 2)
        cctx.show_text(what)
        cctx.set_source_rgb(1, 1, 1)
        cctx.move_to(x, y)
        cctx.show_text(what)

    # Clock
    if ctx.clock:
        time, date = ctx.clock

        # Time
        cctx.select_font_face(
            ctx.font_family, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD
        )
        cctx.set_font_size(ctx.clock_font_size)
        _, _, twidth, theight, _, _ = cctx.text_extents(re.sub(r"\d", "8", time))
        cctx.move_to(wwidth // 2 - twidth // 2, wheight // 3)
        draw(time)

        # Date
        cctx.select_font_face(
            ctx.font_family, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL
        )
        cctx.set_font_size(ctx.clock_font_size // 3)
        _, _, twidth, theight, _, _ = cctx.text_extents(date)
        cctx.move_to(wwidth // 2 - twidth // 2, wheight // 3 + theight * 1.5)
        draw(date)

    # Weather
    # We can have polybar markups in it. We assume %{Tx} means to use
    # Weather Icons and we ignore font color change. The parsing is
    # quite basic.
    if ctx.weather:
        data = re.sub(r"%{F[#\da-f+-]+?}", "", ctx.weather)
        data = re.split(r"(%{T[1-9-]})", data)
        font = ctx.font_family
        cctx.move_to(20, wheight - 20)
        for chunk in data:
            if chunk == "%{T-}":
                font = ctx.font_family
                continue
            elif chunk.startswith("%{T"):
                font = ctx.weather_font_family
                continue
            elif not chunk:
                continue
            cctx.select_font_face(
                font, cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL
            )
            cctx.set_font_size(ctx.weather_font_size)
            draw(chunk)


def on_background_change(monitor, f1, f2, event, ctx):
    """Update background when changed."""
    if event not in (
        Gio.FileMonitorEvent.CHANGES_DONE_HINT,
        Gio.FileMonitorEvent.RENAMED,
    ):
        return
    try:
        new_background = GdkPixbuf.Pixbuf.new_from_file(ctx.background_image)
    except Exception:
        return
    ctx.background = new_background
    ctx.window.queue_draw()


def on_clock_change(ctx):
    """Clock may have changed. Update it.

    We are checking more often than once a minute because we want to
    update the clock swiftly after suspend. An alternative would be to
    listen to PrepareForSleep signal from org.freedesktop.login1, but
    this is more complex.

    """
    now = datetime.datetime.now()
    new_clock = now.strftime("%H:%M")
    if new_clock != ctx.clock:
        ctx.clock = (new_clock, now.strftime("%A %-d %B"))
        ctx.overlay.queue_draw()
    if ctx.leader is None:
        # Do leader "election"
        if ctx.position != (0, 0):
            time.sleep(0.2)
        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        try:
            s.bind("\0xsecurelock-saver")
        except OSError:
            ctx.leader = False
        else:
            ctx.leader = s
    if ctx.leader:
        GLib.timeout_add(min(60 - now.second, 3) * 1000, on_clock_change, ctx)


def on_weather_change(monitor, f1, f2, event, ctx):
    """Weather file has changed."""
    if event not in (
        Gio.FileMonitorEvent.CHANGES_DONE_HINT,
        Gio.FileMonitorEvent.RENAMED,
    ):
        return
    try:
        with open(ctx.weather_file) as wfile:
            ctx.weather = wfile.read()
        ctx.overlay.queue_draw()
    except Exception:
        pass


if __name__ == "__main__":
    ctx = types.SimpleNamespace()
    ctx.background_image = os.getenv("XSECURELOCK_SAVER_IMAGE", None)
    ctx.clock_font_size = int(os.getenv("XSECURELOCK_SAVER_CLOCK_FONT_SIZE", 120))
    ctx.weather_font_size = int(os.getenv("XSECURELOCK_SAVER_CLOCK_FONT_SIZE", 40))
    ctx.weather_file = os.getenv("XSECURELOCK_SAVER_WEATHER", None)
    ctx.font_family = os.getenv("XSECURELOCK_SAVER_FONT", "Iosevka Aile")
    ctx.weather_font_family = os.getenv(
        "XSECURELOCK_SAVER_WEATHER_FONT_FAMILY", "Weather Icons"
    )
    ctx.background = None
    ctx.weather = None
    ctx.clock = None
    ctx.position = (0, 0)
    ctx.leader = None

    ctx.window = Gtk.Window()
    ctx.window.set_app_paintable(True)
    ctx.window.set_visual(ctx.window.get_screen().get_rgba_visual())
    ctx.window.connect("realize", on_win_realize, ctx)
    ctx.window.connect("draw", on_win_draw, ctx)
    ctx.window.connect("delete-event", Gtk.main_quit)

    ctx.overlay = Gtk.DrawingArea()
    ctx.overlay.connect("draw", on_overlay_draw, ctx)
    ctx.window.add(ctx.overlay)

    gio_event_args = (None, None, None, Gio.FileMonitorEvent.CHANGES_DONE_HINT)
    if ctx.background_image:
        gfile = Gio.File.new_for_path(ctx.background_image)
        monitor1 = gfile.monitor_file(Gio.FileMonitorFlags.WATCH_MOVES, None)
        monitor1.connect("changed", on_background_change, ctx)
        on_background_change(*gio_event_args, ctx)
    if ctx.weather_file:
        gfile = Gio.File.new_for_path(ctx.weather_file)
        monitor2 = gfile.monitor_file(Gio.FileMonitorFlags.WATCH_MOVES, None)
        monitor2.connect("changed", on_weather_change, ctx)
        GLib.timeout_add(1000, on_weather_change, *gio_event_args, ctx)
    GLib.timeout_add(1000, on_clock_change, ctx)

    ctx.window.show_all()

    # Main loop
    Gtk.main()