Программирование собственного менеджера окон на Python

Расширенные примеры оконного менеджера

Пример 1: Кастомный мозаичный менеджер на PyQt5

Реализация менеджера, который автоматически распределяет дочерние окна по сетке внутри QMdiArea.

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QMdiArea, QMdiSubWindow, QTextEdit
from PyQt5.QtCore import QTimer

class MosaicManager(QMainWindow):
    def __init__(self):
        super().__init__()
        self.mdi = QMdiArea()
        self.setCentralWidget(self.mdi)
        self.setWindowTitle('Мозаичный менеджер')
        self.setGeometry(100, 100, 800, 600)
        # Добавляем несколько окон
        for i in range(6):
            sub = QMdiSubWindow()
            sub.setWidget(QTextEdit(f'Окно {i+1}'))
            sub.setWindowTitle(f'Окно {i+1}')
            self.mdi.addSubWindow(sub)
            sub.show()
        # Таймер для перераспределения
        self.timer = QTimer()
        self.timer.timeout.connect(self.tile_windows)
        self.timer.start(2000)  # каждые 2 секунды

    def tile_windows(self):
        windows = self.mdi.subWindowList()
        if not windows:
            return
        n = len(windows)
        cols = int(n ** 0.5) or 1
        rows = (n + cols - 1) // cols
        width = self.mdi.width() // cols
        height = self.mdi.height() // rows
        for i, win in enumerate(windows):
            row, col = divmod(i, cols)
            win.move(col * width, row * height)
            win.resize(width, height)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MosaicManager()
    window.show()
    sys.exit(app.exec_())

Результат: каждые 2 секунды дочерние окна автоматически выстраиваются в сетку, заполняя все пространство QMdiArea.

Пример 2: Управление окнами с привязкой к границам (tkinter)

Реализация, при которой окна прилипают к краям экрана или друг к другу.

import tkinter as tk

class SnapWindow:
    SNAP_DISTANCE = 20

    def __init__(self, master, title='Snap', width=200, height=150):
        self.master = master
        self.win = tk.Toplevel(master)
        self.win.title(title)
        self.win.geometry(f'{width}x{height}+200+200')
        self.win.bind('', self.start_move)
        self.win.bind('', self.do_move)
        self.win.protocol('WM_DELETE_WINDOW', self.close)
        self._start_x = 0
        self._start_y = 0

    def start_move(self, event):
        self._start_x = event.x
        self._start_y = event.y

    def do_move(self, event):
        x = self.win.winfo_x() + event.x - self._start_x
        y = self.win.winfo_y() + event.y - self._start_y
        # Прилипание к границам
        screen_w = self.win.winfo_screenwidth()
        screen_h = self.win.winfo_screenheight()
        win_w = self.win.winfo_width()
        win_h = self.win.winfo_height()
        if abs(x) < self.SNAP_DISTANCE:
            x = 0
        elif abs(x + win_w - screen_w) < self.SNAP_DISTANCE:
            x = screen_w - win_w
        if abs(y) < self.SNAP_DISTANCE:
            y = 0
        elif abs(y + win_h - screen_h) < self.SNAP_DISTANCE:
            y = screen_h - win_h
        self.win.geometry(f'+{x}+{y}')

    def close(self):
        self.win.destroy()

root = tk.Tk()
root.withdraw()
win1 = SnapWindow(root, 'Окно A')
win2 = SnapWindow(root, 'Окно B', width=250)
root.mainloop()

При перетаскивании окна автоматически прилипают к краям экрана. Расстояние прилипания задаётся константой SNAP_DISTANCE.

Пример 3: Минимальный мозаичный менеджер на python-xlib

Менеджер, размещающий все окна по сетке без перекрытия.

import Xlib
from Xlib.display import Display
from Xlib import X

display = Display()
screen = display.screen()
root = screen.root
root.change_attributes(event_mask=X.SubstructureRedirectMask | X.SubstructureNotifyMask)

window_list = []
cols, rows = 3, 2
tile_width = screen.width_in_pixels // cols
tile_height = screen.height_in_pixels // rows

def tile_window(win, idx):
    col = idx % cols
    row = idx // cols
    win.configure(x=col * tile_width, y=row * tile_height,
                  width=tile_width, height=tile_height, border_width=2)
    display.flush()

while True:
    ev = display.next_event()
    if ev.type == X.MapRequest:
        ev.window.map()
        window_list.append(ev.window)
        tile_window(ev.window, len(window_list) - 1)
    elif ev.type == X.DestroyNotify:
        if ev.window in window_list:
            window_list.remove(ev.window)
            # Переразметка оставшихся окон
            for i, w in enumerate(window_list):
                tile_window(w, i)

Результат: каждое новое окно размещается в следующей ячейке сетки 3x2. При закрытии окна оставшиеся перераспределяются.