Hallöchen!
Mehr aus Langeweile ist ein Gedankenspiel mit Perplexity etwas eskaliert, und das Ergebnis kann ja durchaus für den ein oder anderen nützlich sein.
Hintergrund: Ich bin KDE Nutzer. Hin und wieder guckt man ja gerne über den Tellerrand. Einfach um mal wieder zu gucken, wie die andere Wiese so ist. Leider ist das gerade bei den beiden "großen" Desktops GNOME und KDE mit einem prall gefüllten App-Menü mit massig Redundanzen verbunden. Und extra dafür eine VM oder parallele Installation zu erstellen, ist im ersten Fall einfach nicht das gleiche und im zweiten Fall einfach zuviel Aufwand.
Also habe ich mich bzw. Perplexity gefragt, ob sich da nichts skripten ließe, was zumindest etwas aufräumt in der App Übersicht. Grob: KDE soll dann im App Menü einen Ordner GNOME-Apps haben, wo die einfach alle drinlanden, dass man drankommt, wenn man sie doch braucht, und GNOME im App-Grid umgekehrt etwas äquivalentes.
Nach LANGEM hin und her kam dabei folgendes raus, was ich noch nicht vollständig testen konnte, mangels GNOME (bin ich heute nicht mehr zu gekommen, siehe Uhrzeit), aber es gibt einen Testmodus, wo nur gesammelt wird, was man jeweils wo einsortiert hätte. Als vorherrschendes trennendes Element habe ich (ich bin CachyOS Nutzer) Arch App Gruppen Kategoriesierungen verwendet (funktioniert also nur mit Arch Derivaten!), man kann aber zusätzlich anhand von QT und GTK prüfen, wenn man mag (per parameter). Ist dann halt zu stark, aber warum den Code wegwerfen, ist halt alles auf dem Weg in gemeinsamer Diskussion mit der AI entstanden. Der Code ist komplett generiert.
Ehrlich gesagt weiß ich nicht, wohin damit die Reise geht, aber zumindest mich hält dieser App-Wust immer vom Nebeneinanderinstallieren ab und vielleicht kommt hier ja was positives bei rum. Ich bin nicht der erfahrenste Bash-Coder, daher mag ich den Code nicht nach seiner Qualität bewerten. Aber vielleicht kommen wir ja gemeinsam am Ende zu 'nem coolen Ergebnis, und vielleicht lässt sich das ja für andere Desktops erweitern, wenn man sowas denn möchte. Wie gesagt, das hier ist einfach nur das Ergebnis nach 3 Stunden hin und her mit Perplexity. So nun genug gesabbelt, hier das Skript:
(Bitte mit Vorsicht genießen!! Das rennt ja gleich los... Erstmal "--help" parameter verwenden und am besten erstmal mit "--test" arbeiten, dabei wird nichts verändert!)
Mehr aus Langeweile ist ein Gedankenspiel mit Perplexity etwas eskaliert, und das Ergebnis kann ja durchaus für den ein oder anderen nützlich sein.
Hintergrund: Ich bin KDE Nutzer. Hin und wieder guckt man ja gerne über den Tellerrand. Einfach um mal wieder zu gucken, wie die andere Wiese so ist. Leider ist das gerade bei den beiden "großen" Desktops GNOME und KDE mit einem prall gefüllten App-Menü mit massig Redundanzen verbunden. Und extra dafür eine VM oder parallele Installation zu erstellen, ist im ersten Fall einfach nicht das gleiche und im zweiten Fall einfach zuviel Aufwand.
Also habe ich mich bzw. Perplexity gefragt, ob sich da nichts skripten ließe, was zumindest etwas aufräumt in der App Übersicht. Grob: KDE soll dann im App Menü einen Ordner GNOME-Apps haben, wo die einfach alle drinlanden, dass man drankommt, wenn man sie doch braucht, und GNOME im App-Grid umgekehrt etwas äquivalentes.
Nach LANGEM hin und her kam dabei folgendes raus, was ich noch nicht vollständig testen konnte, mangels GNOME (bin ich heute nicht mehr zu gekommen, siehe Uhrzeit), aber es gibt einen Testmodus, wo nur gesammelt wird, was man jeweils wo einsortiert hätte. Als vorherrschendes trennendes Element habe ich (ich bin CachyOS Nutzer) Arch App Gruppen Kategoriesierungen verwendet (funktioniert also nur mit Arch Derivaten!), man kann aber zusätzlich anhand von QT und GTK prüfen, wenn man mag (per parameter). Ist dann halt zu stark, aber warum den Code wegwerfen, ist halt alles auf dem Weg in gemeinsamer Diskussion mit der AI entstanden. Der Code ist komplett generiert.
Ehrlich gesagt weiß ich nicht, wohin damit die Reise geht, aber zumindest mich hält dieser App-Wust immer vom Nebeneinanderinstallieren ab und vielleicht kommt hier ja was positives bei rum. Ich bin nicht der erfahrenste Bash-Coder, daher mag ich den Code nicht nach seiner Qualität bewerten. Aber vielleicht kommen wir ja gemeinsam am Ende zu 'nem coolen Ergebnis, und vielleicht lässt sich das ja für andere Desktops erweitern, wenn man sowas denn möchte. Wie gesagt, das hier ist einfach nur das Ergebnis nach 3 Stunden hin und her mit Perplexity. So nun genug gesabbelt, hier das Skript:
(Bitte mit Vorsicht genießen!! Das rennt ja gleich los... Erstmal "--help" parameter verwenden und am besten erstmal mit "--test" arbeiten, dabei wird nichts verändert!)
Bash:
#!/bin/bash
# Desktop App Organizer - Vollautomatisch mit Paketgruppen-Erkennung
# Version 2.2 - Mehrsprachig (DE/EN) mit Verbose-Modus
set -eo pipefail
GREEN='\033[0;32m'
BLUE='\033[0;34m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
CYAN='\033[0;36m'
BOLD='\033[1m'
NC='\033[0m'
# Cleanup bei Abbruch
cleanup() {
echo ""
echo -e "${YELLOW}Abgebrochen durch Benutzer${NC}"
exit 130
}
trap cleanup INT TERM
# Erkenne Systemsprache
detect_language() {
local lang="${LANG:-}"
if [[ "$lang" == de_* ]] || [[ "$lang" == de-* ]]; then
echo "de"
else
echo "en"
fi
}
LANG_CODE=$(detect_language)
# Texte - Deutsch
if [ "$LANG_CODE" = "de" ]; then
T_HELP_TITLE="Desktop App Organizer"
T_HELP_USAGE="VERWENDUNG:"
T_HELP_DESC="BESCHREIBUNG:"
T_HELP_DESC_LINE1="Erstellt automatisch Sammelordner für GNOME-Apps in KDE und KDE-Apps in GNOME."
T_HELP_DESC_LINE2="Apps werden anhand der offiziellen Arch-Paketgruppen erkannt (gnome, gnome-extra,"
T_HELP_DESC_LINE3="kde-applications, plasma, kf5, kf6)."
T_HELP_OPTIONS="OPTIONEN:"
T_HELP_OPT1="Zeigt diese Hilfe an und beendet das Programm"
T_HELP_OPT2_LINE1="Testmodus: Analysiert Apps ohne Änderungen vorzunehmen"
T_HELP_OPT2_LINE2="Zeigt an, welche Apps erkannt wurden und was gemacht würde"
T_HELP_OPT2_LINE3="Empfohlen für den ersten Durchlauf!"
T_HELP_OPT3_LINE1="Erweiterte Erkennung: Zusätzlich zu Paketgruppen auch GTK/Qt-Libraries prüfen"
T_HELP_OPT3_LINE2="Warnung: Kann false-positives erzeugen (z.B. Signal als GNOME-App)"
T_HELP_OPT3_LINE3="Im Standardmodus werden nur Apps aus offiziellen Paketgruppen erkannt"
T_HELP_OPT4_LINE1="Erzwingt Ausführung auch wenn nur eine Desktop-Umgebung installiert ist"
T_HELP_OPT4_LINE2="Nützlich zum Testen oder bei unvollständiger Installation"
T_HELP_OPT5_LINE1="Ausführliche Ausgabe: Zeigt Details während der Analyse"
T_HELP_OPT5_LINE2="Hilfreich bei langsamen Systemen oder vielen Apps"
T_HELP_EXAMPLES="BEISPIELE:"
T_HELP_EX1="# Testlauf (empfohlen)"
T_HELP_EX2="# Echte Ausführung"
T_HELP_EX3="# Mit erweiterter Toolkit-Erkennung (mehr Apps, aber auch false-positives)"
T_HELP_PREREQ="VORAUSSETZUNGEN:"
T_HELP_PREREQ_LINE1="- Arch Linux oder Arch-basierte Distribution (z.B. CachyOS, Manjaro)"
T_HELP_PREREQ_LINE2="- Sowohl KDE als auch GNOME sollten installiert sein"
T_HELP_PREREQ_LINE3="- pacman Paketmanager"
T_HELP_WHAT="WAS DAS SKRIPT MACHT:"
T_HELP_WHAT_KDE="In KDE:"
T_HELP_WHAT_KDE1="• Erstellt Ordner \"GNOME Apps\" im Startmenü"
T_HELP_WHAT_KDE2="• Verschiebt alle GNOME-Apps dort hinein"
T_HELP_WHAT_GNOME="In GNOME:"
T_HELP_WHAT_GNOME1="• Erstellt Ordner \"KDE Apps\" im App-Grid"
T_HELP_WHAT_GNOME2="• Verschiebt alle KDE-Apps dort hinein"
T_HELP_WHAT_OTHER="Andere Apps:"
T_HELP_WHAT_OTHER1="• Bleiben unverändert an ihrem normalen Platz"
T_HELP_GROUPS="ERKANNTE PAKETGRUPPEN:"
T_HELP_FILES="DATEIEN UND ORDNER:"
T_HELP_FILES_LINE1="Das Skript erstellt/modifiziert:"
T_HELP_FILES_LINE2="• ~/.local/share/applications/ (modifizierte .desktop-Dateien)"
T_HELP_FILES_LINE3="• ~/.config/menus/applications-merged/ (KDE-Menü-Konfiguration)"
T_HELP_UNDO="RÜCKGÄNGIG MACHEN:"
T_HELP_UNDO_LINE1="Zum Entfernen der Änderungen:"
T_HELP_AUTHOR="AUTOR:"
T_HELP_AUTHOR_TEXT="Erstellt mit Perplexity AI für die Organisation von Multi-DE-Systemen"
T_HELP_VERSION="VERSION:"
T_TESTMODE="TESTMODUS AKTIVIERT - Keine Änderungen werden vorgenommen"
T_TOOLKIT_WARNING="⚠ Toolkit-Erkennung aktiviert (GTK/Qt) - kann false-positives erzeugen"
T_CREATING_FOLDERS="Erstellt und aktiviert automatisch Sammelordner für GNOME-Apps in KDE und KDE-Apps in GNOME"
T_ANALYZING="Analysiert installierte Apps ohne Änderungen vorzunehmen"
T_ERROR_PACMAN="Fehler: pacman nicht gefunden. Dieses Skript funktioniert nur auf Arch-basierten Systemen."
T_ERROR_SYSAPPS="Fehler: $SYSTEM_APPS nicht gefunden"
T_BUILDING_CACHE="Baue Paketgruppen-Cache auf..."
T_CACHE_BUILT="✓ Cache aufgebaut"
T_INSTALLED_DE="Installierte Desktop-Umgebungen:"
T_KDE_INSTALLED="✓ KDE/Plasma installiert"
T_KDE_NOT_INSTALLED="✗ KDE/Plasma nicht installiert"
T_GNOME_INSTALLED="✓ GNOME installiert"
T_GNOME_NOT_INSTALLED="✗ GNOME nicht installiert"
T_ERROR_NO_DE="Fehler: Weder KDE noch GNOME sind installiert."
T_ERROR_NO_DE2="Dieses Skript ist nur sinnvoll, wenn beide Desktop-Umgebungen installiert sind."
T_WARNING_ONE_DE="⚠ Warnung: Nur eine Desktop-Umgebung installiert."
T_WARNING_ONE_DE2=" Dieses Skript ist am nützlichsten, wenn beide DEs installiert sind."
T_FORCE_SKIP="Force-Modus: Überspringe Warnung - fahre fort trotz fehlender DE"
T_CONTINUE="Trotzdem fortfahren? [j/N] "
T_ABORTED="Abgebrochen."
T_ANALYZING_APPS="Analysiere installierte Anwendungen..."
T_MODE_STRICT="(Modus: Nur offizielle Paketgruppen)"
T_MODE_TOOLKIT="(Modus: Paketgruppen + Toolkit-Erkennung)"
T_ANALYSIS_DONE="Analyse abgeschlossen!"
T_RESULTS="ANALYSEERGEBNISSE"
T_GNOME_APPS="1. GNOME Apps"
T_GNOME_APPS_FOUND="gefunden - aus offiziellen Gruppen"
T_KDE_APPS="2. KDE Apps"
T_KDE_APPS_FOUND="gefunden - aus offiziellen Gruppen"
T_OTHER_APPS="3. Andere/Framework-unabhängige Apps"
T_OTHER_APPS_FOUND="gefunden"
T_NONE_FOUND="(keine gefunden)"
T_TESTMODE_TITLE="TESTMODUS"
T_WOULD_HAPPEN="Was würde im echten Modus passieren:"
T_IN_KDE="✓ In KDE:"
T_FOLDER_CREATED="- Ordner 'GNOME Apps' würde erstellt"
T_APPS_GROUPED="GNOME-Apps würden dort gruppiert"
T_IN_GNOME="✓ In GNOME:"
T_FOLDER_KDE_CREATED="- Ordner 'KDE Apps' würde erstellt"
T_APPS_KDE_GROUPED="KDE-Apps würden dort gruppiert"
T_OTHER_UNCHANGED="ℹ Andere Apps"
T_OTHER_UNCHANGED2="würden nicht verändert"
T_HINT_STRICT="Hinweis: Läuft im strikten Modus (nur Paketgruppen)."
T_HINT_TOOLKIT="Für mehr Apps: --include-toolkit Flag verwenden (kann false-positives erzeugen)"
T_RUN_WITHOUT="Zum Ausführen ohne Testmodus: Skript ohne --dry-run starten"
T_NO_APPS="Keine GNOME- oder KDE-Apps aus offiziellen Paketgruppen gefunden."
T_NOTHING_TODO="Nichts zu tun."
T_START_CONFIG="Starte Konfiguration..."
T_CHECK_MARK_GNOME="Prüfe und markiere GNOME-Apps für KDE..."
T_NEW_MARKED="neue GNOME-Apps markiert"
T_ALL_MARKED="✓ Alle GNOME-Apps bereits korrekt markiert"
T_CREATE_KDE_MENU="Erstelle KDE-Menü für GNOME-Apps..."
T_MENU_CREATED="✓ KDE-Menü 'GNOME Apps' erstellt"
T_MENU_EXISTS="✓ KDE-Menü 'GNOME Apps' existiert bereits"
T_DIR_CREATED="✓ KDE-Menü Directory-Datei erstellt"
T_DIR_EXISTS="✓ KDE-Menü Directory-Datei existiert bereits"
T_CHECK_MARK_KDE="Prüfe und markiere KDE-Apps für GNOME..."
T_NEW_KDE_MARKED="neue KDE-Apps markiert"
T_ALL_KDE_MARKED="✓ Alle KDE-Apps bereits korrekt markiert"
T_CHECK_GNOME_FOLDER="Prüfe GNOME App-Folder für KDE-Apps..."
T_GNOME_FOLDER_EXISTS="✓ GNOME-Ordner 'KDE Apps' existiert bereits"
T_CREATE_GNOME_FOLDER="Erstelle GNOME-Ordner 'KDE Apps'..."
T_GNOME_FOLDER_CREATED="✓ GNOME-Ordner 'KDE Apps' erstellt"
T_ACTIVATING="Aktiviere Änderungen automatisch..."
T_KDE_DETECTED="KDE erkannt - aktualisiere Menü-Cache..."
T_KDE_UPDATED="✓ KDE-Menü sofort aktualisiert"
T_KDE_NOT_FOUND="⚠ kbuildsycoca nicht gefunden - Änderungen beim nächsten Login aktiv"
T_GNOME_DETECTED="GNOME erkannt - aktualisiere App-Folders..."
T_DCONF_UPDATED="✓ dconf aktualisiert"
T_FS_TRIGGERED="✓ Filesystem-Update getriggert"
T_GNOME_VISIBLE="✓ GNOME App-Folders sollten sofort sichtbar sein"
T_NO_CHANGES="Keine neuen Änderungen - alles bereits konfiguriert!"
T_DONE="Fertig!"
T_STATUS="Status:"
T_KDE_STATUS="✓ In KDE:"
T_GNOME_MENU_FOLDER="- Ordner 'GNOME Apps' im Startmenü"
T_GNOME_APPS_GROUPED="GNOME-Apps gruppiert (nur aus offiziellen Paketgruppen)"
T_NEW_ADDED="neue Apps hinzugefügt"
T_GNOME_STATUS="✓ In GNOME:"
T_KDE_GRID_FOLDER="- Ordner 'KDE Apps' im App-Grid"
T_KDE_APPS_GROUPED="KDE-Apps gruppiert (nur aus offiziellen Paketgruppen)"
T_OTHER_NOT_CHANGED="ℹ"
T_OTHER_NOT_CHANGED2="andere Apps wurden nicht verändert"
T_HINT_MANUAL="Apps wie Signal werden nicht automatisch zugeordnet - diese können manuell verschoben werden."
T_UNKNOWN_OPT="Unbekannte Option:"
T_USE_HELP="Verwende --help für Hilfe"
T_KDE_PACKAGES="KDE-Pakete"
T_GNOME_PACKAGES="GNOME-Pakete"
else
# Texte - English
T_HELP_TITLE="Desktop App Organizer"
T_HELP_USAGE="USAGE:"
T_HELP_DESC="DESCRIPTION:"
T_HELP_DESC_LINE1="Automatically creates collection folders for GNOME apps in KDE and KDE apps in GNOME."
T_HELP_DESC_LINE2="Apps are detected based on official Arch package groups (gnome, gnome-extra,"
T_HELP_DESC_LINE3="kde-applications, plasma, kf5, kf6)."
T_HELP_OPTIONS="OPTIONS:"
T_HELP_OPT1="Shows this help and exits"
T_HELP_OPT2_LINE1="Test mode: Analyzes apps without making changes"
T_HELP_OPT2_LINE2="Shows which apps were detected and what would be done"
T_HELP_OPT2_LINE3="Recommended for first run!"
T_HELP_OPT3_LINE1="Extended detection: Additionally checks GTK/Qt libraries"
T_HELP_OPT3_LINE2="Warning: May produce false-positives (e.g. Signal as GNOME app)"
T_HELP_OPT3_LINE3="Default mode only detects apps from official package groups"
T_HELP_OPT4_LINE1="Forces execution even if only one desktop environment is installed"
T_HELP_OPT4_LINE2="Useful for testing or incomplete installations"
T_HELP_OPT5_LINE1="Verbose output: Shows details during analysis"
T_HELP_OPT5_LINE2="Helpful on slow systems or with many apps"
T_HELP_EXAMPLES="EXAMPLES:"
T_HELP_EX1="# Test run (recommended)"
T_HELP_EX2="# Real execution"
T_HELP_EX3="# With extended toolkit detection (more apps, but also false-positives)"
T_HELP_PREREQ="PREREQUISITES:"
T_HELP_PREREQ_LINE1="- Arch Linux or Arch-based distribution (e.g. CachyOS, Manjaro)"
T_HELP_PREREQ_LINE2="- Both KDE and GNOME should be installed"
T_HELP_PREREQ_LINE3="- pacman package manager"
T_HELP_WHAT="WHAT THE SCRIPT DOES:"
T_HELP_WHAT_KDE="In KDE:"
T_HELP_WHAT_KDE1="• Creates folder \"GNOME Apps\" in start menu"
T_HELP_WHAT_KDE2="• Moves all GNOME apps there"
T_HELP_WHAT_GNOME="In GNOME:"
T_HELP_WHAT_GNOME1="• Creates folder \"KDE Apps\" in app grid"
T_HELP_WHAT_GNOME2="• Moves all KDE apps there"
T_HELP_WHAT_OTHER="Other apps:"
T_HELP_WHAT_OTHER1="• Remain unchanged in their normal location"
T_HELP_GROUPS="DETECTED PACKAGE GROUPS:"
T_HELP_FILES="FILES AND FOLDERS:"
T_HELP_FILES_LINE1="The script creates/modifies:"
T_HELP_FILES_LINE2="• ~/.local/share/applications/ (modified .desktop files)"
T_HELP_FILES_LINE3="• ~/.config/menus/applications-merged/ (KDE menu configuration)"
T_HELP_UNDO="UNDO CHANGES:"
T_HELP_UNDO_LINE1="To remove changes:"
T_HELP_AUTHOR="AUTHOR:"
T_HELP_AUTHOR_TEXT="Created with Perplexity AI for multi-DE system organization"
T_HELP_VERSION="VERSION:"
T_TESTMODE="TEST MODE ACTIVATED - No changes will be made"
T_TOOLKIT_WARNING="⚠ Toolkit detection enabled (GTK/Qt) - may produce false-positives"
T_CREATING_FOLDERS="Automatically creates and activates collection folders for GNOME apps in KDE and KDE apps in GNOME"
T_ANALYZING="Analyzes installed apps without making changes"
T_ERROR_PACMAN="Error: pacman not found. This script only works on Arch-based systems."
T_ERROR_SYSAPPS="Error: $SYSTEM_APPS not found"
T_BUILDING_CACHE="Building package group cache..."
T_CACHE_BUILT="✓ Cache built"
T_INSTALLED_DE="Installed desktop environments:"
T_KDE_INSTALLED="✓ KDE/Plasma installed"
T_KDE_NOT_INSTALLED="✗ KDE/Plasma not installed"
T_GNOME_INSTALLED="✓ GNOME installed"
T_GNOME_NOT_INSTALLED="✗ GNOME not installed"
T_ERROR_NO_DE="Error: Neither KDE nor GNOME are installed."
T_ERROR_NO_DE2="This script only makes sense when both desktop environments are installed."
T_WARNING_ONE_DE="⚠ Warning: Only one desktop environment installed."
T_WARNING_ONE_DE2=" This script is most useful when both DEs are installed."
T_FORCE_SKIP="Force mode: Skipping warning - continuing despite missing DE"
T_CONTINUE="Continue anyway? [y/N] "
T_ABORTED="Aborted."
T_ANALYZING_APPS="Analyzing installed applications..."
T_MODE_STRICT="(Mode: Official package groups only)"
T_MODE_TOOLKIT="(Mode: Package groups + toolkit detection)"
T_ANALYSIS_DONE="Analysis complete!"
T_RESULTS="ANALYSIS RESULTS"
T_GNOME_APPS="1. GNOME Apps"
T_GNOME_APPS_FOUND="found - from official groups"
T_KDE_APPS="2. KDE Apps"
T_KDE_APPS_FOUND="found - from official groups"
T_OTHER_APPS="3. Other/Framework-independent Apps"
T_OTHER_APPS_FOUND="found"
T_NONE_FOUND="(none found)"
T_TESTMODE_TITLE="TEST MODE"
T_WOULD_HAPPEN="What would happen in real mode:"
T_IN_KDE="✓ In KDE:"
T_FOLDER_CREATED="- Folder 'GNOME Apps' would be created"
T_APPS_GROUPED="GNOME apps would be grouped there"
T_IN_GNOME="✓ In GNOME:"
T_FOLDER_KDE_CREATED="- Folder 'KDE Apps' would be created"
T_APPS_KDE_GROUPED="KDE apps would be grouped there"
T_OTHER_UNCHANGED="ℹ Other apps"
T_OTHER_UNCHANGED2="would not be changed"
T_HINT_STRICT="Note: Running in strict mode (package groups only)."
T_HINT_TOOLKIT="For more apps: use --include-toolkit flag (may produce false-positives)"
T_RUN_WITHOUT="To run without test mode: start script without --dry-run"
T_NO_APPS="No GNOME or KDE apps from official package groups found."
T_NOTHING_TODO="Nothing to do."
T_START_CONFIG="Starting configuration..."
T_CHECK_MARK_GNOME="Checking and marking GNOME apps for KDE..."
T_NEW_MARKED="new GNOME apps marked"
T_ALL_MARKED="✓ All GNOME apps already correctly marked"
T_CREATE_KDE_MENU="Creating KDE menu for GNOME apps..."
T_MENU_CREATED="✓ KDE menu 'GNOME Apps' created"
T_MENU_EXISTS="✓ KDE menu 'GNOME Apps' already exists"
T_DIR_CREATED="✓ KDE menu directory file created"
T_DIR_EXISTS="✓ KDE menu directory file already exists"
T_CHECK_MARK_KDE="Checking and marking KDE apps for GNOME..."
T_NEW_KDE_MARKED="new KDE apps marked"
T_ALL_KDE_MARKED="✓ All KDE apps already correctly marked"
T_CHECK_GNOME_FOLDER="Checking GNOME app folder for KDE apps..."
T_GNOME_FOLDER_EXISTS="✓ GNOME folder 'KDE Apps' already exists"
T_CREATE_GNOME_FOLDER="Creating GNOME folder 'KDE Apps'..."
T_GNOME_FOLDER_CREATED="✓ GNOME folder 'KDE Apps' created"
T_ACTIVATING="Activating changes automatically..."
T_KDE_DETECTED="KDE detected - updating menu cache..."
T_KDE_UPDATED="✓ KDE menu updated immediately"
T_KDE_NOT_FOUND="⚠ kbuildsycoca not found - changes active at next login"
T_GNOME_DETECTED="GNOME detected - updating app folders..."
T_DCONF_UPDATED="✓ dconf updated"
T_FS_TRIGGERED="✓ Filesystem update triggered"
T_GNOME_VISIBLE="✓ GNOME app folders should be visible immediately"
T_NO_CHANGES="No new changes - everything already configured!"
T_DONE="Done!"
T_STATUS="Status:"
T_KDE_STATUS="✓ In KDE:"
T_GNOME_MENU_FOLDER="- Folder 'GNOME Apps' in start menu"
T_GNOME_APPS_GROUPED="GNOME apps grouped (from official package groups only)"
T_NEW_ADDED="new apps added"
T_GNOME_STATUS="✓ In GNOME:"
T_KDE_GRID_FOLDER="- Folder 'KDE Apps' in app grid"
T_KDE_APPS_GROUPED="KDE apps grouped (from official package groups only)"
T_OTHER_NOT_CHANGED="ℹ"
T_OTHER_NOT_CHANGED2="other apps were not changed"
T_HINT_MANUAL="Apps like Signal are not automatically assigned - these can be moved manually."
T_UNKNOWN_OPT="Unknown option:"
T_USE_HELP="Use --help for help"
T_KDE_PACKAGES="KDE packages"
T_GNOME_PACKAGES="GNOME packages"
fi
# Hilfefunktion
show_help() {
echo -e "${BOLD}${T_HELP_TITLE}${NC} - v2.2"
echo ""
echo -e "${BOLD}${T_HELP_USAGE}${NC}"
echo " $(basename "$0") [OPTIONS]"
echo ""
echo -e "${BOLD}${T_HELP_DESC}${NC}"
echo " ${T_HELP_DESC_LINE1}"
echo " ${T_HELP_DESC_LINE2}"
echo " ${T_HELP_DESC_LINE3}"
echo ""
echo -e "${BOLD}${T_HELP_OPTIONS}${NC}"
echo -e " ${GREEN}-h, --help${NC}"
echo " ${T_HELP_OPT1}"
echo ""
echo -e " ${GREEN}-n, --dry-run, --test${NC}"
echo " ${T_HELP_OPT2_LINE1}"
echo " ${T_HELP_OPT2_LINE2}"
echo -e " ${CYAN}${T_HELP_OPT2_LINE3}${NC}"
echo ""
echo -e " ${GREEN}--include-toolkit${NC}"
echo " ${T_HELP_OPT3_LINE1}"
echo -e " ${YELLOW}${T_HELP_OPT3_LINE2}${NC}"
echo " ${T_HELP_OPT3_LINE3}"
echo ""
echo -e " ${GREEN}--force, -f${NC}"
echo " ${T_HELP_OPT4_LINE1}"
echo -e " ${YELLOW}${T_HELP_OPT4_LINE2}${NC}"
echo ""
echo -e " ${GREEN}--verbose, -v${NC}"
echo " ${T_HELP_OPT5_LINE1}"
echo -e " ${YELLOW}${T_HELP_OPT5_LINE2}${NC}"
echo ""
echo -e "${BOLD}${T_HELP_EXAMPLES}${NC}"
echo -e " ${CYAN}${T_HELP_EX1}${NC}"
echo " $(basename "$0") --dry-run"
echo ""
echo -e " ${CYAN}${T_HELP_EX2}${NC}"
echo " $(basename "$0")"
echo ""
echo -e " ${CYAN}${T_HELP_EX3}${NC}"
echo " $(basename "$0") --dry-run --include-toolkit"
echo ""
echo -e "${BOLD}${T_HELP_PREREQ}${NC}"
echo " ${T_HELP_PREREQ_LINE1}"
echo " ${T_HELP_PREREQ_LINE2}"
echo " ${T_HELP_PREREQ_LINE3}"
echo ""
echo -e "${BOLD}${T_HELP_WHAT}${NC}"
echo -e " ${GREEN}${T_HELP_WHAT_KDE}${NC}"
echo " ${T_HELP_WHAT_KDE1}"
echo " ${T_HELP_WHAT_KDE2}"
echo ""
echo -e " ${BLUE}${T_HELP_WHAT_GNOME}${NC}"
echo " ${T_HELP_WHAT_GNOME1}"
echo " ${T_HELP_WHAT_GNOME2}"
echo ""
echo -e " ${YELLOW}${T_HELP_WHAT_OTHER}${NC}"
echo " ${T_HELP_WHAT_OTHER1}"
echo ""
echo -e "${BOLD}${T_HELP_GROUPS}${NC}"
echo -e " ${GREEN}GNOME:${NC} gnome, gnome-extra"
echo -e " ${BLUE}KDE:${NC} kde-applications, plasma, kf5, kf6"
echo ""
echo -e "${BOLD}${T_HELP_FILES}${NC}"
echo " ${T_HELP_FILES_LINE1}"
echo " ${T_HELP_FILES_LINE2}"
echo " ${T_HELP_FILES_LINE3}"
echo ""
echo -e "${BOLD}${T_HELP_UNDO}${NC}"
echo " ${T_HELP_UNDO_LINE1}"
echo " rm -rf ~/.local/share/applications/*.desktop"
echo " rm -rf ~/.config/menus/applications-merged/gnome-apps.menu"
echo " rm -rf ~/.local/share/applications/gnome-apps.directory"
echo " gsettings reset org.gnome.desktop.app-folders folder-children"
echo ""
echo -e "${BOLD}${T_HELP_AUTHOR}${NC}"
echo " ${T_HELP_AUTHOR_TEXT}"
echo ""
echo -e "${BOLD}${T_HELP_VERSION}${NC}"
echo " 2.2"
echo ""
}
# Prüfe auf Help-Flag zuerst
for arg in "$@"; do
if [[ "$arg" == "-h" ]] || [[ "$arg" == "--help" ]]; then
show_help
exit 0
fi
done
# Prüfe auf Testmodus und Optionen
DRY_RUN=false
STRICT_MODE=true
FORCE_MODE=false
VERBOSE=false
for arg in "$@"; do
case "$arg" in
--dry-run|-n|--test)
DRY_RUN=true
;;
--include-toolkit)
STRICT_MODE=false
;;
--force|-f)
FORCE_MODE=true
;;
--verbose|-v)
VERBOSE=true
;;
*)
echo -e "${RED}${T_UNKNOWN_OPT} $arg${NC}"
echo "${T_USE_HELP}"
exit 1
;;
esac
done
if [ "$DRY_RUN" = true ]; then
echo -e "${CYAN}=== ${T_TESTMODE} ===${NC}"
echo ""
fi
if [ "$STRICT_MODE" = false ]; then
echo -e "${YELLOW}${T_TOOLKIT_WARNING}${NC}"
echo ""
fi
echo -e "${BLUE}=== Desktop App Organizer v2.2 ===${NC}"
if [ "$DRY_RUN" = false ]; then
echo "${T_CREATING_FOLDERS}"
else
echo "${T_ANALYZING}"
fi
echo ""
# Prüfe ob pacman verfügbar ist
if ! command -v pacman &> /dev/null; then
echo -e "${RED}${T_ERROR_PACMAN}${NC}"
exit 1
fi
# Verzeichnisse
SYSTEM_APPS="/usr/share/applications"
LOCAL_APPS="$HOME/.local/share/applications"
KDE_MENU_DIR="$HOME/.config/menus/applications-merged"
KDE_MENU_FILE="$KDE_MENU_DIR/gnome-apps.menu"
DIRECTORY_FILE="$LOCAL_APPS/gnome-apps.directory"
# Prüfe ob System-Apps-Verzeichnis existiert
if [ ! -d "$SYSTEM_APPS" ]; then
echo -e "${RED}${T_ERROR_SYSAPPS}${NC}"
exit 1
fi
# Listen für erkannte Apps
declare -a GTK_APPS
declare -a QT_APPS
declare -a OTHER_APPS
NEWLY_MODIFIED_GTK=0
NEWLY_MODIFIED_KDE=0
# Cache für Paketgruppen und Package-Lookups
declare -A KDE_PACKAGES
declare -A GNOME_PACKAGES
declare -A PACKAGE_CACHE
# Baue Paketgruppen-Cache auf
echo -e "${BLUE}${T_BUILDING_CACHE}${NC}"
# KDE/Plasma Gruppen
for group in kde-applications plasma kf6 kf5; do
if [ "$VERBOSE" = true ]; then
echo -e "${CYAN} Lese Gruppe: $group${NC}"
fi
while IFS= read -r pkg; do
[ -n "$pkg" ] && KDE_PACKAGES["$pkg"]=1
done < <(pacman -Qgq "$group" 2>/dev/null || true)
done
# GNOME Gruppen
for group in gnome gnome-extra; do
if [ "$VERBOSE" = true ]; then
echo -e "${CYAN} Lese Gruppe: $group${NC}"
fi
while IFS= read -r pkg; do
[ -n "$pkg" ] && GNOME_PACKAGES["$pkg"]=1
done < <(pacman -Qgq "$group" 2>/dev/null || true)
done
echo -e "${GREEN}${T_CACHE_BUILT} (${#KDE_PACKAGES[@]} ${T_KDE_PACKAGES}, ${#GNOME_PACKAGES[@]} ${T_GNOME_PACKAGES})${NC}"
# Prüfe ob beide Desktop-Umgebungen überhaupt installiert sind
KDE_INSTALLED=false
GNOME_INSTALLED=false
if [ ${#KDE_PACKAGES[@]} -gt 0 ]; then
KDE_INSTALLED=true
fi
if [ ${#GNOME_PACKAGES[@]} -gt 0 ]; then
GNOME_INSTALLED=true
fi
echo ""
echo -e "${BLUE}${T_INSTALLED_DE}${NC}"
if [ "$KDE_INSTALLED" = true ]; then
echo -e "${GREEN} ${T_KDE_INSTALLED}${NC}"
else
echo -e "${YELLOW} ${T_KDE_NOT_INSTALLED}${NC}"
fi
if [ "$GNOME_INSTALLED" = true ]; then
echo -e "${GREEN} ${T_GNOME_INSTALLED}${NC}"
else
echo -e "${YELLOW} ${T_GNOME_NOT_INSTALLED}${NC}"
fi
echo ""
# Wenn beide nicht installiert sind, beenden
if [ "$KDE_INSTALLED" = false ] && [ "$GNOME_INSTALLED" = false ]; then
echo -e "${RED}${T_ERROR_NO_DE}${NC}"
echo -e "${YELLOW}${T_ERROR_NO_DE2}${NC}"
exit 1
fi
# Warnung wenn nur eine installiert ist
if [ "$KDE_INSTALLED" = false ] || [ "$GNOME_INSTALLED" = false ]; then
if [ "$FORCE_MODE" = false ]; then
echo -e "${YELLOW}${T_WARNING_ONE_DE}${NC}"
echo -e "${YELLOW}${T_WARNING_ONE_DE2}${NC}"
echo ""
read -p "${T_CONTINUE}" -n 1 -r
echo
if [[ ! $REPLY =~ ^[JjYy]$ ]]; then
echo "${T_ABORTED}"
exit 0
fi
echo ""
else
echo -e "${CYAN}${T_FORCE_SKIP}${NC}"
echo ""
fi
fi
# Funktion: Finde Paket für .desktop-Datei (mit Cache)
get_package_for_desktop_file() {
local desktop_file="$1"
if [[ -n "${PACKAGE_CACHE[$desktop_file]:-}" ]]; then
echo "${PACKAGE_CACHE[$desktop_file]}"
return
fi
local pkg
pkg=$(pacman -Qoq "$desktop_file" 2>/dev/null || echo "")
PACKAGE_CACHE["$desktop_file"]="$pkg"
echo "$pkg"
}
# Funktion: Prüfe ob App Qt/KDE ist
is_qt_kde_app() {
local desktop_file="$1"
local package
package=$(get_package_for_desktop_file "$desktop_file")
if [ ${#KDE_PACKAGES[@]} -gt 0 ] && [[ -n "$package" ]]; then
if [[ -n "${KDE_PACKAGES[$package]+x}" ]] && [[ "${KDE_PACKAGES[$package]}" == "1" ]]; then
return 0
fi
fi
if [ "$STRICT_MODE" = true ]; then
return 1
fi
if grep -qiE "^Categories=.*KDE" "$desktop_file" 2>/dev/null; then
return 0
fi
if grep -qiE "^OnlyShowIn=.*KDE" "$desktop_file" 2>/dev/null; then
return 0
fi
return 1
}
# Funktion: Prüfe ob App GTK/GNOME ist
is_gtk_gnome_app() {
local desktop_file="$1"
local package
package=$(get_package_for_desktop_file "$desktop_file")
if [ ${#GNOME_PACKAGES[@]} -gt 0 ] && [[ -n "$package" ]]; then
if [[ -n "${GNOME_PACKAGES[$package]+x}" ]] && [[ "${GNOME_PACKAGES[$package]}" == "1" ]]; then
return 0
fi
fi
if [ "$STRICT_MODE" = true ]; then
return 1
fi
if grep -qiE "^Categories=.*GNOME" "$desktop_file" 2>/dev/null; then
return 0
fi
if grep -qiE "^OnlyShowIn=.*GNOME" "$desktop_file" 2>/dev/null; then
return 0
fi
return 1
}
# Funktion: Extrahiere App-Namen
get_app_name() {
local desktop_file="$1"
local name
name=$(grep -E "^Name=" "$desktop_file" 2>/dev/null | head -n1 | cut -d'=' -f2- || echo "")
echo "$name"
}
# Analysiere installierte Apps
echo -e "${BLUE}${T_ANALYZING_APPS}${NC}"
if [ "$STRICT_MODE" = true ]; then
echo -e "${CYAN}${T_MODE_STRICT}${NC}"
else
echo -e "${CYAN}${T_MODE_TOOLKIT}${NC}"
fi
echo ""
# Zähler für Verbose
APP_COUNT=0
TOTAL_APPS=0
# Zähle Apps nur im Verbose-Modus
if [ "$VERBOSE" = true ]; then
TOTAL_APPS=$(find "$SYSTEM_APPS" -maxdepth 1 -name "*.desktop" -type f 2>/dev/null | wc -l) || TOTAL_APPS=0
fi
# Deaktiviere pipefail temporär für die Schleife
set +e
for desktop_file in "$SYSTEM_APPS"/*.desktop; do
[[ -f "$desktop_file" ]] || continue
filename=$(basename "$desktop_file")
# Verbose-Ausgabe mit Live-Counter
if [ "$VERBOSE" = true ]; then
((APP_COUNT++))
short_name="${filename:0:45}"
printf "\r${CYAN}[%d/%d]${NC} %-50s" "$APP_COUNT" "$TOTAL_APPS" "$short_name"
fi
# Überspringe System-Komponenten und versteckte Apps
if grep -qE "^(NoDisplay=true|Type=Service)" "$desktop_file" 2>/dev/null; then
if [ "$VERBOSE" = true ]; then
printf " ${YELLOW}[Skip]${NC} \n"
fi
continue
fi
# Hole Paketname
pkg=$(pacman -Qoq "$desktop_file" 2>/dev/null || echo "")
# Prüfe ob GNOME App
is_gnome=false
if [ ${#GNOME_PACKAGES[@]} -gt 0 ] && [[ -n "$pkg" ]] && [[ -n "${GNOME_PACKAGES[$pkg]+x}" ]]; then
is_gnome=true
fi
if [ "$is_gnome" = true ]; then
GTK_APPS+=("$filename")
if [ "$VERBOSE" = true ]; then
printf " ${GREEN}[GNOME]${NC}\n"
fi
continue
fi
# Prüfe ob KDE App
is_kde=false
if [ ${#KDE_PACKAGES[@]} -gt 0 ] && [[ -n "$pkg" ]] && [[ -n "${KDE_PACKAGES[$pkg]+x}" ]]; then
is_kde=true
fi
if [ "$is_kde" = true ]; then
QT_APPS+=("$filename")
if [ "$VERBOSE" = true ]; then
printf " ${BLUE}[KDE]${NC} \n"
fi
continue
fi
# Weder KDE noch GNOME
OTHER_APPS+=("$filename")
if [ "$VERBOSE" = true ]; then
printf " ${YELLOW}[Other]${NC}\n"
fi
done
# Reaktiviere pipefail
set -e
# Aufräumen
if [ "$VERBOSE" = true ]; then
echo ""
fi
echo -e "${GREEN}${T_ANALYSIS_DONE}${NC}"
echo ""
# Zeige detaillierte Listen
echo -e "${CYAN}╔═══════════════════════════════════════════════════════════════╗${NC}"
echo -e "${CYAN}║ ${T_RESULTS} ║${NC}"
echo -e "${CYAN}╚═══════════════════════════════════════════════════════════════╝${NC}"
echo ""
# Liste 1: GNOME Apps
echo -e "${GREEN}┌─ ${T_GNOME_APPS} (${#GTK_APPS[@]} ${T_GNOME_APPS_FOUND})${NC}"
if [ ${#GTK_APPS[@]} -gt 0 ]; then
for app in "${GTK_APPS[@]}"; do
app_name=$(get_app_name "$SYSTEM_APPS/$app")
pkg=$(get_package_for_desktop_file "$SYSTEM_APPS/$app")
echo -e "${GREEN}│${NC} • ${app_name:-$app} ${CYAN}[${pkg:-unknown}]${NC}"
done
else
echo -e "${GREEN}│${NC} ${T_NONE_FOUND}"
fi
echo -e "${GREEN}└─${NC}"
echo ""
# Liste 2: KDE Apps
echo -e "${BLUE}┌─ ${T_KDE_APPS} (${#QT_APPS[@]} ${T_KDE_APPS_FOUND})${NC}"
if [ ${#QT_APPS[@]} -gt 0 ]; then
for app in "${QT_APPS[@]}"; do
app_name=$(get_app_name "$SYSTEM_APPS/$app")
pkg=$(get_package_for_desktop_file "$SYSTEM_APPS/$app")
echo -e "${BLUE}│${NC} • ${app_name:-$app} ${CYAN}[${pkg:-unknown}]${NC}"
done
else
echo -e "${BLUE}│${NC} ${T_NONE_FOUND}"
fi
echo -e "${BLUE}└─${NC}"
echo ""
# Liste 3: Andere Apps
echo -e "${YELLOW}┌─ ${T_OTHER_APPS} (${#OTHER_APPS[@]} ${T_OTHER_APPS_FOUND})${NC}"
if [ ${#OTHER_APPS[@]} -gt 0 ]; then
for app in "${OTHER_APPS[@]}"; do
app_name=$(get_app_name "$SYSTEM_APPS/$app")
pkg=$(get_package_for_desktop_file "$SYSTEM_APPS/$app")
echo -e "${YELLOW}│${NC} • ${app_name:-$app} ${CYAN}[${pkg:-unknown}]${NC}"
done
else
echo -e "${YELLOW}│${NC} ${T_NONE_FOUND}"
fi
echo -e "${YELLOW}└─${NC}"
echo ""
# Im Testmodus hier beenden
if [ "$DRY_RUN" = true ]; then
echo -e "${CYAN}╔═══════════════════════════════════════════════════════════════╗${NC}"
echo -e "${CYAN}║ ${T_TESTMODE_TITLE} ║${NC}"
echo -e "${CYAN}╚═══════════════════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "${BLUE}${T_WOULD_HAPPEN}${NC}"
echo ""
if [ "$GNOME_INSTALLED" = true ]; then
echo -e "${GREEN}${T_IN_KDE}${NC}"
echo " ${T_FOLDER_CREATED}"
echo " - ${#GTK_APPS[@]} ${T_APPS_GROUPED}"
echo ""
fi
if [ "$KDE_INSTALLED" = true ]; then
echo -e "${BLUE}${T_IN_GNOME}${NC}"
echo " ${T_FOLDER_KDE_CREATED}"
echo " - ${#QT_APPS[@]} ${T_APPS_KDE_GROUPED}"
echo ""
fi
echo -e "${YELLOW}${T_OTHER_UNCHANGED} (${#OTHER_APPS[@]}) ${T_OTHER_UNCHANGED2}${NC}"
echo ""
if [ "$STRICT_MODE" = true ]; then
echo -e "${CYAN}${T_HINT_STRICT}${NC}"
echo -e "${CYAN}${T_HINT_TOOLKIT}${NC}"
fi
echo ""
echo -e "${CYAN}${T_RUN_WITHOUT}${NC}"
exit 0
fi
# Wenn keine Apps gefunden wurden, beenden
if [ ${#GTK_APPS[@]} -eq 0 ] && [ ${#QT_APPS[@]} -eq 0 ]; then
echo -e "${YELLOW}${T_NO_APPS}${NC}"
echo -e "${YELLOW}${T_NOTHING_TODO}${NC}"
exit 0
fi
# Ab hier: Normaler Modus
echo -e "${BLUE}${T_START_CONFIG}${NC}"
echo ""
mkdir -p "$LOCAL_APPS"
mkdir -p "$KDE_MENU_DIR"
# ===== TEIL 1: GNOME-Apps für KDE markieren =====
if [ "$GNOME_INSTALLED" = true ] && [ ${#GTK_APPS[@]} -gt 0 ]; then
echo -e "${BLUE}${T_CHECK_MARK_GNOME}${NC}"
for app in "${GTK_APPS[@]}"; do
app_local_file="$LOCAL_APPS/$app"
if [[ -f "$app_local_file" ]] && grep -q "^Categories=.*X-GNOME-Apps" "$app_local_file" 2>/dev/null; then
continue
fi
cp "$SYSTEM_APPS/$app" "$app_local_file"
if grep -q "^Categories=" "$app_local_file" 2>/dev/null; then
if ! grep -q "X-GNOME-Apps" "$app_local_file" 2>/dev/null; then
sed -i 's/^Categories=\(.*\)/Categories=X-GNOME-Apps;\1/' "$app_local_file"
((NEWLY_MODIFIED_GTK++))
fi
else
echo "Categories=X-GNOME-Apps;" >> "$app_local_file"
((NEWLY_MODIFIED_GTK++))
fi
done
if [ $NEWLY_MODIFIED_GTK -gt 0 ]; then
echo -e "${GREEN}✓ ${NEWLY_MODIFIED_GTK} ${T_NEW_MARKED}${NC}"
else
echo -e "${YELLOW}${T_ALL_MARKED}${NC}"
fi
fi
# ===== TEIL 2: Erstelle KDE-Menü-Kategorie für GNOME-Apps =====
KDE_MENU_CREATED=false
if [ "$GNOME_INSTALLED" = true ] && [ ${#GTK_APPS[@]} -gt 0 ]; then
if [ ! -f "$KDE_MENU_FILE" ]; then
echo -e "${BLUE}${T_CREATE_KDE_MENU}${NC}"
cat > "$KDE_MENU_FILE" << 'EOF'
<!DOCTYPE Menu PUBLIC "-//freedesktop//DTD Menu 1.0//EN"
"http://www.freedesktop.org/standards/menu-spec/1.0/menu.dtd">
<Menu>
<Name>Applications</Name>
<Menu>
<Name>GNOME Apps</Name>
<Directory>gnome-apps.directory</Directory>
<Include>
<Category>X-GNOME-Apps</Category>
</Include>
</Menu>
</Menu>
EOF
KDE_MENU_CREATED=true
echo -e "${GREEN}${T_MENU_CREATED}${NC}"
else
echo -e "${YELLOW}${T_MENU_EXISTS}${NC}"
fi
if [ ! -f "$DIRECTORY_FILE" ]; then
cat > "$DIRECTORY_FILE" << 'EOF'
[Desktop Entry]
Type=Directory
Name=GNOME Apps
Name[de]=GNOME Apps
Icon=gnome-panel-launcher
Comment=GNOME and GTK Applications
Comment[de]=GNOME und GTK Anwendungen
EOF
echo -e "${GREEN}${T_DIR_CREATED}${NC}"
else
echo -e "${YELLOW}${T_DIR_EXISTS}${NC}"
fi
fi
# ===== TEIL 3: KDE-Apps für GNOME markieren =====
if [ "$KDE_INSTALLED" = true ] && [ ${#QT_APPS[@]} -gt 0 ]; then
echo -e "${BLUE}${T_CHECK_MARK_KDE}${NC}"
for app in "${QT_APPS[@]}"; do
app_local_file="$LOCAL_APPS/$app"
if [[ -f "$app_local_file" ]] && grep -q "^Categories=.*X-KDE-Apps" "$app_local_file" 2>/dev/null; then
continue
fi
cp "$SYSTEM_APPS/$app" "$app_local_file"
if grep -q "^Categories=" "$app_local_file" 2>/dev/null; then
if ! grep -q "X-KDE-Apps" "$app_local_file" 2>/dev/null; then
sed -i 's/^Categories=\(.*\)/Categories=X-KDE-Apps;\1/' "$app_local_file"
((NEWLY_MODIFIED_KDE++))
fi
else
echo "Categories=X-KDE-Apps;" >> "$app_local_file"
((NEWLY_MODIFIED_KDE++))
fi
done
if [ $NEWLY_MODIFIED_KDE -gt 0 ]; then
echo -e "${GREEN}✓ ${NEWLY_MODIFIED_KDE} ${T_NEW_KDE_MARKED}${NC}"
else
echo -e "${YELLOW}${T_ALL_KDE_MARKED}${NC}"
fi
fi
# ===== TEIL 4: Erstelle GNOME App-Folder für KDE-Apps =====
GNOME_FOLDER_CREATED=false
FOLDER_ID="kde-apps"
FOLDER_NAME="KDE Apps"
if [ "$KDE_INSTALLED" = true ] && [ ${#QT_APPS[@]} -gt 0 ] && command -v gsettings &> /dev/null; then
echo -e "${BLUE}${T_CHECK_GNOME_FOLDER}${NC}"
CURRENT_FOLDERS=$(gsettings get org.gnome.desktop.app-folders folder-children 2>/dev/null || echo "@as []")
if echo "$CURRENT_FOLDERS" | grep -q "$FOLDER_ID"; then
echo -e "${YELLOW}${T_GNOME_FOLDER_EXISTS}${NC}"
else
echo -e "${BLUE}${T_CREATE_GNOME_FOLDER}${NC}"
if [ "$CURRENT_FOLDERS" = "@as []" ] || [ -z "$CURRENT_FOLDERS" ]; then
gsettings set org.gnome.desktop.app-folders folder-children "['$FOLDER_ID']"
else
NEW_FOLDERS=$(echo "$CURRENT_FOLDERS" | sed "s/]/, '$FOLDER_ID']/")
gsettings set org.gnome.desktop.app-folders folder-children "$NEW_FOLDERS"
fi
gsettings set org.gnome.desktop.app-folders.folder:/org/gnome/desktop/app-folders/folders/$FOLDER_ID/ name "$FOLDER_NAME"
gsettings set org.gnome.desktop.app-folders.folder:/org/gnome/desktop/app-folders/folders/$FOLDER_ID/ categories "['X-KDE-Apps']"
GNOME_FOLDER_CREATED=true
echo -e "${GREEN}${T_GNOME_FOLDER_CREATED}${NC}"
fi
fi
# ===== TEIL 5: Automatische Aktivierung =====
NEEDS_ACTIVATION=false
if [ $NEWLY_MODIFIED_GTK -gt 0 ] || [ $KDE_MENU_CREATED = true ]; then
NEEDS_ACTIVATION=true
fi
if [ $NEWLY_MODIFIED_KDE -gt 0 ] || [ $GNOME_FOLDER_CREATED = true ]; then
NEEDS_ACTIVATION=true
fi
if [ $NEEDS_ACTIVATION = true ]; then
echo ""
echo -e "${BLUE}${T_ACTIVATING}${NC}"
KDE_RUNNING=false
if [[ "${XDG_CURRENT_DESKTOP:-}" == *"KDE"* ]] || [[ "${XDG_SESSION_DESKTOP:-}" == "plasma"* ]] || pgrep -x plasmashell > /dev/null 2>&1; then
KDE_RUNNING=true
fi
if [ "$KDE_RUNNING" = true ] && { [ $NEWLY_MODIFIED_GTK -gt 0 ] || [ $KDE_MENU_CREATED = true ]; }; then
echo -e "${BLUE}${T_KDE_DETECTED}${NC}"
if command -v kbuildsycoca6 &> /dev/null; then
kbuildsycoca6 &> /dev/null && echo -e "${GREEN}${T_KDE_UPDATED}${NC}"
elif command -v kbuildsycoca5 &> /dev/null; then
kbuildsycoca5 &> /dev/null && echo -e "${GREEN}${T_KDE_UPDATED}${NC}"
else
echo -e "${YELLOW}${T_KDE_NOT_FOUND}${NC}"
fi
fi
GNOME_RUNNING=false
if [[ "${XDG_CURRENT_DESKTOP:-}" == *"GNOME"* ]] || [[ "${XDG_SESSION_DESKTOP:-}" == "gnome"* ]] || pgrep -x gnome-shell > /dev/null 2>&1; then
GNOME_RUNNING=true
fi
if [ "$GNOME_RUNNING" = true ] && { [ $NEWLY_MODIFIED_KDE -gt 0 ] || [ $GNOME_FOLDER_CREATED = true ]; }; then
echo -e "${BLUE}${T_GNOME_DETECTED}${NC}"
if command -v dconf &> /dev/null; then
dconf update &> /dev/null && echo -e "${GREEN}${T_DCONF_UPDATED}${NC}"
fi
if [ ${#QT_APPS[@]} -gt 0 ]; then
for app in "${QT_APPS[@]}"; do
if [[ -f "$LOCAL_APPS/$app" ]]; then
touch "$LOCAL_APPS/$app" 2>/dev/null && echo -e "${GREEN}${T_FS_TRIGGERED}${NC}"
break
fi
done
fi
echo -e "${GREEN}${T_GNOME_VISIBLE}${NC}"
fi
else
echo ""
echo -e "${GREEN}${T_NO_CHANGES}${NC}"
fi
echo ""
echo -e "${GREEN}=== ${T_DONE} ===${NC}"
echo ""
echo -e "${BLUE}${T_STATUS}${NC}"
echo ""
if [ "$GNOME_INSTALLED" = true ]; then
echo -e "${YELLOW}${T_KDE_STATUS}${NC}"
echo " ${T_GNOME_MENU_FOLDER}"
echo " - ${#GTK_APPS[@]} ${T_GNOME_APPS_GROUPED}"
[ $NEWLY_MODIFIED_GTK -gt 0 ] && echo " - ${NEWLY_MODIFIED_GTK} ${T_NEW_ADDED}"
echo ""
fi
if [ "$KDE_INSTALLED" = true ]; then
echo -e "${YELLOW}${T_GNOME_STATUS}${NC}"
echo " ${T_KDE_GRID_FOLDER}"
echo " - ${#QT_APPS[@]} ${T_KDE_APPS_GROUPED}"
[ $NEWLY_MODIFIED_KDE -gt 0 ] && echo " - ${NEWLY_MODIFIED_KDE} ${T_NEW_ADDED}"
echo ""
fi
echo -e "${BLUE}${T_OTHER_NOT_CHANGED} ${#OTHER_APPS[@]} ${T_OTHER_NOT_CHANGED2}${NC}"
echo ""
if [ "$STRICT_MODE" = true ]; then
echo -e "${CYAN}${T_HINT_STRICT}${NC}"
echo -e "${CYAN}${T_HINT_MANUAL}${NC}"
fi
echo ""
Zuletzt bearbeitet:
)
