renderer.py

#!/usr/bin/python3

import os
import sys
import xml.etree.ElementTree as ET

import gi
gi.require_version('Rsvg', '2.0')
from gi.repository import Rsvg, GLib

import cairo


CACHE_DIR = os.path.expanduser("~/.cache/WindowControls")


def parse_color_to_rgb(color_str):
    if not color_str:
        return None
    if color_str.startswith('shade/'):
        parts = color_str.split('/')
        if len(parts) >= 3:
            base = parts[1].lstrip('#')
            factor = float(parts[2])
            if len(base) == 6:
                r = min(1.0, (int(base[0:2], 16) / 255.0) * factor)
                g = min(1.0, (int(base[2:4], 16) / 255.0) * factor)
                b = min(1.0, (int(base[4:6], 16) / 255.0) * factor)
                return (r, g, b)
    elif color_str.startswith('#'):
        h = color_str.lstrip('#')
        if len(h) == 6:
            return (int(h[0:2], 16) / 255.0,
                    int(h[2:4], 16) / 255.0,
                    int(h[4:6], 16) / 255.0)
    return None


def render_svg_colorized(svg_path, color_rgb, size):
    surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, size, size)
    ctx = cairo.Context(surface)

    handle = Rsvg.Handle.new_from_file(svg_path)
    viewport = Rsvg.Rectangle()
    viewport.x = 0
    viewport.y = 0
    viewport.width = size
    viewport.height = size
    handle.render_document(ctx, viewport)

    if color_rgb:
        ctx.set_operator(cairo.OPERATOR_ATOP)
        ctx.set_source_rgba(color_rgb[0], color_rgb[1], color_rgb[2], 1.0)
        ctx.paint()

    return surface


def composite_layers(layers, size):
    result = cairo.ImageSurface(cairo.FORMAT_ARGB32, size, size)
    ctx = cairo.Context(result)
    for layer in layers:
        ctx.set_source_surface(layer, 0, 0)
        ctx.paint()
    return result


def find_theme_dir(theme_name):
    paths = [
        os.path.expanduser(f"~/.themes/{theme_name}/metacity-1"),
        f"/usr/share/themes/{theme_name}/metacity-1",
        f"/usr/local/share/themes/{theme_name}/metacity-1",
    ]
    for p in paths:
        if os.path.isdir(p):
            return p
    return None


def render_theme(theme_name):
    theme_dir = find_theme_dir(theme_name)
    if not theme_dir:
        print(f"error=Theme not found: {theme_name}", file=sys.stderr)
        return False

    xml_path = None
    for fname in ['metacity-theme-3.xml', 'metacity-theme-2.xml', 'metacity-theme-1.xml']:
        p = os.path.join(theme_dir, fname)
        if os.path.isfile(p):
            xml_path = p
            break

    if not xml_path:
        print("error=No metacity theme XML found", file=sys.stderr)
        return False

    tree = ET.parse(xml_path)
    root = tree.getroot()

    constants = {}
    for c in root.findall('.//constant'):
        constants[c.get('name')] = c.get('value')

    draw_ops = {}
    for ops in root.findall('.//draw_ops'):
        name = ops.get('name', '')
        draw_ops[name] = ops

    os.makedirs(CACHE_DIR, exist_ok=True)

    SIZE = 16

    button_states = {
        ('close', 'normal'):  'close_focused',
        ('close', 'hover'):   'close_focused_prelight',
        ('close', 'active'):  'close_focused_pressed',
        ('maximize', 'normal'):  'maximize_focused',
        ('maximize', 'hover'):   'maximize_focused_prelight',
        ('maximize', 'active'):  'maximize_focused_pressed',
        ('minimize', 'normal'):  'minimize_focused',
        ('minimize', 'hover'):   'minimize_focused_prelight',
        ('minimize', 'active'):  'minimize_focused_pressed',
    }

    for (btn_type, state), ops_name in button_states.items():
        if ops_name not in draw_ops:
            continue

        ops = draw_ops[ops_name]
        layers = []

        for child in ops:
            if child.tag == 'image':
                filename = child.get('filename')
                colorize_const = child.get('colorize')

                svg_path = os.path.join(theme_dir, filename)
                if not os.path.isfile(svg_path):
                    continue

                color_rgb = None
                if colorize_const and colorize_const in constants:
                    color_rgb = parse_color_to_rgb(constants[colorize_const])
                elif colorize_const:
                    color_rgb = parse_color_to_rgb(colorize_const)

                layer = render_svg_colorized(svg_path, color_rgb, SIZE)
                layers.append(layer)

        if layers:
            result = composite_layers(layers, SIZE)
            out_path = os.path.join(CACHE_DIR, f"{btn_type}_{state}.png")
            result.write_to_png(out_path)

    print(f"cache={CACHE_DIR}")
    return True


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: renderer.py <theme_name>", file=sys.stderr)
        sys.exit(1)

    if not render_theme(sys.argv[1]):
        sys.exit(1)