Python script, ASCII text executable
1
"""
2
Panorama panel: traditional desktop panel using Wayland layer-shell
3
protocol.
4
Copyright 2025, roundabout-host.com <vlad@roundabout-host.com>
5
This program is free software: you can redistribute it and/or modify
7
it under the terms of the GNU General Public Licence as published by
8
the Free Software Foundation, either version 3 of the Licence, or
9
(at your option) any later version.
10
This program is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
GNU General Public Licence for more details.
15
You should have received a copy of the GNU General Public Licence
17
along with this program. If not, see <https://www.gnu.org/licenses/>.
18
"""
19
from __future__ import annotations
21
import os
23
import sys
24
import importlib
25
import time
26
import traceback
27
import faulthandler
28
import typing
29
import locale
30
from itertools import accumulate, chain
31
from pathlib import Path
32
import ruamel.yaml as yaml
33
from pywayland.client import Display, EventQueue
34
from pywayland.protocol.wayland.wl_output import WlOutputProxy
35
from pywayland.protocol.wayland import WlRegistry, WlSeat, WlSurface, WlOutput, WlShm
36
from pywayland.protocol.wlr_foreign_toplevel_management_unstable_v1 import (
37
ZwlrForeignToplevelManagerV1,
38
ZwlrForeignToplevelHandleV1
39
)
40
from pywayland.protocol.wlr_screencopy_unstable_v1 import (
41
ZwlrScreencopyManagerV1,
42
ZwlrScreencopyFrameV1
43
)
44
faulthandler.enable()
46
os.environ["GI_TYPELIB_PATH"] = "/usr/local/lib/x86_64-linux-gnu/girepository-1.0"
48
from ctypes import CDLL
50
CDLL('libgtk4-layer-shell.so')
51
import gi
53
gi.require_version("Gtk", "4.0")
54
gi.require_version("Gtk4LayerShell", "1.0")
55
from gi.repository import Gtk, GLib, Gtk4LayerShell, Gdk, Gio, GObject
57
from gi.events import GLibEventLoopPolicy
58
import ctypes
60
from cffi import FFI
61
ffi = FFI()
62
ffi.cdef("""
63
void * gdk_wayland_display_get_wl_display (void * display);
64
void * gdk_wayland_surface_get_wl_surface (void * surface);
65
void * gdk_wayland_monitor_get_wl_output (void * monitor);
66
""")
67
gtk = ffi.dlopen("libgtk-4.so.1")
68
sys.path.insert(0, str((Path(__file__).parent / "shared").resolve()))
70
locale.bindtextdomain("panorama-panel", "locale")
72
locale.textdomain("panorama-panel")
73
locale.setlocale(locale.LC_ALL)
74
_ = locale.gettext
75
import panorama_panel
77
import asyncio
79
asyncio.set_event_loop_policy(GLibEventLoopPolicy())
80
custom_css = """
82
.panel-flash {
83
animation: flash 333ms ease-in-out 0s 2;
84
}
85
@keyframes flash {
87
0% {
88
background-color: initial;
89
}
90
50% {
91
background-color: #ffff0080;
92
}
93
0% {
94
background-color: initial;
95
}
96
}
97
"""
98
css_provider = Gtk.CssProvider()
100
css_provider.load_from_data(custom_css)
101
Gtk.StyleContext.add_provider_for_display(
102
Gdk.Display.get_default(),
103
css_provider,
104
100
105
)
106
@Gtk.Template(filename="panel-configurator.ui")
109
class PanelConfigurator(Gtk.Frame):
110
__gtype_name__ = "PanelConfigurator"
111
panel_size_adjustment: Gtk.Adjustment = Gtk.Template.Child()
113
monitor_number_adjustment: Gtk.Adjustment = Gtk.Template.Child()
114
top_position_radio: Gtk.CheckButton = Gtk.Template.Child()
115
bottom_position_radio: Gtk.CheckButton = Gtk.Template.Child()
116
left_position_radio: Gtk.CheckButton = Gtk.Template.Child()
117
right_position_radio: Gtk.CheckButton = Gtk.Template.Child()
118
autohide_switch: Gtk.Switch = Gtk.Template.Child()
119
def __init__(self, panel: Panel, **kwargs):
121
super().__init__(**kwargs)
122
self.panel = panel
123
self.panel_size_adjustment.set_value(panel.size)
124
match self.panel.position:
126
case Gtk.PositionType.TOP:
127
self.top_position_radio.set_active(True)
128
case Gtk.PositionType.BOTTOM:
129
self.bottom_position_radio.set_active(True)
130
case Gtk.PositionType.LEFT:
131
self.left_position_radio.set_active(True)
132
case Gtk.PositionType.RIGHT:
133
self.right_position_radio.set_active(True)
134
self.top_position_radio.panel_position_target = Gtk.PositionType.TOP
136
self.bottom_position_radio.panel_position_target = Gtk.PositionType.BOTTOM
137
self.left_position_radio.panel_position_target = Gtk.PositionType.LEFT
138
self.right_position_radio.panel_position_target = Gtk.PositionType.RIGHT
139
self.autohide_switch.set_active(self.panel.autohide)
140
@Gtk.Template.Callback()
142
def update_panel_size(self, adjustment: Gtk.Adjustment):
143
if not self.get_root():
144
return
145
self.panel.set_size(int(adjustment.get_value()))
146
self.panel.get_application().save_config()
148
@Gtk.Template.Callback()
150
def toggle_autohide(self, switch: Gtk.Switch, value: bool):
151
if not self.get_root():
152
return
153
self.panel.set_autohide(value, self.panel.hide_time)
154
self.panel.get_application().save_config()
156
@Gtk.Template.Callback()
158
def move_panel(self, button: Gtk.CheckButton):
159
if not self.get_root():
160
return
161
if not button.get_active():
162
return
163
self.panel.set_position(button.panel_position_target)
165
self.update_panel_size(self.panel_size_adjustment)
166
# Make the applets aware of the changed orientation
168
for area in (self.panel.left_area, self.panel.centre_area, self.panel.right_area):
169
applet = area.get_first_child()
170
while applet:
171
applet.set_orientation(self.panel.get_orientation())
172
applet.set_panel_position(self.panel.position)
173
applet.queue_resize()
174
applet = applet.get_next_sibling()
175
self.panel.get_application().save_config()
177
@Gtk.Template.Callback()
179
def move_to_monitor(self, adjustment: Gtk.Adjustment):
180
if not self.get_root():
181
return
182
app: PanoramaPanel = self.get_root().get_application()
183
monitor = app.monitors[int(self.monitor_number_adjustment.get_value())]
184
self.panel.unmap()
185
self.panel.monitor_index = int(self.monitor_number_adjustment.get_value())
186
Gtk4LayerShell.set_monitor(self.panel, monitor)
187
self.panel.show()
188
# Make the applets aware of the changed monitor
190
for area in (self.panel.left_area, self.panel.centre_area, self.panel.right_area):
191
applet = area.get_first_child()
192
while applet:
193
applet.output_changed()
194
applet = applet.get_next_sibling()
195
self.panel.get_application().save_config()
197
PANEL_POSITIONS_HUMAN = {
200
Gtk.PositionType.TOP: "top",
201
Gtk.PositionType.BOTTOM: "bottom",
202
Gtk.PositionType.LEFT: "left",
203
Gtk.PositionType.RIGHT: "right",
204
}
205
@Gtk.Template(filename="panel-manager.ui")
208
class PanelManager(Gtk.Window):
209
__gtype_name__ = "PanelManager"
210
panel_editing_switch: Gtk.Switch = Gtk.Template.Child()
212
panel_stack: Gtk.Stack = Gtk.Template.Child()
213
current_panel: typing.Optional[Panel] = None
214
def __init__(self, application: Gtk.Application, **kwargs):
216
super().__init__(application=application, **kwargs)
217
self.connect("close-request", lambda *args: self.destroy())
219
action_group = Gio.SimpleActionGroup()
221
self.next_panel_action = Gio.SimpleAction(name="next-panel")
223
action_group.add_action(self.next_panel_action)
224
self.next_panel_action.connect("activate", lambda *args: self.panel_stack.set_visible_child(self.panel_stack.get_visible_child().get_next_sibling()))
225
self.previous_panel_action = Gio.SimpleAction(name="previous-panel")
227
action_group.add_action(self.previous_panel_action)
228
self.previous_panel_action.connect("activate", lambda *args: self.panel_stack.set_visible_child(self.panel_stack.get_visible_child().get_prev_sibling()))
229
self.insert_action_group("win", action_group)
231
if isinstance(self.get_application(), PanoramaPanel):
232
self.panel_editing_switch.set_active(application.edit_mode)
233
self.panel_editing_switch.connect("state-set", self.set_edit_mode)
234
self.connect("close-request", lambda *args: self.unflash_old_panel())
236
self.connect("close-request", lambda *args: self.destroy())
237
if isinstance(self.get_application(), PanoramaPanel):
239
app: PanoramaPanel = self.get_application()
240
for panel in app.panels:
241
configurator = PanelConfigurator(panel)
242
self.panel_stack.add_child(configurator)
243
configurator.monitor_number_adjustment.set_upper(len(app.monitors))
244
self.panel_stack.set_visible_child(self.panel_stack.get_first_child())
246
self.panel_stack.connect("notify::visible-child", self.set_visible_panel)
247
self.panel_stack.notify("visible-child")
248
def unflash_old_panel(self):
250
if self.current_panel:
251
for area in (self.current_panel.left_area, self.current_panel.centre_area, self.current_panel.right_area):
252
area.unflash()
253
def set_visible_panel(self, stack: Gtk.Stack, pspec: GObject.ParamSpec):
255
self.unflash_old_panel()
256
panel: Panel = stack.get_visible_child().panel
258
self.current_panel = panel
260
self.next_panel_action.set_enabled(stack.get_visible_child().get_next_sibling() is not None)
261
self.previous_panel_action.set_enabled(stack.get_visible_child().get_prev_sibling() is not None)
262
# Start an animation to show the user what panel is being edited
264
for area in (panel.left_area, panel.centre_area, panel.right_area):
265
area.flash()
266
def set_edit_mode(self, switch, value):
268
if isinstance(self.get_application(), PanoramaPanel):
269
self.get_application().set_edit_mode(value)
270
@Gtk.Template.Callback()
272
def save_settings(self, *args):
273
if isinstance(self.get_application(), PanoramaPanel):
274
self.get_application().save_config()
275
def get_applet_directories():
278
data_home = Path(os.getenv("XDG_DATA_HOME", Path.home() / ".local" / "share"))
279
data_dirs = [Path(d) for d in os.getenv("XDG_DATA_DIRS", "/usr/local/share:/usr/share").split(":")]
280
all_paths = [data_home / "panorama-panel" / "applets"] + [d / "panorama-panel" / "applets" for d in data_dirs]
282
return [d for d in all_paths if d.is_dir()]
283
def get_config_file():
286
config_home = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
287
return config_home / "panorama-panel" / "config.yaml"
289
class AppletArea(Gtk.Box):
292
def __init__(self, orientation=Gtk.Orientation.HORIZONTAL):
293
super().__init__()
294
self.drop_target = Gtk.DropTarget.new(GObject.TYPE_UINT64, Gdk.DragAction.MOVE)
296
self.drop_target.set_gtypes([GObject.TYPE_UINT64])
297
self.drop_target.connect("drop", self.drop_applet)
298
def drop_applet(self, drop_target: Gtk.DropTarget, value: int, x: float, y: float):
300
applet = self.get_root().get_application().drags[value]
301
old_area: AppletArea = applet.get_parent()
302
old_area.remove(applet)
303
# Find the position where to insert the applet
304
child = self.get_first_child()
305
while child:
306
allocation = child.get_allocation()
307
child_x, child_y = self.translate_coordinates(self, 0, 0)
308
if self.get_orientation() == Gtk.Orientation.HORIZONTAL:
309
midpoint = child_x + allocation.width / 2
310
if x < midpoint:
311
applet.insert_before(self, child)
312
break
313
elif self.get_orientation() == Gtk.Orientation.VERTICAL:
314
midpoint = child_y + allocation.height / 2
315
if y < midpoint:
316
applet.insert_before(self, child)
317
break
318
child = child.get_next_sibling()
319
else:
320
self.append(applet)
321
applet.show()
322
self.get_root().get_application().drags.pop(value)
324
self.get_root().get_application().save_config()
325
return True
327
def set_edit_mode(self, value):
329
panel: Panel = self.get_root()
330
child = self.get_first_child()
331
while child is not None:
332
if value:
333
child.make_draggable()
334
else:
335
child.restore_drag()
336
child.set_opacity(0.75 if value else 1)
337
child = child.get_next_sibling()
338
if value:
340
self.add_controller(self.drop_target)
341
if panel.get_orientation() == Gtk.Orientation.HORIZONTAL:
342
self.set_size_request(48, 0)
343
elif panel.get_orientation() == Gtk.Orientation.VERTICAL:
344
self.set_size_request(0, 48)
345
else:
346
self.remove_controller(self.drop_target)
347
self.set_size_request(0, 0)
348
def flash(self):
350
self.add_css_class("panel-flash")
351
def unflash(self):
353
self.remove_css_class("panel-flash")
354
POSITION_TO_LAYER_SHELL_EDGE = {
357
Gtk.PositionType.TOP: Gtk4LayerShell.Edge.TOP,
358
Gtk.PositionType.BOTTOM: Gtk4LayerShell.Edge.BOTTOM,
359
Gtk.PositionType.LEFT: Gtk4LayerShell.Edge.LEFT,
360
Gtk.PositionType.RIGHT: Gtk4LayerShell.Edge.RIGHT,
361
}
362
class Panel(Gtk.Window):
365
def __init__(self, application: Gtk.Application, monitor: Gdk.Monitor, position: Gtk.PositionType = Gtk.PositionType.TOP, size: int = 40, autohide: bool = False, hide_time: int = 0, can_capture_keyboard: bool = False):
366
super().__init__(application=application)
367
self.drop_motion_controller = None
368
self.motion_controller = None
369
self.set_decorated(False)
370
self.position = None
371
self.autohide = None
372
self.monitor_name = monitor.get_connector()
373
self.hide_time = None
374
self.monitor_index = 0
375
self.can_capture_keyboard = can_capture_keyboard
376
self.open_popovers: set[int] = set()
377
self.add_css_class("panorama-panel")
379
Gtk4LayerShell.init_for_window(self)
381
Gtk4LayerShell.set_namespace(self, "com.roundabout_host.panorama.panel")
382
Gtk4LayerShell.set_monitor(self, monitor)
383
Gtk4LayerShell.set_layer(self, Gtk4LayerShell.Layer.TOP)
385
if can_capture_keyboard:
386
Gtk4LayerShell.set_keyboard_mode(self, Gtk4LayerShell.KeyboardMode.ON_DEMAND)
387
else:
388
Gtk4LayerShell.set_keyboard_mode(self, Gtk4LayerShell.KeyboardMode.NONE)
389
box = Gtk.CenterBox()
391
self.left_area = AppletArea(orientation=box.get_orientation())
393
self.centre_area = AppletArea(orientation=box.get_orientation())
394
self.right_area = AppletArea(orientation=box.get_orientation())
395
box.set_start_widget(self.left_area)
397
box.set_center_widget(self.centre_area)
398
box.set_end_widget(self.right_area)
399
self.set_child(box)
401
self.set_position(position)
402
self.set_size(size)
403
self.set_autohide(autohide, hide_time)
404
# Add a context menu
406
menu = Gio.Menu()
407
menu.append(_("Open _manager"), "panel.manager")
409
self.context_menu = Gtk.PopoverMenu.new_from_model(menu)
411
self.context_menu.set_has_arrow(False)
412
self.context_menu.set_parent(self)
413
self.context_menu.set_halign(Gtk.Align.START)
414
self.context_menu.set_flags(Gtk.PopoverMenuFlags.NESTED)
415
panorama_panel.track_popover(self.context_menu)
416
right_click_controller = Gtk.GestureClick()
418
right_click_controller.set_button(3)
419
right_click_controller.connect("pressed", self.show_context_menu)
420
self.add_controller(right_click_controller)
422
action_group = Gio.SimpleActionGroup()
424
manager_action = Gio.SimpleAction.new("manager", None)
425
manager_action.connect("activate", self.show_manager)
426
action_group.add_action(manager_action)
427
self.insert_action_group("panel", action_group)
428
def reset_margins(self):
430
for edge in POSITION_TO_LAYER_SHELL_EDGE.values():
431
Gtk4LayerShell.set_margin(self, edge, 0)
432
def set_edit_mode(self, value):
434
for area in (self.left_area, self.centre_area, self.right_area):
435
area.set_edit_mode(value)
436
def show_context_menu(self, gesture, n_presses, x, y):
438
rect = Gdk.Rectangle()
439
rect.x = int(x)
440
rect.y = int(y)
441
rect.width = 1
442
rect.height = 1
443
self.context_menu.set_pointing_to(rect)
445
self.context_menu.popup()
446
def slide_in(self):
448
if not self.autohide:
449
Gtk4LayerShell.set_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position], 0)
450
return False
451
if Gtk4LayerShell.get_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position]) >= 0:
453
return False
454
Gtk4LayerShell.set_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position], Gtk4LayerShell.get_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position]) + 1)
456
return True
457
def slide_out(self):
459
if not self.autohide:
460
Gtk4LayerShell.set_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position], 0)
461
return False
462
if Gtk4LayerShell.get_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position]) <= 1 - self.size:
464
return False
465
Gtk4LayerShell.set_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position], Gtk4LayerShell.get_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position]) - 1)
467
return True
468
def show_manager(self, _0=None, _1=None):
470
if self.get_application():
471
if not self.get_application().manager_window:
472
self.get_application().manager_window = PanelManager(self.get_application())
473
self.get_application().manager_window.connect("close-request", self.get_application().reset_manager_window)
474
self.get_application().manager_window.present()
475
def get_orientation(self):
477
box = self.get_first_child()
478
return box.get_orientation()
479
def set_size(self, value: int):
481
self.size = int(value)
482
if self.get_orientation() == Gtk.Orientation.HORIZONTAL:
483
self.set_size_request(800, self.size)
484
self.set_default_size(800, self.size)
485
else:
486
self.set_size_request(self.size, 600)
487
self.set_default_size(self.size, 600)
488
def set_position(self, position: Gtk.PositionType):
490
self.position = position
491
self.reset_margins()
492
match self.position:
493
case Gtk.PositionType.TOP:
494
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.BOTTOM, False)
495
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.TOP, True)
496
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.LEFT, True)
497
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.RIGHT, True)
498
case Gtk.PositionType.BOTTOM:
499
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.TOP, False)
500
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.BOTTOM, True)
501
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.LEFT, True)
502
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.RIGHT, True)
503
case Gtk.PositionType.LEFT:
504
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.RIGHT, False)
505
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.LEFT, True)
506
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.TOP, True)
507
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.BOTTOM, True)
508
case Gtk.PositionType.RIGHT:
509
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.LEFT, False)
510
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.RIGHT, True)
511
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.TOP, True)
512
Gtk4LayerShell.set_anchor(self, Gtk4LayerShell.Edge.BOTTOM, True)
513
box = self.get_first_child()
514
match self.position:
515
case Gtk.PositionType.TOP | Gtk.PositionType.BOTTOM:
516
box.set_orientation(Gtk.Orientation.HORIZONTAL)
517
for area in (self.left_area, self.centre_area, self.right_area):
518
area.set_orientation(Gtk.Orientation.HORIZONTAL)
519
case Gtk.PositionType.LEFT | Gtk.PositionType.RIGHT:
520
box.set_orientation(Gtk.Orientation.VERTICAL)
521
for area in (self.left_area, self.centre_area, self.right_area):
522
area.set_orientation(Gtk.Orientation.VERTICAL)
523
if self.autohide:
525
if not self.open_popovers:
526
GLib.timeout_add(self.hide_time // (self.size - 1), self.slide_out)
527
def set_autohide(self, autohide: bool, hide_time: int):
529
self.autohide = autohide
530
self.hide_time = hide_time
531
if not self.autohide:
532
self.reset_margins()
533
Gtk4LayerShell.auto_exclusive_zone_enable(self)
534
if self.motion_controller is not None:
535
self.remove_controller(self.motion_controller)
536
if self.drop_motion_controller is not None:
537
self.remove_controller(self.drop_motion_controller)
538
self.motion_controller = None
539
self.drop_motion_controller = None
540
self.reset_margins()
541
else:
542
Gtk4LayerShell.set_exclusive_zone(self, 0)
543
# Only leave 1px of the window as a "mouse sensor"
544
Gtk4LayerShell.set_margin(self, POSITION_TO_LAYER_SHELL_EDGE[self.position], 1 - self.size)
545
self.motion_controller = Gtk.EventControllerMotion()
546
self.add_controller(self.motion_controller)
547
self.drop_motion_controller = Gtk.DropControllerMotion()
548
self.add_controller(self.drop_motion_controller)
549
self.motion_controller.connect("enter", lambda *args: GLib.timeout_add(self.hide_time // (self.size - 1), self.slide_in))
551
self.drop_motion_controller.connect("enter", lambda *args: GLib.timeout_add(self.hide_time // (self.size - 1), self.slide_in))
552
self.motion_controller.connect("leave", lambda *args: not self.open_popovers and GLib.timeout_add(self.hide_time // (self.size - 1), self.slide_out))
553
self.drop_motion_controller.connect("leave", lambda *args: not self.open_popovers and GLib.timeout_add(self.hide_time // (self.size - 1), self.slide_out))
554
def wl_output_enter(self, output, name):
556
for area in (self.left_area, self.centre_area, self.right_area):
557
applet = area.get_first_child()
558
while applet:
559
applet.wl_output_enter(output, name)
560
applet = applet.get_next_sibling()
561
def foreign_toplevel_new(self, manager, toplevel):
563
for area in (self.left_area, self.centre_area, self.right_area):
564
applet = area.get_first_child()
565
while applet:
566
applet.foreign_toplevel_new(manager, toplevel)
567
applet = applet.get_next_sibling()
568
def foreign_toplevel_output_enter(self, toplevel, output):
570
for area in (self.left_area, self.centre_area, self.right_area):
571
applet = area.get_first_child()
572
while applet:
573
applet.foreign_toplevel_output_enter(toplevel, output)
574
applet = applet.get_next_sibling()
575
def foreign_toplevel_output_leave(self, toplevel, output):
577
for area in (self.left_area, self.centre_area, self.right_area):
578
applet = area.get_first_child()
579
while applet:
580
applet.foreign_toplevel_output_leave(toplevel, output)
581
applet = applet.get_next_sibling()
582
def foreign_toplevel_app_id(self, toplevel, app_id):
584
for area in (self.left_area, self.centre_area, self.right_area):
585
applet = area.get_first_child()
586
while applet:
587
applet.foreign_toplevel_app_id(toplevel, app_id)
588
applet = applet.get_next_sibling()
589
def foreign_toplevel_title(self, toplevel, title):
591
for area in (self.left_area, self.centre_area, self.right_area):
592
applet = area.get_first_child()
593
while applet:
594
applet.foreign_toplevel_title(toplevel, title)
595
applet = applet.get_next_sibling()
596
def foreign_toplevel_state(self, toplevel, state):
598
for area in (self.left_area, self.centre_area, self.right_area):
599
applet = area.get_first_child()
600
while applet:
601
applet.foreign_toplevel_state(toplevel, state)
602
applet = applet.get_next_sibling()
603
def foreign_toplevel_closed(self, toplevel):
605
for area in (self.left_area, self.centre_area, self.right_area):
606
applet = area.get_first_child()
607
while applet:
608
applet.foreign_toplevel_closed(toplevel)
609
applet = applet.get_next_sibling()
610
def foreign_toplevel_refresh(self):
612
for area in (self.left_area, self.centre_area, self.right_area):
613
applet = area.get_first_child()
614
while applet:
615
applet.foreign_toplevel_refresh()
616
applet = applet.get_next_sibling()
617
def get_all_subclasses(klass: type) -> list[type]:
620
subclasses = []
621
for subclass in klass.__subclasses__():
622
subclasses.append(subclass)
623
subclasses += get_all_subclasses(subclass)
624
return subclasses
626
def load_packages_from_dir(dir_path: Path):
628
loaded_modules = []
629
for path in dir_path.iterdir():
631
if path.name.startswith("_"):
632
continue
633
if path.is_dir() and (path / "__init__.py").exists():
635
try:
636
module_name = path.name
637
spec = importlib.util.spec_from_file_location(module_name, path / "__init__.py")
638
module = importlib.util.module_from_spec(spec)
639
spec.loader.exec_module(module)
640
loaded_modules.append(module)
641
except Exception as e:
642
print(f"Failed to load applet module {path.name}: {e}", file=sys.stderr)
643
else:
644
continue
645
return loaded_modules
647
PANEL_POSITIONS = {
650
"top": Gtk.PositionType.TOP,
651
"bottom": Gtk.PositionType.BOTTOM,
652
"left": Gtk.PositionType.LEFT,
653
"right": Gtk.PositionType.RIGHT,
654
}
655
PANEL_POSITIONS_REVERSE = {
658
Gtk.PositionType.TOP: "top",
659
Gtk.PositionType.BOTTOM: "bottom",
660
Gtk.PositionType.LEFT: "left",
661
Gtk.PositionType.RIGHT: "right",
662
}
663
class PanoramaPanel(Gtk.Application):
666
def __init__(self):
667
super().__init__(
668
application_id="com.roundabout_host.roundabout.PanoramaPanel",
669
flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE
670
)
671
self.display = Gdk.Display.get_default()
672
self.monitors = self.display.get_monitors()
673
self.applets_by_name: dict[str, panorama_panel.Applet] = {}
674
self.panels: list[Panel] = []
675
self.wl_globals = []
676
self.wl_display = None
677
self.wl_seat = None
678
self.wl_shm = None
679
self.foreign_toplevel_manager = None
680
self.screencopy_manager = None
681
self.manager_window = None
682
self.edit_mode = False
683
self.output_proxies = []
684
self.drags = {}
685
self.wl_output_ids = set()
686
self.started = False
687
self.add_main_option(
689
"trigger",
690
ord("t"),
691
GLib.OptionFlags.NONE,
692
GLib.OptionArg.STRING,
693
_("Trigger an action which can be processed by the applets"),
694
_("NAME")
695
)
696
def on_new_toplevel(self, manager: ZwlrForeignToplevelManagerV1,
698
handle: ZwlrForeignToplevelHandleV1):
699
for panel in self.panels:
700
panel.foreign_toplevel_new(manager, handle)
701
handle.dispatcher["title"] = self.on_title_changed
702
handle.dispatcher["app_id"] = self.on_app_id_changed
703
handle.dispatcher["output_enter"] = self.on_output_enter
704
handle.dispatcher["output_leave"] = self.on_output_leave
705
handle.dispatcher["state"] = self.on_state_changed
706
handle.dispatcher["closed"] = self.on_closed
707
def on_output_enter(self, handle, output):
709
for panel in self.panels:
710
panel.foreign_toplevel_output_enter(handle, output)
711
def on_output_leave(self, handle, output):
713
for panel in self.panels:
714
panel.foreign_toplevel_output_leave(handle, output)
715
def on_title_changed(self, handle, title):
717
for panel in self.panels:
718
panel.foreign_toplevel_title(handle, title)
719
def on_app_id_changed(self, handle, app_id):
721
for panel in self.panels:
722
panel.foreign_toplevel_app_id(handle, app_id)
723
def on_state_changed(self, handle, state):
725
for panel in self.panels:
726
panel.foreign_toplevel_state(handle, state)
727
def on_closed(self, handle):
729
for panel in self.panels:
730
panel.foreign_toplevel_closed(handle)
731
def foreign_toplevel_refresh(self):
733
for panel in self.panels:
734
panel.foreign_toplevel_refresh()
735
def receive_output_name(self, output: WlOutput, name: str):
737
output.name = name
738
def idle_proxy_cover(self, output_name):
740
for monitor in self.display.get_monitors():
741
wl_output = gtk.gdk_wayland_monitor_get_wl_output(ffi.cast("void *", ctypes.pythonapi.PyCapsule_GetPointer(monitor.__gpointer__, None)))
742
found = False
743
for proxy in self.output_proxies:
744
if proxy._ptr == wl_output:
745
found = True
746
if wl_output and not found:
747
print("Create proxy")
748
output_proxy = WlOutputProxy(wl_output, self.wl_display)
749
output_proxy.interface.registry[output_proxy._ptr] = output_proxy
750
self.output_proxies.append(output_proxy)
751
def on_global(self, registry, name, interface, version):
753
if interface == "zwlr_foreign_toplevel_manager_v1":
754
self.foreign_toplevel_manager_id = name
755
self.foreign_toplevel_version = version
756
elif interface == "wl_output":
757
output = registry.bind(name, WlOutput, version)
758
output.id = name
759
self.wl_globals.append(output)
760
print(f"global {name} {interface} {version}")
761
output.global_name = name
762
output.name = None
763
output.dispatcher["name"] = self.receive_output_name
764
while not output.name or not self.foreign_toplevel_version:
765
self.wl_display.dispatch(block=True)
766
print(output.name)
767
self.wl_output_ids.add(output.global_name)
768
if not output.name.startswith("live-preview"):
769
self.generate_panels(output.name)
770
for panel in self.panels:
771
panel.wl_output_enter(output, output.name)
772
if not output.name.startswith("live-preview"):
773
if self.foreign_toplevel_manager:
774
self.foreign_toplevel_manager.destroy()
775
self.wl_globals.remove(self.foreign_toplevel_manager)
776
self.foreign_toplevel_refresh()
777
self.foreign_toplevel_manager = self.registry.bind(self.foreign_toplevel_manager_id, ZwlrForeignToplevelManagerV1, self.foreign_toplevel_version)
778
self.foreign_toplevel_manager.id = self.foreign_toplevel_manager_id
779
self.wl_globals.append(self.foreign_toplevel_manager)
780
self.foreign_toplevel_manager.dispatcher["toplevel"] = self.on_new_toplevel
781
self.foreign_toplevel_manager.dispatcher["finished"] = lambda *a: print("Toplevel manager finished")
782
self.wl_display.roundtrip()
783
self.panels_generated = True
784
print(f"Monitor {output.name} ({interface}) connected", file=sys.stderr)
785
elif interface == "wl_seat":
786
self.wl_seat = registry.bind(name, WlSeat, version)
787
self.wl_seat.id = name
788
self.wl_globals.append(self.wl_seat)
789
elif interface == "wl_shm":
790
self.wl_shm = registry.bind(name, WlShm, version)
791
self.wl_shm.id = name
792
self.wl_globals.append(self.wl_shm)
793
elif interface == "zwlr_screencopy_manager_v1":
794
self.screencopy_manager = registry.bind(name, ZwlrScreencopyManagerV1, version)
795
self.screencopy_manager.id = name
796
self.wl_globals.append(self.screencopy_manager)
797
def on_global_remove(self, registry, name):
799
if name in self.wl_output_ids:
800
print(f"Monitor {name} disconnected", file=sys.stderr)
801
self.wl_output_ids.discard(name)
802
for g in self.wl_globals:
803
if g.id == name:
804
g.destroy()
805
self.wl_globals.remove(g)
806
break
807
def generate_panels(self, output_name):
809
print("Generating panels...", file=sys.stderr)
810
self.exit_all_applets()
811
for i, monitor in enumerate(self.monitors):
813
geometry = monitor.get_geometry()
814
print(f"Monitor {i}: {geometry.width}x{geometry.height} at {geometry.x},{geometry.y}")
815
for panel in self.panels:
817
if panel.monitor_name == output_name:
818
panel.destroy()
819
with open(get_config_file(), "r") as config_file:
820
yaml_loader = yaml.YAML(typ="rt")
821
yaml_file = yaml_loader.load(config_file)
822
for panel_data in yaml_file["panels"]:
823
if panel_data["monitor"] != output_name:
824
continue
825
position = PANEL_POSITIONS[panel_data["position"]]
826
my_monitor = None
827
for monitor in self.display.get_monitors():
828
if monitor.get_connector() == panel_data["monitor"]:
829
my_monitor = monitor
830
break
831
if not my_monitor:
832
continue
833
GLib.idle_add(self.idle_proxy_cover, my_monitor.get_connector())
834
size = panel_data["size"]
835
autohide = panel_data["autohide"]
836
hide_time = panel_data["hide_time"]
837
can_capture_keyboard = panel_data["can_capture_keyboard"]
838
panel = Panel(self, my_monitor, position, size, autohide, hide_time, can_capture_keyboard)
840
self.panels.append(panel)
841
print(f"{size}px panel on {position}, autohide is {autohide} ({hide_time}ms)")
843
for area_name, area in (("left", panel.left_area), ("centre", panel.centre_area), ("right", panel.right_area)):
845
applet_list = panel_data["applets"].get(area_name)
846
if applet_list is None:
847
continue
848
for applet in applet_list:
850
item = list(applet.items())[0]
851
AppletClass = self.applets_by_name[item[0]]
852
options = item[1]
853
applet_widget = AppletClass(orientation=panel.get_orientation(), config=options)
854
applet_widget.connect("config-changed", self.save_config)
855
applet_widget.set_panel_position(panel.position)
856
area.append(applet_widget)
858
panel.present()
860
panel.realize()
861
panel.monitor_name = my_monitor.get_connector()
862
def do_startup(self):
864
Gtk.Application.do_startup(self)
865
ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p
867
ctypes.pythonapi.PyCapsule_GetPointer.argtypes = (ctypes.py_object,)
868
all_applets = list(
870
chain.from_iterable(load_packages_from_dir(d) for d in get_applet_directories()))
871
print("Applets:")
872
subclasses = get_all_subclasses(panorama_panel.Applet)
873
for subclass in subclasses:
874
if subclass.__name__ in self.applets_by_name:
875
print(f"Name conflict for applet {subclass.__name__}. Only one will be loaded.",
876
file=sys.stderr)
877
self.applets_by_name[subclass.__name__] = subclass
878
self.wl_display = Display()
880
wl_display_ptr = gtk.gdk_wayland_display_get_wl_display(
881
ffi.cast("void *", ctypes.pythonapi.PyCapsule_GetPointer(self.display.__gpointer__, None)))
882
self.wl_display._ptr = wl_display_ptr
883
self.panels_generated = False
885
self.got_output_name = False
886
self.foreign_toplevel_manager_id = None
887
self.foreign_toplevel_version = None
888
self.idle_proxy_cover(None)
890
self.registry = self.wl_display.get_registry()
891
self.registry.dispatcher["global"] = self.on_global
892
self.registry.dispatcher["global_remove"] = self.on_global_remove
893
self.wl_display.roundtrip()
894
if self.foreign_toplevel_version:
895
print("Foreign Toplevel Interface: Found")
896
else:
897
print("Foreign Toplevel Interface: Not Found")
898
self.hold()
900
def do_activate(self):
902
Gio.Application.do_activate(self)
903
def save_config(self, *args):
905
print("Saving configuration file")
906
with open(get_config_file(), "w") as config_file:
907
yaml_writer = yaml.YAML(typ="rt")
908
data = {"panels": []}
909
for panel in self.panels:
910
panel_data = {
911
"position": PANEL_POSITIONS_REVERSE[panel.position],
912
"monitor": panel.monitor_index,
913
"size": panel.size,
914
"autohide": panel.autohide,
915
"hide_time": panel.hide_time,
916
"can_capture_keyboard": panel.can_capture_keyboard,
917
"applets": {}
918
}
919
for area_name, area in (("left", panel.left_area), ("centre", panel.centre_area), ("right", panel.right_area)):
921
panel_data["applets"][area_name] = []
922
applet = area.get_first_child()
923
while applet is not None:
924
panel_data["applets"][area_name].append({
925
applet.__class__.__name__: applet.get_config(),
926
})
927
applet = applet.get_next_sibling()
929
data["panels"].append(panel_data)
931
yaml_writer.dump(data, config_file)
933
def exit_all_applets(self):
935
for panel in self.panels:
936
for area in (panel.left_area, panel.centre_area, panel.right_area):
937
applet = area.get_first_child()
938
while applet is not None:
939
applet.shutdown(self)
940
applet = applet.get_next_sibling()
942
def do_shutdown(self):
944
print("Shutting down")
945
self.exit_all_applets()
946
Gtk.Application.do_shutdown(self)
947
def do_command_line(self, command_line: Gio.ApplicationCommandLine):
949
options = command_line.get_options_dict()
950
args = command_line.get_arguments()[1:]
951
trigger_variant = options.lookup_value("trigger", GLib.VariantType("s"))
953
if trigger_variant:
954
action_name = trigger_variant.get_string()
955
print(app.list_actions())
956
self.activate_action(action_name, None)
957
print(f"Triggered {action_name}")
958
return 0
960
def set_edit_mode(self, value):
962
self.edit_mode = value
963
for panel in self.panels:
964
panel.set_edit_mode(value)
965
def reset_manager_window(self, *args):
967
self.manager_window = None
968
if __name__ == "__main__":
971
app = PanoramaPanel()
972
app.run(sys.argv)
973