"""Führt ein QMenu aus und delegiert sauber, falls QMenu.exec gemockt ist.

if QMenu.exec is not _ORIGINAL_QMENU_EXEC:

return QMenu.exec(menu, pos) if pos is not None else QMenu.exec(menu)

"""Produkt-Profil: mehrere Produkte aus EINEM Code (SoftwareCenter, LaunchBoards).

name: str # Fenstertitel / Tray-Tooltip / Tray-Meldungen

settings_app: str # QSettings-AppName (eigenes Profil je Produkt)

icon_file: str # Icon-Dateiname relativ zum Skript

"""Loest einen mitgelieferten Ressourcenpfad (Icons etc.) robust auf.

base_dir = getattr(sys, "_MEIPASS", None) or os.path.dirname(os.path.abspath(__file__))

"""Einfaches Praefix-Ranking fuer die Tray-Suche: 0=exakt, 1=Praefix, 2=Substring, sonst None."""

text_cf = (text or "").casefold()

if text_cf == query:

return 0

if text_cf.startswith(query):

return 1

if query in text_cf:

return 2

if isinstance(value, str) and value.strip():

try:

loaded = json.loads(value)

except json.JSONDecodeError:

loaded = []

if isinstance(loaded, list):

return loaded

"""Verlaufs-Sortierung: zuletzt geschlossenes Board zuerst, danach aktive Boards.

closed = sorted((b for b in boards if b.get("closed_at")), key=lambda b: b["closed_at"], reverse=True)

active = [b for b in boards if not b.get("closed_at")]

parser = configparser.ConfigParser(interpolation=None, strict=False)

parser.optionxform = str

try:

with open(path, encoding="utf-8") as handle:

parser.read_file(handle)

except (OSError, configparser.Error, UnicodeDecodeError):

return {}

if not parser.has_section("Desktop Entry"):

return {}

entry = read_desktop_entry(path)

if not entry:

return None

for key in ("Name[de_DE]", "Name[de]", "Name"):

value = entry.get(key)

if value:

return value.strip()

entry = read_desktop_entry(path)

icon_name = entry.get("Icon", "").strip()

if not icon_name:

return None

if os.path.isabs(icon_name) and os.path.exists(icon_name):

return QIcon(icon_name)

icon = QIcon.fromTheme(icon_name)

if not icon.isNull():

return icon

entry = read_desktop_entry(path)

exec_line = entry.get("Exec", "").strip()

if not exec_line:

return None

try:

tokens = shlex.split(exec_line, posix=True)

except ValueError:

return None

cleaned = []

for token in tokens:

normalized_token = _sanitize_desktop_exec_token(token)

if normalized_token:

cleaned.append(normalized_token)

if not isinstance(token, str) or not token:

return None

if "%" not in token:

return token

normalized = []

saw_field_code = False

index = 0

while index < len(token):

char = token[index]

if char != "%":

normalized.append(char)

index += 1

continue

if index + 1 >= len(token):

normalized.append(char)

index += 1

continue

code = token[index + 1]

if code == "%":

normalized.append("%")

index += 2

continue

if code in DESKTOP_FIELD_CODES:

saw_field_code = True

index += 2

continue

normalized.append(char)

index += 1

sanitized = "".join(normalized).strip()

if not sanitized:

return None

# SoftwareCenter startet Desktop-Dateien ohne Datei-/URL-Kontext.

# Argumente mit Desktop-Feldcodes werden deshalb komplett verworfen.

if saw_field_code and sanitized != token:

return None

if not isinstance(path, str) or not path.strip():

return False

lower = path.strip().lower()

if not isinstance(path, str) or not path:

return False

if is_web_url(path):

return True

if not isinstance(path, str) or not path:

return False

path = os.path.expandvars(path)

if path.lower().endswith(".exe") and os.path.isfile(path):

return True

if not sys.platform.startswith("win") or not is_windows_shortcut(path):

return None

abs_path = os.path.abspath(path)

target = _resolve_windows_shortcut_target_com(abs_path) or _resolve_windows_shortcut_target_powershell(abs_path)

if not target:

return None

target = os.path.normpath(os.path.expandvars(target.strip().strip('"')))

if is_supported_windows_shortcut_target(target):

return target

try:

import win32com.client # type: ignore[import-not-found]

shell = win32com.client.Dispatch("WScript.Shell")

shortcut = shell.CreateShortcut(path)

target = getattr(shortcut, "TargetPath", "")

except Exception:

return None

env = os.environ.copy()

env["SOFTWARECENTER_SHORTCUT_PATH"] = path

command = (

"$ErrorActionPreference='Stop'; "

"[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; "

"$shortcut=(New-Object -ComObject WScript.Shell)."

"CreateShortcut($env:SOFTWARECENTER_SHORTCUT_PATH); "

"$shortcut.TargetPath"

)

try:

completed = subprocess.run(

["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", command],

capture_output=True,

text=True,

encoding="utf-8",

errors="replace",

env=env,

timeout=5,

creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),

)

except (OSError, subprocess.SubprocessError):

return None

if completed.returncode != 0:

return None

if not isinstance(path, str) or not path:

return ""

if is_web_url(path):

clean = path.strip()

for prefix in ("https://", "http://"):

if clean.lower().startswith(prefix):

clean = clean[len(prefix):]

break

return clean.rstrip("/") or path

name = desktop_entry_display_name(path) if is_linux_desktop_entry(path) else None

if name:

return name

basename = os.path.basename(path.rstrip("\\/"))

label, _ext = os.path.splitext(basename)

if not isinstance(path, str) or not path:

return "unknown"

if is_web_url(path):

return "url"

lower_path = path.lower()

if lower_path.endswith(".url"):

return "url"

if lower_path.endswith(".lnk"):

return "windows_shortcut"

if lower_path.endswith(".app"):

return "mac_app"

if lower_path.endswith(".desktop"):

return "linux_desktop"

if lower_path.endswith((".bat", ".cmd", ".ps1", ".sh", ".py")):

return "script"

if os.path.isdir(path):

return "directory"

if os.path.isfile(path):

return "file"

if isinstance(entry, str):

path = entry.strip()

label = None

kind = None

notes = None

elif isinstance(entry, dict):

raw_path = entry.get("path", "")

# BUGSWEEP-40: Nicht-String-Pfad (z.B. None aus manuell editiertem Profil) -> leer, damit der

# `if not path: return None`-Guard greift; str(None) ergäbe sonst den Literal-String "None".

path = raw_path.strip() if isinstance(raw_path, str) else ""

label = entry.get("label")

kind = entry.get("kind")

notes = entry.get("notes")

else:

return None

if not path:

return None

if label is not None:

label = str(label).strip() or None

if kind is not None:

kind = str(kind).strip() or None

if notes is not None:

notes = str(notes).strip() or None

return {

"path": path,

"label": label or default_entry_label(path),

"kind": kind or detect_entry_kind(path),

"notes": notes,

tabs = []

for index in range(window.tabs.count()):

page = window.tabs.widget(index)

tabs.append(

{

"name": window.tabs.tabText(index),

"view_mode": page.view_mode,

"entries": page.list.get_all_entries(),

}

)

return {

"format": PROFILE_FORMAT,

"format_version": PROFILE_FORMAT_VERSION,

"app_version": __version__,

"source_platform": sys.platform,

"exported_at": iso_now(),

"current_tab": max(window.tabs.currentIndex(), 0),

"tabs": tabs,

if not isinstance(payload, dict):

raise ValueError("Das Profil ist kein JSON-Objekt.")

payload_format = payload.get("format")

payload_version = payload.get("format_version")

if payload_format != PROFILE_FORMAT or payload_version != PROFILE_FORMAT_VERSION:

raise ValueError("Unbekanntes Profilformat.")

raw_tabs = payload.get("tabs")

if not isinstance(raw_tabs, list) or not raw_tabs:

raise ValueError("Das Profil enthält keine Tabs.")

tabs = []

for raw_tab in raw_tabs:

if not isinstance(raw_tab, dict):

continue

name = str(raw_tab.get("name") or "Tab").strip() or "Tab"

view_mode = "list" if str(raw_tab.get("view_mode")).strip().lower() == "list" else "tiles"

entries = []

raw_entries = raw_tab.get("entries", [])

if not isinstance(raw_entries, list):

raw_entries = []

for raw_entry in raw_entries:

normalized = normalize_entry(raw_entry)

if normalized:

entries.append(normalized)

tabs.append({"name": name, "view_mode": view_mode, "entries": entries})

if not tabs:

raise ValueError("Das Profil enthält keine lesbaren Tabs.")

"""Startet eine Datei unter Windows mit gesetztem Arbeitsverzeichnis.

# Python 3.13+: os.startfile akzeptiert cwd direkt.

try:

os.startfile(path, cwd=workdir) # type: ignore[call-arg]

return

except TypeError:

pass # aelteres Python ohne cwd-Parameter -> ShellExecuteW

except OSError:

raise

import ctypes

# ShellExecuteW(hwnd, lpVerb, lpFile, lpParameters, lpDirectory, nShowCmd)

# lpDirectory = Arbeitsverzeichnis (wie "Ausfuehren in" einer Verknuepfung).

rc = ctypes.windll.shell32.ShellExecuteW(None, None, path, None, workdir, 1)

if rc <= 32: # ShellExecute meldet Fehler als Wert <= 32

if is_web_url(path):

try:

if QDesktopServices.openUrl(QUrl(path)):

return

except Exception:

pass

try:

import webbrowser

webbrowser.open(path)

return

except Exception as e:

QMessageBox.critical(None, t("Fehler beim Starten"), f"Konnte nicht starten:\n{path}\n\n{e}")

return

if not os.path.exists(path):

QMessageBox.warning(None, "Datei nicht gefunden", f"Pfad existiert nicht:\n{path}")

return

try:

if sys.platform.startswith("win"):

# Windows: Arbeitsverzeichnis = Ordner der Ziel-Datei (wie "Ausfuehren in"

# einer Verknuepfung), damit Apps ihre Ressourcen relativ zur cwd finden.

workdir = os.path.dirname(os.path.abspath(path)) or None

_startfile_in_dir(path, workdir)

elif sys.platform == "darwin":

subprocess.Popen(["open", path])

else:

if is_linux_desktop_entry(path):

command = desktop_entry_exec_command(path)

if command:

subprocess.Popen(command)

else:

subprocess.Popen(["xdg-open", path])

elif os.access(path, os.X_OK):

subprocess.Popen([path])

else:

subprocess.Popen(["xdg-open", path])

except Exception as e:

"""Liefert den plattformspezifischen Titel für die Dateimanager-Aktion."""

if path and is_web_url(path):

return t("Im Browser öffnen")

if sys.platform.startswith("win"):

return "Im Explorer anzeigen"

elif sys.platform == "darwin":

return "Im Finder anzeigen"

"""Öffnet den Dateimanager (Explorer/Finder/xdg-open) und hebt die Datei hervor."""

if not isinstance(path, str) or not path.strip():

return

if is_web_url(path):

open_file(path)

return

if not os.path.exists(path):

QMessageBox.warning(None, "Datei nicht gefunden", f"Pfad existiert nicht:\n{path}")

return

try:

norm_path = os.path.normpath(os.path.abspath(path))

if sys.platform.startswith("win"):

if os.path.isdir(norm_path):

subprocess.Popen(["explorer", norm_path])

else:

subprocess.Popen(["explorer", f"/select,{norm_path}"])

elif sys.platform == "darwin":

subprocess.Popen(["open", "-R", norm_path])

else:

target_dir = norm_path if os.path.isdir(norm_path) else os.path.dirname(norm_path)

subprocess.Popen(["xdg-open", target_dir])

except Exception as e:

QMessageBox.critical(

None, "Fehler beim Öffnen des Dateimanagers", f"Konnte Dateimanager nicht öffnen:\n{path}\n\n{e}"

"""Dialog zum Bearbeiten von Bezeichnung und Notizen eines Eintrags."""

def __init__(self, entry: dict, parent=None):

super().__init__(parent)

self.setWindowTitle(t("Eintrag bearbeiten"))

self.setAccessibleName(t("Eintrag bearbeiten"))

self.setAccessibleDescription(t("Dialog zum Anpassen von Bezeichnung und Notizen des Eintrags."))

self.setMinimumWidth(440)

layout = QVBoxLayout(self)

form = QFormLayout()

path = entry.get("path") or ""

label = entry.get("label") or ""

notes = entry.get("notes") or ""

self.lbl_path = QLineEdit(path)

self.lbl_path.setReadOnly(True)

self.lbl_path.setAccessibleName(t("Pfad oder Web-Adresse"))

self.lbl_path.setAccessibleDescription(t("Schreibgeschützter Pfad oder Web-Adresse des Eintrags."))

self.lbl_path.setToolTip(t("Schreibgeschützter Pfad oder Web-Adresse des Eintrags"))

lbl_path_title = QLabel(t("&Pfad:"))

lbl_path_title.setBuddy(self.lbl_path)

form.addRow(lbl_path_title, self.lbl_path)

self.edit_label = QLineEdit(label)

self.edit_label.setAccessibleName(t("Bezeichnung"))

self.edit_label.setAccessibleDescription(t("Anzeigename für diesen Eintrag im Board."))

self.edit_label.setToolTip(t("Name der Verknüpfung im Board"))

lbl_label_title = QLabel(t("&Bezeichnung:"))

lbl_label_title.setBuddy(self.edit_label)

form.addRow(lbl_label_title, self.edit_label)

self.edit_notes = QTextEdit()

self.edit_notes.setPlainText(notes)

self.edit_notes.setPlaceholderText(t("Optionale Notiz eingeben..."))

self.edit_notes.setAccessibleName(t("Notiz"))

self.edit_notes.setAccessibleDescription(t("Optionale Notiz oder Beschreibung für diesen Eintrag."))

self.edit_notes.setToolTip(t("Optionale Notiz eingeben..."))

self.edit_notes.setMaximumHeight(100)

lbl_notes_title = QLabel(t("&Notiz:"))

lbl_notes_title.setBuddy(self.edit_notes)

form.addRow(lbl_notes_title, self.edit_notes)

layout.addLayout(form)

buttons = QDialogButtonBox(

QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel

)

ok_btn = buttons.button(QDialogButtonBox.StandardButton.Ok)

if ok_btn:

ok_btn.setAccessibleName(t("Speichern"))

ok_btn.setToolTip(t("Änderungen speichern"))

cancel_btn = buttons.button(QDialogButtonBox.StandardButton.Cancel)

if cancel_btn:

cancel_btn.setAccessibleName(t("Abbrechen"))

cancel_btn.setToolTip(t("Abbrechen"))

buttons.accepted.connect(self.accept)

buttons.rejected.connect(self.reject)

layout.addWidget(buttons)

def get_data(self) -> tuple[str, str | None]:

label = self.edit_label.text().strip()

notes = self.edit_notes.toPlainText().strip() or None

"""Delegate für SoftwareListWidget:

def paint(self, painter: QPainter, option: QStyleOptionViewItem, index):

widget = option.widget

if not isinstance(widget, QListWidget) or widget.viewMode() != QListWidget.ViewMode.ListMode:

super().paint(painter, option, index)

return

painter.save()

widget.style().drawPrimitive(

widget.style().PrimitiveElement.PE_PanelItemViewItem,

option,

painter,

widget,

)

rect = option.rect

left_margin = 6

right_margin = 12

icon_size = option.decorationSize.width() or 24

# Icon zeichnen

icon = index.data(Qt.ItemDataRole.DecorationRole)

icon_rect = QRect(

rect.left() + left_margin,

rect.top() + (rect.height() - icon_size) // 2,

icon_size,

icon_size,

)

if icon and isinstance(icon, QIcon) and not icon.isNull():

icon.paint(painter, icon_rect, Qt.AlignmentFlag.AlignCenter)

label = index.data(Qt.ItemDataRole.DisplayRole) or ""

metadata = index.data(ENTRY_METADATA_ROLE) or {}

notes = metadata.get("notes") if isinstance(metadata, dict) else None

path = index.data(Qt.ItemDataRole.UserRole) or ""

is_missing = False

if path and not str(path).startswith(("http://", "https://")) and not os.path.exists(path):

is_missing = True

secondary_text = ""

if is_missing:

secondary_text = f"[Nicht gefunden: {path}]"

elif notes:

secondary_text = notes

elif path:

secondary_text = path

painter.setFont(option.font)

fm = painter.fontMetrics()

is_selected = bool(option.state & widget.style().StateFlag.State_Selected)

if is_selected:

text_color = option.palette.highlightedText().color()

sec_color = text_color

else:

text_color = option.palette.text().color()

sec_color = QColor(204, 68, 68) if is_missing else QColor(130, 130, 130)

text_left = icon_rect.right() + 8

available_width = rect.right() - right_margin - text_left

if available_width > 0:

label_max_width = min(fm.horizontalAdvance(label), int(available_width * 0.45))

label_rect = QRect(text_left, rect.top(), label_max_width + 8, rect.height())

painter.setPen(text_color)

elided_label = fm.elidedText(label, Qt.TextElideMode.ElideRight, label_rect.width())

painter.drawText(

label_rect,

Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft,

elided_label,

)

sec_left = label_rect.right() + 16

sec_width = rect.right() - right_margin - sec_left

if sec_width > 30 and secondary_text:

sec_rect = QRect(sec_left, rect.top(), sec_width, rect.height())

painter.setPen(sec_color)

elide_mode = Qt.TextElideMode.ElideMiddle if not notes and not is_missing else Qt.TextElideMode.ElideRight

elided_sec = fm.elidedText(secondary_text, elide_mode, sec_width)

painter.drawText(

sec_rect,

Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft,

elided_sec,

)

painter.restore()

def sizeHint(self, option: QStyleOptionViewItem, index):

widget = option.widget

if isinstance(widget, QListWidget) and widget.viewMode() == QListWidget.ViewMode.ListMode:

return QSize(option.rect.width(), 32)

requestDelete = Signal(list)

# Transfer zwischen Boards (Tabs): jeweils (entries: list[dict], target_index: int)

requestMoveToBoard = Signal(list, int)

requestCopyToBoard = Signal(list, int)

entriesChanged = Signal()

def __init__(self, parent=None):

super().__init__(parent)

self.setAcceptDrops(True)

self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)

self.setAccessibleName(t("Software- und Dokumentenliste"))

self.setAccessibleDescription(

t("Verknüpfungen des aktuellen Boards. Mit Pfeiltasten navigieren, Eingabetaste zum Starten, F2 zum Bearbeiten, Entf zum Entfernen.")

)

self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)

self.customContextMenuRequested.connect(self._on_context_menu)

self.itemActivated.connect(self._on_item_activated)

self._icon_provider = QFileIconProvider()

# Callable -> list[(index, name)] der ANDEREN Boards (ohne dieses).

# Wird von MainWindow.add_new_tab gesetzt; ohne Provider bleiben die

# Transfer-Submenues ausgeblendet (z. B. bei isolierter Nutzung in Tests).

self.board_provider = None

self.setItemDelegate(SoftwareListItemDelegate(self))

self.configure_as_tiles()

def keyPressEvent(self, event):

"""Barrierefreie Tastaturbedienung: Entf/Backspace loescht, F2 editiert, Strg+C kopiert Pfad."""

key = event.key()

modifiers = event.modifiers()

if key in (Qt.Key.Key_Delete, Qt.Key.Key_Backspace):

selected = self.selectedItems()

paths = [

it.data(Qt.ItemDataRole.UserRole)

for it in selected

if it.data(Qt.ItemDataRole.UserRole)

]

if paths:

self.requestDelete.emit(paths)

event.accept()

return

elif key == Qt.Key.Key_F2:

selected = self.selectedItems()

if len(selected) == 1:

self._edit_entry(selected[0])

event.accept()

return

elif event.matches(QKeySequence.StandardKey.Copy) or (

modifiers == Qt.KeyboardModifier.ControlModifier and key == Qt.Key.Key_C

):

paths = [

str(it.data(Qt.ItemDataRole.UserRole))

for it in self.selectedItems()

if it.data(Qt.ItemDataRole.UserRole)

]

if paths:

clipboard = QApplication.clipboard()

if clipboard is not None:

clipboard.setText("\n".join(paths))

event.accept()

return

super().keyPressEvent(event)

def configure_as_tiles(self):

self.setViewMode(QListWidget.ViewMode.IconMode)

self.setResizeMode(QListWidget.ResizeMode.Adjust)

self.setWrapping(True)

self.setIconSize(QSize(64, 64))

self.setGridSize(QSize(110, 100))

self.setSpacing(8)

self.setUniformItemSizes(False)

def configure_as_list(self):

self.setViewMode(QListWidget.ViewMode.ListMode)

self.setResizeMode(QListWidget.ResizeMode.Adjust)

self.setWrapping(False)

self.setIconSize(QSize(24, 24))

self.setGridSize(QSize())

self.setSpacing(2)

self.setUniformItemSizes(True)

def paintEvent(self, event):

super().paintEvent(event)

if self.count() == 0:

painter = QPainter(self.viewport())

try:

painter.setRenderHint(QPainter.RenderHint.Antialiasing)

rect = self.viewport().rect()

if rect.width() < 50 or rect.height() < 50:

return

palette = self.palette()

text_color = palette.color(QPalette.ColorRole.PlaceholderText)

if not text_color.isValid() or text_color.alpha() == 0:

text_color = palette.text().color()

text_color.setAlpha(130)

painter.setPen(text_color)

font = self.font()

font.setPointSize(max(10, font.pointSize() + 1))

font.setBold(True)

painter.setFont(font)

title_text = t("Dieses Board ist noch leer")

hint_text = t("Ziehen Sie beliebige Apps, Dokumente, Ordner oder Verknüpfungen hierher.")

fm = painter.fontMetrics()

title_h = fm.height()

title_rect = QRect(rect.left() + 20, rect.center().y() - title_h - 4, rect.width() - 40, title_h + 4)

painter.drawText(title_rect, Qt.AlignmentFlag.AlignCenter, title_text)

font.setBold(False)

font.setPointSize(max(9, font.pointSize() - 1))

painter.setFont(font)

painter.setPen(text_color)

hint_rect = QRect(rect.left() + 20, rect.center().y() + 6, rect.width() - 40, max(40, rect.height() // 2))

painter.drawText(hint_rect, Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop | Qt.TextFlag.TextWordWrap, hint_text)

finally:

painter.end()

def dragEnterEvent(self, event):

if event.mimeData().hasUrls() or event.mimeData().hasText():

event.acceptProposedAction()

else:

event.ignore()

def dragMoveEvent(self, event):

if event.mimeData().hasUrls() or event.mimeData().hasText():

event.acceptProposedAction()

else:

event.ignore()

def dropEvent(self, event):

urls = event.mimeData().urls() if event.mimeData().hasUrls() else []

paths = []

for url in urls:

if url.isLocalFile():

p = url.toLocalFile()

if is_supported_launch_target(p):

paths.append(p)

elif url.scheme() in ("http", "https"):

u_str = url.toString()

if is_supported_launch_target(u_str):

paths.append(u_str)

if not paths and event.mimeData().hasText():

text = event.mimeData().text().strip()

if is_supported_launch_target(text):

paths.append(text)

if paths:

self.add_paths(paths)

self.entriesChanged.emit()

event.acceptProposedAction()

else:

event.ignore()

def filter_entries(self, query: str) -> int:

"""Filtert die Einträge im ListWidget anhand eines Suchbegriffs.

self._current_filter = query or ""

needle = self._current_filter.strip().casefold()

visible_count = 0

for i in range(self.count()):

item = self.item(i)

if not item:

continue

if not needle:

item.setHidden(False)

visible_count += 1

continue

metadata = item.data(ENTRY_METADATA_ROLE) or {}

label = (item.text() or "").casefold()

path = (metadata.get("path") or item.data(Qt.ItemDataRole.UserRole) or "").casefold()

notes = (metadata.get("notes") or "").casefold()

if needle in label or needle in path or needle in notes:

item.setHidden(False)

visible_count += 1

else:

item.setHidden(True)

return visible_count

def get_visible_count(self) -> int:

"""Gibt die Anzahl aktuell nicht-ausgeblendeter Einträge zurück."""

count = 0

for i in range(self.count()):

item = self.item(i)

if item and not item.isHidden():

count += 1

return count

def get_first_visible_entry(self) -> dict | None:

"""Gibt das Metadaten-Dict des ersten sichtbaren Eintrags zurück."""

for i in range(self.count()):

item = self.item(i)

if item and not item.isHidden():

metadata = item.data(ENTRY_METADATA_ROLE)

if isinstance(metadata, dict):

return metadata

return {

"path": item.data(Qt.ItemDataRole.UserRole),

"label": item.text(),

"kind": detect_entry_kind(item.data(Qt.ItemDataRole.UserRole)),

"notes": None,

}

return None

def sort_entries(self, ascending: bool = True):

"""Sortiert die Einträge im aktuellen Board alphabetisch nach Bezeichnung."""

entries = self.get_all_entries()

if not entries:

return

entries.sort(key=lambda e: (e.get("label") or "").lower(), reverse=not ascending)

self.clear()

for entry in entries:

self._add_item(entry)

self.entriesChanged.emit()

def _edit_entry(self, item: QListWidgetItem):

"""Öffnet den Dialog zum Bearbeiten von Bezeichnung und Notizen eines Eintrags."""

if item is None:

return