jpanel.py

# To run this script without installing the library, set GI_TYPELIB_PATH and LD_LIBRARY_PATH to the build/src directory
# GI_TYPELIB_PATH=build/src LD_LIBRARY_PATH=build/src python3 examples/simple-example.py

# For GTK4 Layer Shell to get linked before libwayland-client we must explicitly load it before importing with gi
from ctypes import CDLL
CDLL('libgtk4-layer-shell.so')

import gi
gi.require_version('Gtk', '4.0')
gi.require_version('Gtk4LayerShell', '1.0')

from gi.repository import Gtk, GLib
from gi.repository import Gtk4LayerShell as LayerShell
from datetime import datetime

class Panel:
    def __init__(self, app, edge=LayerShell.Edge.BOTTOM, layer=LayerShell.Layer.TOP, width=400, height=32):
        """
        Initialize a new panel
        
        Args:
            app: GTK Application instance
            edge: Which edge to anchor to (BOTTOM, TOP, LEFT, RIGHT)
            layer: Layer level (TOP, BOTTOM, BACKGROUND, OVERLAY)
            width: Panel width
            height: Panel height
        """
        self.app = app
        self.edge = edge
        self.layer = layer
        self.width = width
        self.height = height
        
        # Create the window
        self.window = Gtk.Window(application=app)
        self.window.set_default_size(width, height)
        
        # Initialize LayerShell
        self._setup_layer_shell()
        
        # Create root container
        self.root_box = Gtk.Box(spacing=4)
        self.window.set_child(self.root_box)
        
        # Store widgets for easy access
        self.widgets = {}
        
    def _setup_layer_shell(self):
        """Configure the layer shell settings"""
        LayerShell.init_for_window(self.window)
        LayerShell.set_layer(self.window, self.layer)
        
        # Anchor to the specified edge
        if self.edge == LayerShell.Edge.BOTTOM:
            LayerShell.set_anchor(self.window, LayerShell.Edge.BOTTOM, True)
            LayerShell.set_anchor(self.window, LayerShell.Edge.LEFT, True)
            LayerShell.set_anchor(self.window, LayerShell.Edge.RIGHT, True)
        elif self.edge == LayerShell.Edge.TOP:
            LayerShell.set_anchor(self.window, LayerShell.Edge.TOP, True)
            LayerShell.set_anchor(self.window, LayerShell.Edge.LEFT, True)
            LayerShell.set_anchor(self.window, LayerShell.Edge.RIGHT, True)
        elif self.edge == LayerShell.Edge.LEFT:
            LayerShell.set_anchor(self.window, LayerShell.Edge.LEFT, True)
            LayerShell.set_anchor(self.window, LayerShell.Edge.TOP, True)
            LayerShell.set_anchor(self.window, LayerShell.Edge.BOTTOM, True)
        elif self.edge == LayerShell.Edge.RIGHT:
            LayerShell.set_anchor(self.window, LayerShell.Edge.RIGHT, True)
            LayerShell.set_anchor(self.window, LayerShell.Edge.TOP, True)
            LayerShell.set_anchor(self.window, LayerShell.Edge.BOTTOM, True)
            
        LayerShell.auto_exclusive_zone_enable(self.window)
    
    def add_time_widget(self, format_str="%Y-%m-%d %H:%M:%S", update_interval=1000):
        """
        Add a time widget that updates automatically
        
        Args:
            format_str: strftime format string for time display
            update_interval: Update interval in milliseconds
        """
        current_time = datetime.now().strftime(format_str)
        time_label = Gtk.Label(label=current_time)
        
        def update_time():
            current_time = datetime.now().strftime(format_str)
            time_label.set_text(current_time)
            return True
        
        # Set up timer
        GLib.timeout_add(update_interval, update_time)
        
        # Add to panel and store reference
        self.root_box.append(time_label)
        self.widgets['time_label'] = time_label
        
        return time_label
    
    def add_button(self, label, callback=None, name=None):
        """
        Add a button to the panel
        
        Args:
            label: Button text
            callback: Function to call when clicked
            name: Optional name to store widget reference
        """
        button = Gtk.Button(label=label)
        
        if callback:
            button.connect('clicked', callback)
        
        self.root_box.append(button)
        
        if name:
            self.widgets[name] = button
            
        return button
    
    def add_widget(self, widget, name=None):
        """
        Add any GTK widget to the panel
        
        Args:
            widget: GTK widget to add
            name: Optional name to store widget reference
        """
        self.root_box.append(widget)
        
        if name:
            self.widgets[name] = widget
            
        return widget
    
    def get_widget(self, name):
        """Get a stored widget by name"""
        return self.widgets.get(name)
    
    def show(self):
        """Display the panel"""
        self.window.present()
    
    def hide(self):
        """Hide the panel"""
        self.window.hide()
    
    def close(self):
        """Close the panel"""
        self.window.close()

def on_activate(app):
    # Create a bottom panel
    bottom_panel = Panel(app, edge=LayerShell.Edge.BOTTOM)
    
    # Add widgets to the panel
    bottom_panel.add_time_widget()
    bottom_panel.add_button('Close Panel', lambda btn: bottom_panel.close(), 'close_btn')
    
    # Show the panel
    bottom_panel.show()
    
    # Example: Create a second panel at the top (uncomment to test)
    # top_panel = Panel(app, edge=LayerShell.Edge.TOP, height=24)
    # top_panel.add_time_widget(format_str="%H:%M:%S")
    # top_panel.add_button('Top Panel', name='top_btn')
    # top_panel.show()

app = Gtk.Application(application_id='de.janlu.shell.panel.py')
app.connect('activate', on_activate)
app.run(None)