Commit be4ed3f
14
plików
+3731
dodanych
-0
usuniętych
@@ -0,0 +1,4 @@
1 +# Artefakty budowy
2 +pagan-welcome
3 +*.o
4 +__pycache__/
0 5 new file mode 100644
@@ -0,0 +1,65 @@
1 +# pagan-welcome – Makefile
2 +#
3 +# Budowa aplikacji GTK3 oraz instalacja plików towarzyszących.
4 +#
5 +# make – zbuduj pagan-welcome
6 +# make install – zainstaluj do $(DESTDIR) (domyślnie system)
7 +# make clean – usuń artefakty
8 +
9 +CC ?= cc
10 +PKG_CONFIG ?= pkg-config
11 +
12 +PKGS := gtk+-3.0 libnotify
13 +
14 +CFLAGS ?= -O2 -g
15 +CFLAGS += -Wall -Wextra -std=gnu11
16 +# GtkStatusIcon jest przestarzałe, ale nadal działa w XFCE i innych DE.
17 +CFLAGS += -Wno-deprecated-declarations
18 +CFLAGS += $(shell $(PKG_CONFIG) --cflags $(PKGS))
19 +
20 +# LDFLAGS podawane z zewnątrz (np. rpath-link do bibliotek rootfs).
21 +LDFLAGS ?=
22 +
23 +LIBS := $(shell $(PKG_CONFIG) --libs $(PKGS))
24 +
25 +PREFIX ?= /usr
26 +BINDIR = $(PREFIX)/bin
27 +APPDIR = $(PREFIX)/share/applications
28 +# Autostart sesji jest systemowy, dlatego NIE pod $(PREFIX).
29 +AUTOSTARTDIR = /etc/xdg/autostart
30 +PIXMAPDIR = $(PREFIX)/share/pixmaps
31 +
32 +OBJS = pagan-welcome.o pw-util.o pw-i18n.o
33 +BIN = pagan-welcome
34 +
35 +all: $(BIN)
36 +
37 +$(BIN): $(OBJS)
38 + $(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
39 +
40 +pagan-welcome.o: pagan-welcome.c pw-util.h pw-i18n.h
41 +pw-util.o: pw-util.c pw-util.h
42 +pw-i18n.o: pw-i18n.c pw-i18n.h
43 +
44 +%.o: %.c
45 + $(CC) $(CFLAGS) -c -o $@ $<
46 +
47 +install: $(BIN)
48 + install -Dm755 $(BIN) $(DESTDIR)$(BINDIR)/pagan-welcome
49 + install -Dm755 pagan-welcome-backend.py \
50 + $(DESTDIR)$(BINDIR)/pagan-welcome-backend
51 + install -Dm644 pagan-welcome.desktop \
52 + $(DESTDIR)$(APPDIR)/pagan-welcome.desktop
53 + install -Dm644 pagan-welcome-updates.desktop \
54 + $(DESTDIR)$(APPDIR)/pagan-welcome-updates.desktop
55 + install -Dm644 pagan-welcome-autostart.desktop \
56 + $(DESTDIR)$(AUTOSTARTDIR)/pagan-welcome.desktop
57 + if [ -f pagan-welcome.png ]; then \
58 + install -Dm644 pagan-welcome.png \
59 + $(DESTDIR)$(PIXMAPDIR)/pagan-welcome.png; \
60 + fi
61 +
62 +clean:
63 + rm -f $(OBJS) $(BIN)
64 +
65 +.PHONY: all install clean
0 66 new file mode 100644
@@ -0,0 +1,127 @@
1 +# Pagan-Welcome
2 +
3 +Centrum startowe **PaganLinux** – jedno okno, z którego nowy użytkownik może
4 +poznać system, zainstalować go, zaktualizować i dobrać podstawowe ustawienia.
5 +
6 +Interfejs zbudowany jest na **GTK3** (natywnie dla tej dystrybucji, bez
7 +dodatkowych zależności w obrazie). Ciężkie zadania sieciowe i parsowanie
8 +(HTML dokumentacji, JSON repozytorium) wykonuje backend w Pythonie
9 +(`pagan-welcome-backend`), dzięki czemu warstwa GTK zajmuje się wyłącznie
10 +prezentacją.
11 +
12 +## Funkcje
13 +
14 +| Sekcja | Co robi |
15 +| --- | --- |
16 +| **Nowości** | Pobiera informacje o wydaniach z <https://docs.paganlinux.eu/docs/paganlinux> i pokazuje je jako listę zmian. Działa też offline (ostatnia pobrana wersja z pamięci podręcznej). |
17 +| **Instalator** | Uruchamia instalator Calamares – aktywny wyłącznie w sesji live (z pendrive'a/ISO). |
18 +| **Aktualizacja** | `pag update` + `pag upgrade` (system rolling). Dodatkowo przycisk uruchamiający aktualizację w oknie terminala. |
19 +| **Sklep** | Przeglądanie i wyszukiwanie pakietów z repozytorium PAG oraz instalacja/usuwanie przez `pag`. |
20 +| **Ustawienia** | Język, układ klawiatury, strefa czasowa, nazwa komputera, połączenie Wi-Fi. |
21 +
22 +Interfejs jest **dwujęzyczny (PL/EN)**. Język wybiera się w nagłówku i jest
23 +zapamiętywany w `~/.config/pagan-welcome/config.ini`.
24 +
25 +## Tryby uruchomienia
26 +
27 +```sh
28 +pagan-welcome # okno główne
29 +pagan-welcome --page update # od razu strona aktualizacji
30 +pagan-welcome --page store # od razu sklep
31 +pagan-welcome --tray # aplet tray + powiadomienia (autostart)
32 +pagan-welcome --check # wypisz liczbę dostępnych aktualizacji (CLI)
33 +pagan-welcome --version
34 +```
35 +
36 +### Aplet panelu (tray)
37 +
38 +`pagan-welcome --tray` działa w tle jako aplet: pokazuje ikonę w tacce
39 +systemowej panelu (XFCE: wtyczka *systray*), cyklicznie (co 6 h) sprawdza
40 +aktualizacje przez `pag update`, a gdy są dostępne – wysyła powiadomienie
41 +(libnotify) i zmienia podpowiedź ikony. Menu apletu pozwala sprawdzić
42 +aktualizacje, uruchomić aktualizację, otworzyć Pagan-Welcome lub ustawienia.
43 +
44 +Aplet startuje automatycznie przy logowaniu
45 +(`/etc/xdg/autostart/pagan-welcome.desktop`).
46 +
47 +### „Nie pokazuj tego okna przy logowaniu”
48 +
49 +Pole wyboru w nagłówku zapisuje `show_on_login=false` w konfiguracji. Aplet
50 +nadal działa w tle – ukrywane jest tylko okno główne. Aby je przywrócić,
51 +odznacz pole (albo ustaw `show_on_login=true`).
52 +
53 +## Aktualizacja: aplikacja czy terminal?
54 +
55 +`pag` pyta o potwierdzenie przed operacją (`_ask_confirm`). Bez terminala
56 +brak odpowiedzi na `input()` daje `EOFError`, dlatego **domyślnie anuluje**
57 +operację. Z tego powodu aplikacja:
58 +
59 +* uruchamia `pag` z `PAG_YES=1` (potwierdzenie automatyczne) i bez TTY
60 + (kolory i interaktywne paski postępu są wtedy wyłączone – `pag` sam to
61 + wykrywa), a wyjście strumieniuje na bieżąco do pola logu;
62 +* oferuje osobny przycisk **„Aktualizuj w terminalu”**, który otwiera
63 + `sudo pagan-update` w emulatorze terminala – dla użytkowników, którzy chcą
64 + widzieć pełny, kolorowy przebieg i mieć możliwość reakcji.
65 +
66 +Dzięki temu zwykła aktualizacja jest wygodna (integracja w oknie), a wariant
67 +terminalowy pozostaje dostępny, gdy jest potrzebny.
68 +
69 +## Uprawnienia
70 +
71 +Operacje wymagające roota (aktualizacja, instalacja pakietów, zmiana locale)
72 +wykonuje warstwa uprawnień:
73 +
74 +1. jako root – bezpośrednio,
75 +2. `pkexec` – gdy w sesji działa agent polkit (graficzne okno autoryzacji),
76 +3. `sudo -S` – w przeciwnym razie (aplikacja prosi wtedy o hasło w okienku).
77 +
78 +## Budowa i instalacja
79 +
80 +```sh
81 +make # zbuduj pagan-welcome
82 +sudo make install # zainstaluj do systemu
83 +```
84 +
85 +Wymagania budowy: `gtk+-3.0`, `libnotify` (pkg-config), kompilator C11.
86 +
87 +Instalowane pliki:
88 +
89 +| Plik | Przeznaczenie |
90 +| --- | --- |
91 +| `/usr/bin/pagan-welcome` | aplikacja (okno + tray) |
92 +| `/usr/bin/pagan-welcome-backend` | backend: nowości, repo, ustawienia (TSV) |
93 +| `/usr/share/applications/pagan-welcome.desktop` | wpis „Pagan-Welcome” |
94 +| `/usr/share/applications/pagan-welcome-updates.desktop` | wpis „Aktualizacje PaganLinux” |
95 +| `/etc/xdg/autostart/pagan-welcome.desktop` | aplet startujący przy logowaniu |
96 +| `/usr/share/pixmaps/pagan-welcome.png` | ikona (z `branding/`) |
97 +
98 +## Backend CLI
99 +
100 +Backend wypisuje dane w formacie TSV (jedna linia = jedno zdarzenie):
101 +
102 +```sh
103 +pagan-welcome-backend news pl # UPDATED/CACHED/TITLE/REL/NOTE
104 +pagan-welcome-backend repo # PKG: nazwa, wersja, rozmiar, opis, zależności, licencja
105 +pagan-welcome-backend installed # INST: nazwa, wersja
106 +pagan-welcome-backend updates # UPDATES: liczba
107 +pagan-welcome-backend sysinfo # LOCALE/KEYMAP/TIMEZONE/HOSTNAME/LIVE/CALAMARES/PAG
108 +pagan-welcome-backend timezones # TZ: lista stref
109 +```
110 +
111 +Dzięki temu backend da się testować i wywoływać niezależnie od GUI.
112 +
113 +## Dodawanie języka
114 +
115 +1. Dopisz kod i nazwę w `pw-i18n.c` (tablica `TABLE`) oraz – jeśli trzeba –
116 + locale w `LOCALE_BY_LANG`.
117 +2. Uzupełnij tłumaczenia nowych kluczy.
118 +
119 +Brakujący klucz jest po cichu uzupełniany z polskiego, więc aplikacja nigdy
120 +nie pokaże surowego identyfikatora.
121 +
122 +## Tłumaczenia treści nowości
123 +
124 +Treść nowości pochodzi ze strony dokumentacji i zależy od tego, jakie wersje
125 +językowe udostępnia serwer. Serwer (patrz `blueprints/docs.py`) przekierowuje
126 +na istniejącą wersję językową, więc gdy danego dokumentu nie ma po angielsku,
127 +wyświetlona zostanie wersja polska – to zachowanie serwera, nie aplikacji.
0 128 new file mode 100755
@@ -0,0 +1,63 @@
1 +#!/bin/bash
2 +# build-in-rootfs.sh – zbuduj i zainstaluj Pagan-Welcome w rootfs PaganLinux.
3 +#
4 +# Używane przez build-pagan.sh (install_pagan_welcome) oraz ręcznie:
5 +# ./build-in-rootfs.sh [ROOTFS]
6 +#
7 +# Kompiluje na hoście, ale przeciwko NAGŁÓWkom i BIBLIOTEKOM z rootfs
8 +# (PKG_CONFIG_PATH wskazuje .pc rootfs, których `prefix` prowadzi do
9 +# $ROOTFS/usr) – tak samo, jak builder buduje XFCE. Gotowy program linkuje
10 +# się z sonamami libgtk-3.so.0 itd., które w systemie docelowym są w /usr/lib64.
11 +set -euo pipefail
12 +
13 +ROOTFS="${1:-${PAGAN_ROOT:-/mnt/pagan}}"
14 +SRC="$(cd "$(dirname "$0")" && pwd)"
15 +
16 +die() { echo " ✗ pagan-welcome: $*" >&2; exit 1; }
17 +info() { echo " $*"; }
18 +
19 +[ -d "$ROOTFS/usr" ] || die "brak rootfs: $ROOTFS"
20 +command -v pkg-config >/dev/null 2>&1 || die "brak pkg-config"
21 +command -v make >/dev/null 2>&1 || die "brak make"
22 +
23 +# .pc z rootfs mają w środku bezwzględny prefix (/…/usr), więc wystarczy
24 +# dopisać ich katalogi do ścieżki wyszukiwania. NIE ustawiamy PKG_CONFIG_LIBDIR
25 +# (to zastąpiłoby domyślne katalogi – brakujące .pc, np. xrender, bierzemy
26 +# z hosta, tak jak builder przy budowie XFCE).
27 +export PKG_CONFIG_PATH="$ROOTFS/usr/lib64/pkgconfig:$ROOTFS/usr/lib/pkgconfig:$ROOTFS/usr/lib/x86_64-linux-gnu/pkgconfig:$ROOTFS/usr/share/pkgconfig"
28 +unset PKG_CONFIG_LIBDIR PKG_CONFIG_SYSROOT_DIR || true
29 +
30 +pkg-config --exists gtk+-3.0 || die "rootfs bez gtk+-3.0 (dev) – zbuduj środowisko graficzne"
31 +pkg-config --exists libnotify || die "rootfs bez libnotify – zbuduj środowisko graficzne"
32 +# Kontrola, czy udało się zebrać katalogi nagłówków z rootfs (nie z hosta).
33 +case " $(pkg-config --cflags gtk+-3.0) " in
34 + *"$ROOTFS"*) ;;
35 + *) die "pkg-config nie wskazuje nagłówków rootfs – sprawdź PKG_CONFIG_PATH" ;;
36 +esac
37 +
38 +# rpath-link: linker musi rozwiązać zależności przechodnie z bibliotek rootfs.
39 +export LDFLAGS="-Wl,-rpath-link,$ROOTFS/usr/lib64 -Wl,-rpath-link,$ROOTFS/usr/lib"
40 +
41 +info "buduję pagan-welcome (rootfs: $ROOTFS, gtk $(pkg-config --modversion gtk+-3.0))"
42 +make -C "$SRC" clean >/dev/null 2>&1 || true
43 +make -C "$SRC" >/dev/null
44 +
45 +info "instaluję pliki"
46 +make -C "$SRC" install DESTDIR="$ROOTFS" PREFIX=/usr >/dev/null
47 +
48 +# Ikona z brandingu projektu.
49 +BRANDING_ICON="$SRC/../branding/pagan-loki-pingwin.png"
50 +if [ -f "$BRANDING_ICON" ]; then
51 + install -Dm644 "$BRANDING_ICON" "$ROOTFS/usr/share/pixmaps/pagan-welcome.png"
52 + info "ikona: /usr/share/pixmaps/pagan-welcome.png"
53 +fi
54 +
55 +# Skrót „Aktualizacje" na pulpicie live (root) – obok ikony instalatora.
56 +if [ -d "$ROOTFS/root/Desktop" ]; then
57 + cp -a "$ROOTFS/usr/share/applications/pagan-welcome-updates.desktop" \
58 + "$ROOTFS/root/Desktop/pagan-welcome-updates.desktop"
59 + chmod 755 "$ROOTFS/root/Desktop/pagan-welcome-updates.desktop"
60 + info "live: ikona aktualizacji na pulpicie"
61 +fi
62 +
63 +info "gotowe: $ROOTFS/usr/bin/pagan-welcome"
0 64 new file mode 100755
@@ -0,0 +1,15 @@
1 +[Desktop Entry]
2 +Type=Application
3 +Version=1.0
4 +Name=Pagan-Welcome tray
5 +Name[pl]=Pagan-Welcome (tacka systemowa)
6 +Comment=Notify about PaganLinux updates
7 +Comment[pl]=Powiadamiaj o aktualizacjach PaganLinux
8 +Exec=/usr/bin/pagan-welcome --tray
9 +Icon=pagan-welcome
10 +Terminal=false
11 +Categories=System;Utility;
12 +# Uruchamiane przy logowaniu w każdej sesji graficznej. Okno główne pokazuje
13 +# się tylko wtedy, gdy w ~/.config/pagan-welcome/config.ini show_on_login=true
14 +# (przełącznik „Nie pokazuj tego okna przy logowaniu").
15 +X-GNOME-Autostart-enabled=true
0 16 new file mode 100755
@@ -0,0 +1,731 @@
1 +#!/usr/bin/env python3
2 +# -*- coding: utf-8 -*-
3 +"""Pagan-Welcome – logika zaplecza i CLI dla interfejsu GTK.
4 +
5 +Moduł dostarcza czyste funkcje do pobierania i parsowania nowości oraz
6 +repozytorium PAG, odczytu stanu zainstalowanych pakietów i ustawień systemu.
7 +Uruchomiony z argumentem działa też jako CLI dla aplikacji GTK
8 +(`pagan-welcome`), wypisując dane w prostym formacie TSV:
9 +
10 + pagan-welcome-backend.py news <pl|en>
11 + pagan-welcome-backend.py repo
12 + pagan-welcome-backend.py installed
13 + pagan-welcome-backend.py updates
14 + pagan-welcome-backend.py sysinfo
15 + pagan-welcome-backend.py timezones
16 +
17 +Dzięki temu ciężkie parsowanie (HTML, JSON) zostaje w Pythonie, a warstwa
18 +GTK w C zajmuje się wyłącznie prezentacją.
19 +"""
20 +
21 +import json
22 +import os
23 +import re
24 +import shutil
25 +import subprocess
26 +import sys
27 +import time
28 +import urllib.error
29 +import urllib.request
30 +from html.parser import HTMLParser
31 +
32 +# ── Adresy i ścieżki ──────────────────────────────────────────────────────
33 +DOCS_URL = "https://docs.paganlinux.eu/docs/paganlinux"
34 +REPO_JSON_URL = "https://repo.paganlinux.eu/stable/repo.json"
35 +USER_AGENT = "Pagan-Welcome/1.0 (+https://paganlinux.eu)"
36 +HTTP_TIMEOUT = 20
37 +
38 +HOME = os.path.expanduser("~")
39 +CONFIG_DIR = os.path.join(HOME, ".config", "pagan-welcome")
40 +CACHE_DIR = os.path.join(HOME, ".cache", "pagan-welcome")
41 +CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
42 +
43 +PAG_DB = "/var/lib/pag/installed.json"
44 +PAG_WORLD = "/var/lib/pag/world"
45 +PAG_BIN = "/usr/bin/pag"
46 +CALAMARES_BIN = "/usr/bin/calamares"
47 +
48 +# Nazwa pakietu: bezpieczna, bez spacji i znaków powłoki (walidacja przed
49 +# przekazaniem do `pag`/`pkexec`).
50 +PKG_NAME_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._+@-]*$")
51 +
52 +
53 +# ── Konfiguracja użytkownika ──────────────────────────────────────────────
54 +def load_config():
55 + """Wczytaj konfigurację (~/.config/pagan-welcome/config.json)."""
56 + try:
57 + with open(CONFIG_FILE, encoding="utf-8") as fh:
58 + data = json.load(fh)
59 + if isinstance(data, dict):
60 + return data
61 + except (OSError, ValueError):
62 + pass
63 + return {}
64 +
65 +
66 +def save_config(cfg):
67 + """Zapisz konfigurację; błędy zapisu nie przerywają działania aplikacji."""
68 + try:
69 + os.makedirs(CONFIG_DIR, exist_ok=True)
70 + tmp = CONFIG_FILE + ".new"
71 + with open(tmp, "w", encoding="utf-8") as fh:
72 + json.dump(cfg, fh, indent=2, ensure_ascii=False)
73 + os.replace(tmp, CONFIG_FILE)
74 + return True
75 + except OSError:
76 + return False
77 +
78 +
79 +def detect_lang(cfg=None):
80 + """Ustal język: konfiguracja → $LANG → polski."""
81 + cfg = cfg if cfg is not None else load_config()
82 + lang = (cfg.get("lang") or "").strip().lower()
83 + if lang in ("pl", "en"):
84 + return lang
85 + env = os.environ.get("LC_ALL") or os.environ.get("LC_MESSAGES") or os.environ.get("LANG") or ""
86 + if env.lower().startswith("pl"):
87 + return "pl"
88 + if env.lower().startswith("en"):
89 + return "en"
90 + return "pl"
91 +
92 +
93 +# ── Wykrywanie środowiska ─────────────────────────────────────────────────
94 +def is_root():
95 + return hasattr(os, "geteuid") and os.geteuid() == 0
96 +
97 +
98 +def have(cmd):
99 + """Czy polecenie jest dostępne w PATH (albo jako ścieżka absolutna)."""
100 + if os.path.isabs(cmd):
101 + return os.path.exists(cmd)
102 + return shutil.which(cmd) is not None
103 +
104 +
105 +def is_live():
106 + """Czy działamy w sesji live (ISO/pendrive), a nie z zainstalowanego dysku.
107 +
108 + Trzy niezależne sygnały: parametr jądra `pagan.live`/`live`, katalogi
109 + montowania systemu live oraz root na overlayu (tak montuje go initramfs).
110 + """
111 + try:
112 + with open("/proc/cmdline", encoding="utf-8", errors="replace") as fh:
113 + cmdline = fh.read()
114 + except OSError:
115 + cmdline = ""
116 + if "pagan.live" in cmdline or re.search(r"(?:^|\s)live(?:\s|$)", cmdline):
117 + return True
118 + for marker in ("/run/live", "/lib/live/mount", "/live/root"):
119 + if os.path.isdir(marker):
120 + return True
121 + try:
122 + with open("/proc/mounts", encoding="utf-8", errors="replace") as fh:
123 + for line in fh:
124 + parts = line.split()
125 + if len(parts) >= 3 and parts[1] == "/" and parts[2] == "overlay":
126 + return True
127 + except OSError:
128 + pass
129 + return False
130 +
131 +
132 +def format_size(num):
133 + """Rozmiar w bajtach → czytelny zapis (np. 1,2 MB)."""
134 + try:
135 + num = float(num)
136 + except (TypeError, ValueError):
137 + return "?"
138 + for unit in ("B", "KB", "MB", "GB", "TB"):
139 + if num < 1024 or unit == "TB":
140 + if unit == "B":
141 + return "%d %s" % (int(num), unit)
142 + return "%.1f %s" % (num, unit)
143 + num /= 1024.0
144 + return "?"
145 +
146 +
147 +# ── HTTP ──────────────────────────────────────────────────────────────────
148 +# Ponowienia dla BŁĘDÓW PRZEJŚCIOWYCH. Powód: w świeżo zalogowanej sesji LIVE
149 +# NetworkManager potrafi podnieść interfejs DOPIERO po starcie pagan-welcome
150 +# (autostart sesji), więc pierwsze zapytanie kończy się „Network is unreachable”
151 +# i okno pokazywało puste „Nowości”, mimo że chwilę później sieć już działa.
152 +HTTP_RETRIES = 3 # łącznie próby (pierwsza + ponowienia)
153 +HTTP_RETRY_DELAY = 3.0 # sekundy przerwy między próbami
154 +
155 +
156 +def http_get(url, timeout=HTTP_TIMEOUT, retries=HTTP_RETRIES):
157 + """Pobierz URL i zwróć treść jako tekst (UTF-8).
158 +
159 + Błąd HTTP (4xx/5xx) NIE jest ponawiany – to nie usterka sieci. Ponawiamy
160 + tylko błędy przejściowe (brak trasy, DNS, przekroczony czas). Rzuca OSError.
161 + """
162 + attempts = max(1, int(retries))
163 + last = None
164 + for attempt in range(attempts):
165 + try:
166 + req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
167 + with urllib.request.urlopen(req, timeout=timeout) as resp:
168 + raw = resp.read()
169 + return raw.decode("utf-8", errors="replace")
170 + except urllib.error.HTTPError:
171 + raise
172 + except (urllib.error.URLError, OSError) as exc:
173 + last = exc
174 + if attempt + 1 < attempts:
175 + time.sleep(HTTP_RETRY_DELAY)
176 + raise last
177 +
178 +
179 +# ── Nowości (docs.paganlinux.eu) ──────────────────────────────────────────
180 +class _MarkdownBodyParser(HTMLParser):
181 + """Wyciąga bloki (akapit, nagłówek, cytat, lista) z <div class="markdown-body">.
182 +
183 + Strona docs renderuje treść z Markdownu do HTML, więc zamiast zgadywać
184 + strukturę, zbieramy kolejne bloki i grupujemy je w wydania.
185 + """
186 +
187 + _BLOCK_TAGS = ("p", "h1", "h2", "h3", "h4", "h5", "h6", "blockquote", "li")
188 +
189 + def __init__(self):
190 + super().__init__(convert_charrefs=True)
191 + self.in_body = False
192 + self.body_depth = 0
193 + self.blocks = []
194 + self._cur = None
195 + self._buf = []
196 +
197 + def handle_starttag(self, tag, attrs):
198 + if not self.in_body:
199 + if tag == "div" and "markdown-body" in (dict(attrs).get("class") or ""):
200 + self.in_body = True
201 + self.body_depth = 1
202 + return
203 + if tag == "div":
204 + self.body_depth += 1
205 + elif tag == "br":
206 + self._buf.append("\n")
207 + elif tag in self._BLOCK_TAGS and self._cur is None:
208 + self._cur = tag
209 + self._buf = []
210 +
211 + def handle_endtag(self, tag):
212 + if not self.in_body:
213 + return
214 + if tag == "div":
215 + self.body_depth -= 1
216 + if self.body_depth <= 0:
217 + self._flush()
218 + self.in_body = False
219 + return
220 + if tag in self._BLOCK_TAGS and self._cur == tag:
221 + self._flush()
222 +
223 + def handle_data(self, data):
224 + if self.in_body and self._cur is not None:
225 + self._buf.append(data)
226 +
227 + def _flush(self):
228 + text = "".join(self._buf).strip()
229 + if text:
230 + self.blocks.append({"tag": self._cur, "text": text})
231 + self._cur = None
232 + self._buf = []
233 +
234 +
235 +_RELEASE_RE = re.compile(
236 + r"^\s*(?:wydanie|wersja|release|version)\b", re.IGNORECASE)
237 +_VERSION_RE = re.compile(r"\b\d+\.\d+(?:\.\d+)?\b")
238 +
239 +
240 +def _looks_like_release(text):
241 + """Czy akapit/nagłówek rozpoczyna nowe wydanie?"""
242 + if _RELEASE_RE.match(text):
243 + return True
244 + # Krótki nagłówek z numerem wersji, np. "0.1.2 Mokosza".
245 + if len(text) <= 60 and _VERSION_RE.search(text):
246 + return True
247 + return False
248 +
249 +
250 +def parse_news_html(html):
251 + """Zamień HTML strony docs na strukturę {title, releases:[{title, notes}]}."""
252 + title = ""
253 + m = re.search(r'<h1[^>]*class="[^"]*dv-title[^"]*"[^>]*>(.*?)</h1>', html, re.S)
254 + if m:
255 + title = re.sub(r"<[^>]+>", "", m.group(1)).strip()
256 + if not title:
257 + m = re.search(r"<title>(.*?)</title>", html, re.S)
258 + if m:
259 + title = re.sub(r"\s*[–|-]\s*PaganOS.*$", "", m.group(1)).strip()
260 +
261 + parser = _MarkdownBodyParser()
262 + try:
263 + parser.feed(html)
264 + except Exception:
265 + pass
266 +
267 + releases = []
268 + current = None
269 + for block in parser.blocks:
270 + text = block["text"]
271 + if block["tag"] in ("p", "h1", "h2", "h3", "h4", "h5", "h6") and _looks_like_release(text):
272 + current = {"title": text, "notes": []}
273 + releases.append(current)
274 + continue
275 + if current is None:
276 + current = {"title": title or "", "notes": []}
277 + releases.append(current)
278 + # Notatki: rozbij wielolinijkowe cytaty na osobne punkty.
279 + for line in text.splitlines():
280 + line = line.strip()
281 + if line:
282 + current["notes"].append(line)
283 +
284 + # Usuń puste wydania (bez tytułu i notatek).
285 + releases = [r for r in releases if r["title"] or r["notes"]]
286 + return {"title": title, "releases": releases}
287 +
288 +
289 +def _cache_path(name):
290 + return os.path.join(CACHE_DIR, name)
291 +
292 +
293 +def _write_cache(name, payload):
294 + try:
295 + os.makedirs(CACHE_DIR, exist_ok=True)
296 + tmp = _cache_path(name) + ".new"
297 + with open(tmp, "w", encoding="utf-8") as fh:
298 + json.dump(payload, fh, ensure_ascii=False)
299 + os.replace(tmp, _cache_path(name))
300 + except OSError:
301 + pass
302 +
303 +
304 +def _read_cache(name):
305 + try:
306 + with open(_cache_path(name), encoding="utf-8") as fh:
307 + return json.load(fh)
308 + except (OSError, ValueError):
309 + return None
310 +
311 +
312 +def fetch_news(lang="pl", force=False):
313 + """Pobierz nowości dla języka `lang`.
314 +
315 + Zwraca dict: {title, releases, source, updated, cached, error}.
316 + Przy braku sieci zwraca ostatnią zapamiętaną wersję (jeśli jest).
317 + """
318 + cache_name = "news-%s.json" % lang
319 + url = "%s?lang=%s" % (DOCS_URL, lang)
320 + result = {
321 + "title": "",
322 + "releases": [],
323 + "source": url,
324 + "updated": None,
325 + "cached": False,
326 + "error": None,
327 + }
328 +
329 + if not force:
330 + cached = _read_cache(cache_name)
331 + if cached:
332 + result.update(cached)
333 + result["cached"] = True
334 + return result
335 +
336 + try:
337 + html = http_get(url)
338 + parsed = parse_news_html(html)
339 + result["title"] = parsed["title"]
340 + result["releases"] = parsed["releases"]
341 + result["updated"] = time.strftime("%Y-%m-%d %H:%M")
342 + result["cached"] = False
343 + _write_cache(cache_name, {
344 + "title": result["title"],
345 + "releases": result["releases"],
346 + "updated": result["updated"],
347 + })
348 + return result
349 + except (OSError, ValueError) as exc:
350 + cached = _read_cache(cache_name)
351 + if cached:
352 + result.update(cached)
353 + result["cached"] = True
354 + result["error"] = str(exc)
355 + return result
356 + result["error"] = str(exc)
357 + return result
358 +
359 +
360 +# ── Repozytorium PAG ──────────────────────────────────────────────────────
361 +def fetch_repo(force=False):
362 + """Pobierz indeks repozytorium (repo.json).
363 +
364 + Zwraca dict: {packages, updated, cached, error}. `packages` to lista
365 + słowników z polami name/version/release/size/description/depends/license.
366 + """
367 + result = {"packages": [], "updated": None, "cached": False, "error": None}
368 +
369 + if not force:
370 + cached = _read_cache("repo.json")
371 + if cached:
372 + result.update(cached)
373 + result["cached"] = True
374 + return result
375 +
376 + try:
377 + raw = http_get(REPO_JSON_URL)
378 + data = json.loads(raw)
379 + packages = data.get("packages") or []
380 + if not isinstance(packages, list):
381 + packages = []
382 + result["packages"] = packages
383 + result["updated"] = data.get("updated") or time.strftime("%Y-%m-%d %H:%M")
384 + result["cached"] = False
385 + _write_cache("repo.json", {
386 + "packages": packages,
387 + "updated": result["updated"],
388 + })
389 + return result
390 + except (OSError, ValueError) as exc:
391 + cached = _read_cache("repo.json")
392 + if cached:
393 + result.update(cached)
394 + result["cached"] = True
395 + result["error"] = str(exc)
396 + return result
397 + result["error"] = str(exc)
398 + return result
399 +
400 +
401 +def installed_packages():
402 + """Zwróć mapę nazwa → wpis z bazy pag (/var/lib/pag/installed.json)."""
403 + try:
404 + with open(PAG_DB, encoding="utf-8") as fh:
405 + data = json.load(fh)
406 + if isinstance(data, dict):
407 + return data
408 + except (OSError, ValueError):
409 + pass
410 + return {}
411 +
412 +
413 +def world_packages():
414 + """Pakiety zainstalowane świadomie (/var/lib/pag/world) – zbiór nazw."""
415 + try:
416 + with open(PAG_WORLD, encoding="utf-8") as fh:
417 + return {line.strip() for line in fh if line.strip()}
418 + except OSError:
419 + return set()
420 +
421 +
422 +def valid_package_name(name):
423 + return bool(name) and bool(PKG_NAME_RE.match(name))
424 +
425 +
426 +# ── Uruchamianie poleceń ──────────────────────────────────────────────────
427 +def run_stream(cmd, on_line=None, env=None, input_text=None, cwd=None):
428 + """Uruchom polecenie, strumieniując wyjście linia po linii.
429 +
430 + `on_line(line)` jest wołane dla każdej linii (stdout+stderr razem).
431 + `input_text` trafia na stdin (np. hasło sudo). Zwraca kod wyjścia.
432 + """
433 + full_env = dict(os.environ)
434 + if env:
435 + full_env.update(env)
436 + try:
437 + proc = subprocess.Popen(
438 + cmd, cwd=cwd, env=full_env,
439 + stdin=subprocess.PIPE if input_text is not None else subprocess.DEVNULL,
440 + stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
441 + text=True, errors="replace", bufsize=1,
442 + )
443 + except (OSError, ValueError) as exc:
444 + if on_line:
445 + on_line("! %s" % exc)
446 + return 127
447 +
448 + if input_text is not None:
449 + try:
450 + proc.stdin.write(input_text)
451 + proc.stdin.flush()
452 + except (OSError, ValueError):
453 + pass
454 + finally:
455 + try:
456 + proc.stdin.close()
457 + except (OSError, ValueError):
458 + pass
459 +
460 + try:
461 + for line in proc.stdout:
462 + if on_line:
463 + on_line(line.rstrip("\n"))
464 + except (OSError, ValueError):
465 + pass
466 + finally:
467 + try:
468 + proc.stdout.close()
469 + except (OSError, ValueError):
470 + pass
471 + proc.wait()
472 + return proc.returncode
473 +
474 +
475 +def _polkit_agent_running():
476 + """Czy w sesji działa agent polkit (wtedy pkexec ma kto pokazać okno)?."""
477 + for name in ("polkit-gnome-authentication-agent-1", "xfce-polkit",
478 + "polkit-kde-authentication-agent-1", "mate-polkit",
479 + "lxpolkit", "polkit-mate-authentication-agent-1"):
480 + try:
481 + if subprocess.run(["pgrep", "-x", name],
482 + stdout=subprocess.DEVNULL,
483 + stderr=subprocess.DEVNULL).returncode == 0:
484 + return True
485 + except OSError:
486 + break
487 + return False
488 +
489 +
490 +def privileged_prefix():
491 + """Prefiks polecenia z uprawnieniami root.
492 +
493 + - root → brak prefiksu,
494 + - pkexec (gdy działa agent polkit) → graficzne okno autoryzacji,
495 + - w przeciwnym razie sudo -S (hasło podaje wywołujący).
496 + """
497 + if is_root():
498 + return []
499 + if have("pkexec") and _polkit_agent_running():
500 + return ["pkexec"]
501 + if have("sudo"):
502 + return ["sudo", "-S"]
503 + return []
504 +
505 +
506 +def run_privileged(cmd, on_line=None, env=None, password=None):
507 + """Uruchom polecenie z uprawnieniami root.
508 +
509 + `password` jest używane tylko wtedy, gdy prefiks to sudo -S.
510 + Zwraca kod wyjścia (127, gdy nie ma jak podnieść uprawnień).
511 + """
512 + prefix = privileged_prefix()
513 + if not prefix and not is_root():
514 + if on_line:
515 + on_line("! Brak pkexec/sudo – nie mogę podnieść uprawnień.")
516 + return 127
517 +
518 + full = list(prefix)
519 + if env:
520 + full.append("env")
521 + full.extend("%s=%s" % (k, v) for k, v in env.items())
522 + full.extend(cmd)
523 +
524 + input_text = None
525 + if prefix[:1] == ["sudo"]:
526 + input_text = (password or "") + "\n"
527 + return run_stream(full, on_line=on_line, input_text=input_text)
528 +
529 +
530 +def pag_available():
531 + return have(PAG_BIN) or have("pag")
532 +
533 +
534 +def pag_cmd():
535 + return PAG_BIN if have(PAG_BIN) else "pag"
536 +
537 +
538 +# ── Porównywanie wersji i liczenie aktualizacji ───────────────────────────
539 +def version_key(ver):
540 + """Klucz sortowania wersji: segmenty liczbowe porównywane liczbowo."""
541 + key = []
542 + for part in re.split(r"[._+~-]", str(ver or "")):
543 + if part.isdigit():
544 + key.append((0, int(part), ""))
545 + else:
546 + key.append((1, 0, part))
547 + return key
548 +
549 +
550 +def count_updates(installed, repo_packages):
551 + """Ile zainstalowanych pakietów ma w repo nowszą wersję."""
552 + repo = {p.get("name"): p for p in repo_packages if p.get("name")}
553 + count = 0
554 + for name, entry in (installed or {}).items():
555 + rp = repo.get(name)
556 + if not rp:
557 + continue
558 + iv = str(entry.get("version", ""))
559 + rv = str(rp.get("version", ""))
560 + if iv and rv and version_key(rv) > version_key(iv):
561 + count += 1
562 + return count
563 +
564 +
565 +# ── Bieżące ustawienia systemu (odczyt) ───────────────────────────────────
566 +def _run_capture(cmd, timeout=6):
567 + try:
568 + out = subprocess.run(cmd, stdout=subprocess.PIPE,
569 + stderr=subprocess.DEVNULL, text=True,
570 + errors="replace", timeout=timeout)
571 + return out.stdout.strip()
572 + except (OSError, subprocess.SubprocessError):
573 + return ""
574 +
575 +
576 +def current_locale():
577 + """Kod języka z lokalizacji systemowej (np. 'pl' z 'pl_PL.UTF-8')."""
578 + status = _run_capture(["localectl", "status"])
579 + m = re.search(r"LANG=([A-Za-z_]+)", status)
580 + if m:
581 + return m.group(1).split("_")[0].lower()
582 + return ""
583 +
584 +
585 +def current_keymap():
586 + """Układ klawiatury X11 (np. 'pl')."""
587 + status = _run_capture(["localectl", "status"])
588 + m = re.search(r"X11 Layout:\s*(\S+)", status)
589 + if m:
590 + return m.group(1)
591 + return _run_capture(["localectl", "status"])
592 +
593 +
594 +def current_timezone():
595 + tz = _run_capture(["timedatectl", "show", "-p", "Timezone", "--value"])
596 + if tz:
597 + return tz
598 + try:
599 + with open("/etc/timezone", encoding="utf-8") as fh:
600 + return fh.read().strip()
601 + except OSError:
602 + return ""
603 +
604 +
605 +def current_hostname():
606 + name = _run_capture(["hostname"])
607 + if name:
608 + return name
609 + try:
610 + with open("/etc/hostname", encoding="utf-8") as fh:
611 + return fh.read().strip()
612 + except OSError:
613 + return ""
614 +
615 +
616 +def available_timezones():
617 + """Lista stref czasowych z /usr/share/zoneinfo/zone.tab (posortowana)."""
618 + zones = []
619 + try:
620 + with open("/usr/share/zoneinfo/zone.tab", encoding="utf-8") as fh:
621 + for line in fh:
622 + if line.startswith("#") or not line.strip():
623 + continue
624 + parts = line.split("\t")
625 + if len(parts) >= 3:
626 + zones.append(parts[2].strip())
627 + except OSError:
628 + pass
629 + if not zones:
630 + zones = ["Europe/Warsaw", "Europe/London", "Europe/Berlin",
631 + "America/New_York", "UTC"]
632 + return sorted(set(zones))
633 +
634 +
635 +# ── CLI (TSV) dla interfejsu GTK ──────────────────────────────────────────
636 +def _field(value):
637 + """Pole TSV: bez tabulatorów i znaków nowej linii."""
638 + text = "" if value is None else str(value)
639 + return text.replace("\t", " ").replace("\r", " ").replace("\n", " ")
640 +
641 +
642 +def _emit(*cols):
643 + print("\t".join(_field(c) for c in cols))
644 +
645 +
646 +def _cmd_news(args):
647 + lang = args[0] if args else "pl"
648 + data = fetch_news(lang, force=True)
649 + _emit("UPDATED", data.get("updated") or "")
650 + _emit("CACHED", "1" if data.get("cached") else "0")
651 + _emit("ERROR", data.get("error") or "")
652 + _emit("TITLE", data.get("title") or "")
653 + for rel in data.get("releases") or []:
654 + _emit("REL", rel.get("title") or "")
655 + for note in rel.get("notes") or []:
656 + _emit("NOTE", note)
657 + return 0
658 +
659 +
660 +def _cmd_repo(_args):
661 + data = fetch_repo(force=True)
662 + _emit("UPDATED", data.get("updated") or "")
663 + _emit("CACHED", "1" if data.get("cached") else "0")
664 + _emit("ERROR", data.get("error") or "")
665 + for pkg in data.get("packages") or []:
666 + deps = ",".join(pkg.get("depends") or [])
667 + lic = ",".join(pkg.get("license") or [])
668 + _emit("PKG", pkg.get("name") or "", pkg.get("version") or "",
669 + pkg.get("size") or 0, pkg.get("description") or "", deps, lic)
670 + return 0
671 +
672 +
673 +def _cmd_installed(_args):
674 + for name, entry in sorted(installed_packages().items()):
675 + _emit("INST", name, entry.get("version") or "")
676 + return 0
677 +
678 +
679 +def _cmd_updates(_args):
680 + installed = installed_packages()
681 + repo = fetch_repo()
682 + count = count_updates(installed, repo.get("packages") or [])
683 + _emit("UPDATES", count)
684 + return 0
685 +
686 +
687 +def _cmd_sysinfo(_args):
688 + _emit("LOCALE", current_locale())
689 + _emit("KEYMAP", current_keymap())
690 + _emit("TIMEZONE", current_timezone())
691 + _emit("HOSTNAME", current_hostname())
692 + _emit("LIVE", "1" if is_live() else "0")
693 + _emit("CALAMARES", "1" if have(CALAMARES_BIN) else "0")
694 + _emit("PAG", "1" if pag_available() else "0")
695 + return 0
696 +
697 +
698 +def _cmd_timezones(_args):
699 + for zone in available_timezones():
700 + _emit("TZ", zone)
701 + return 0
702 +
703 +
704 +def main(argv):
705 + if not argv or argv[0] in ("-h", "--help", "help"):
706 + print("Użycie: pagan-welcome-backend.py {news <pl|en>|repo|installed|"
707 + "updates|sysinfo|timezones}")
708 + return 0 if argv else 2
709 + cmd = argv[0]
710 + args = argv[1:]
711 + table = {
712 + "news": _cmd_news,
713 + "repo": _cmd_repo,
714 + "installed": _cmd_installed,
715 + "updates": _cmd_updates,
716 + "sysinfo": _cmd_sysinfo,
717 + "timezones": _cmd_timezones,
718 + }
719 + handler = table.get(cmd)
720 + if handler is None:
721 + print("Nieznane polecenie: %s" % cmd, file=sys.stderr)
722 + return 2
723 + try:
724 + return handler(args)
725 + except (OSError, ValueError) as exc:
726 + print("Błąd: %s" % exc, file=sys.stderr)
727 + return 1
728 +
729 +
730 +if __name__ == "__main__":
731 + sys.exit(main(sys.argv[1:]))
0 732 new file mode 100755
@@ -0,0 +1,13 @@
1 +[Desktop Entry]
2 +Type=Application
3 +Version=1.0
4 +Name=PaganLinux updates
5 +Name[pl]=Aktualizacje PaganLinux
6 +Comment=Check for and install system updates
7 +Comment[pl]=Sprawdź i zainstaluj aktualizacje systemu
8 +Exec=/usr/bin/pagan-welcome --page update
9 +Icon=pagan-welcome
10 +Terminal=false
11 +Categories=System;Settings;
12 +Keywords=update;upgrade;aktualizacje;
13 +StartupNotify=true
0 14 new file mode 100644
@@ -0,0 +1,1919 @@
1 +/* pagan-welcome – centrum startowe PaganLinux (GTK3).
2 + *
3 + * Zbiera w jednym oknie to, co potrzebne na starcie systemu:
4 + * • Nowości – informacje o wydaniach z docs.paganlinux.eu,
5 + * • Instalator – uruchomienie Calamaresa (tylko w sesji live),
6 + * • Aktualizacja – `pag update` + `pag upgrade` (system rolling),
7 + * • Sklep – przeglądanie i instalowanie pakietów z repo PAG,
8 + * • Ustawienia – język, klawiatura, strefa czasowa, nazwa komputera, Wi-Fi.
9 + *
10 + * Ten sam plik wykonywalny w trybie `--tray` działa jako aplet panelu:
11 + * pokazuje ikonę w tacce systemowej, okresowo sprawdza aktualizacje i
12 + * powiadamia o nich (libnotify).
13 + *
14 + * Ciężkie parsowanie (HTML, JSON) wykonuje backend w Pythonie
15 + * (`pagan-welcome-backend`); tu zostaje wyłącznie prezentacja.
16 + *
17 + * Tryby:
18 + * pagan-welcome – okno główne,
19 + * pagan-welcome --tray – aplet tray + powiadomienia o aktualizacjach,
20 + * pagan-welcome --check – sprawdź aktualizacje i wypisz liczbę (CLI),
21 + * pagan-welcome --version – wersja.
22 + */
23 +
24 +#include <gtk/gtk.h>
25 +#include <libnotify/notify.h>
26 +#include <stdlib.h>
27 +#include <string.h>
28 +
29 +#include "pw-i18n.h"
30 +#include "pw-util.h"
31 +
32 +#define PW_VERSION "1.0"
33 +#define PW_CALAMARES "/usr/bin/calamares"
34 +#define PW_TRAY_INTERVAL_SEC (6 * 60 * 60) /* sprawdzanie co 6 godzin */
35 +
36 +/* ── Stan aplikacji ──────────────────────────────────────────────────────── */
37 +typedef struct {
38 + GtkWidget *widget;
39 + char *key;
40 + gboolean is_label;
41 +} TrEntry;
42 +
43 +typedef struct {
44 + char *name;
45 + char *version;
46 + guint64 size;
47 + char *description;
48 + char *depends;
49 + char *license;
50 +} Package;
51 +
52 +typedef struct {
53 + PwConfig *cfg;
54 +
55 + GtkWidget *window;
56 + GtkWidget *stack;
57 + GtkWidget *sidebar;
58 + GtkWidget *lang_combo;
59 + GtkWidget *dont_show_check;
60 + GtkWidget *header_title;
61 + GtkWidget *header_tagline;
62 +
63 + GList *tr_entries; /* TrEntry* */
64 +
65 + /* Nowości */
66 + GtkWidget *news_view;
67 + GtkWidget *news_meta;
68 + GtkWidget *news_refresh;
69 + GtkWidget *news_browser;
70 +
71 + /* Instalator */
72 + GtkWidget *install_status;
73 + GtkWidget *install_btn;
74 + GtkWidget *install_log;
75 +
76 + /* Aktualizacja */
77 + GtkWidget *update_result;
78 + GtkWidget *update_check_btn;
79 + GtkWidget *update_btn;
80 + GtkWidget *update_terminal_btn;
81 + GtkWidget *update_log;
82 + gboolean update_busy;
83 +
84 + /* Sklep */
85 + GtkWidget *store_search;
86 + GtkWidget *store_tree;
87 + GtkListStore *store_model;
88 + GtkTreeModelFilter *store_filter;
89 + GtkWidget *store_count;
90 + GtkWidget *store_details;
91 + GtkWidget *store_install_btn;
92 + GtkWidget *store_remove_btn;
93 + GtkWidget *store_log;
94 + GtkTreeViewColumn *store_col_name;
95 + GtkTreeViewColumn *store_col_version;
96 + GtkTreeViewColumn *store_col_size;
97 + GtkTreeViewColumn *store_col_desc;
98 + GHashTable *packages; /* name -> Package* */
99 + GHashTable *installed; /* name -> char* version */
100 + char *store_selected;
101 +
102 + /* Ustawienia */
103 + GtkWidget *set_lang_combo;
104 + GtkWidget *set_keymap_combo;
105 + GtkWidget *set_tz_combo;
106 + GtkWidget *set_host_entry;
107 + GtkWidget *set_status;
108 + GtkWidget *set_apply_btn;
109 + GtkWidget *set_wifi_btn;
110 +
111 + /* Aplet tray */
112 + gboolean tray_mode;
113 + const char *start_page; /* strona otwierana na starcie (--page) */
114 + GtkStatusIcon *tray_icon;
115 + GtkWidget *tray_menu;
116 + GtkWidget *tray_items[5];
117 + guint tray_timer;
118 + gboolean tray_busy;
119 + /* Liczba dostępnych aktualizacji, o których JUŻ powiadomiliśmy (-1 = o
120 + * żadnych). Aplet sprawdza aktualizacje co 6 h, więc bez tego użytkownik
121 + * dostawał to samo powiadomienie w kółko – patrz tray_check_done(). */
122 + int tray_notified;
123 +} App;
124 +
125 +static App *g_app = NULL;
126 +
127 +enum {
128 + COL_NAME, COL_VERSION, COL_SIZE, COL_DESC, COL_INSTALLED, N_COLS
129 +};
130 +
131 +/* ── Rejestr tłumaczeń ───────────────────────────────────────────────────── */
132 +static void
133 +tr_register(App *app, GtkWidget *w, const char *key, gboolean is_label)
134 +{
135 + TrEntry *e = g_new0(TrEntry, 1);
136 + e->widget = w;
137 + e->key = g_strdup(key);
138 + e->is_label = is_label;
139 + app->tr_entries = g_list_append(app->tr_entries, e);
140 +}
141 +
142 +static void
143 +retranslate(App *app)
144 +{
145 + if (!app->window)
146 + return;
147 + for (GList *l = app->tr_entries; l; l = l->next) {
148 + TrEntry *e = l->data;
149 + if (e->is_label)
150 + gtk_label_set_text(GTK_LABEL(e->widget), pw_tr(e->key));
151 + else
152 + gtk_button_set_label(GTK_BUTTON(e->widget), pw_tr(e->key));
153 + }
154 + gtk_window_set_title(GTK_WINDOW(app->window), pw_tr("app_title"));
155 + gtk_label_set_text(GTK_LABEL(app->header_title), pw_tr("app_title"));
156 + gtk_label_set_text(GTK_LABEL(app->header_tagline), pw_tr("app_tagline"));
157 +
158 + gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(app->store_col_name),
159 + pw_tr("store_col_name"));
160 + gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(app->store_col_version),
161 + pw_tr("store_col_version"));
162 + gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(app->store_col_size),
163 + pw_tr("store_col_size"));
164 + gtk_tree_view_column_set_title(GTK_TREE_VIEW_COLUMN(app->store_col_desc),
165 + pw_tr("store_col_desc"));
166 + if (app->tray_menu) {
167 + static const char *keys[] = {"tray_check", "tray_update", "tray_open",
168 + "tray_settings", "tray_quit"};
169 + for (int i = 0; i < 5; i++)
170 + if (app->tray_items[i])
171 + gtk_menu_item_set_label(GTK_MENU_ITEM(app->tray_items[i]),
172 + pw_tr(keys[i]));
173 + }
174 +}
175 +
176 +/* ── Log (GtkTextView) ───────────────────────────────────────────────────── */
177 +static GtkWidget *
178 +log_new(int height)
179 +{
180 + GtkWidget *view = gtk_text_view_new();
181 + gtk_text_view_set_editable(GTK_TEXT_VIEW(view), FALSE);
182 + gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(view), FALSE);
183 + gtk_text_view_set_monospace(GTK_TEXT_VIEW(view), TRUE);
184 + gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD_CHAR);
185 +
186 + GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
187 + gtk_text_buffer_create_tag(buf, "ok", "foreground", "#2e7d32", NULL);
188 + gtk_text_buffer_create_tag(buf, "err", "foreground", "#c62828", NULL);
189 + gtk_text_buffer_create_tag(buf, "warn", "foreground", "#ef6c00", NULL);
190 + gtk_text_buffer_create_tag(buf, "hdr", "weight", PANGO_WEIGHT_BOLD, NULL);
191 +
192 + GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
193 + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
194 + GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
195 + gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scroll),
196 + height);
197 + gtk_container_add(GTK_CONTAINER(scroll), view);
198 + return scroll;
199 +}
200 +
201 +static GtkTextView *
202 +log_view_of(GtkWidget *scroll)
203 +{
204 + return GTK_TEXT_VIEW(gtk_bin_get_child(GTK_BIN(scroll)));
205 +}
206 +
207 +static void
208 +log_append(GtkWidget *scroll, const char *line, const char *tag)
209 +{
210 + GtkTextView *view = log_view_of(scroll);
211 + GtkTextBuffer *buf = gtk_text_view_get_buffer(view);
212 + GtkTextIter end;
213 + gtk_text_buffer_get_end_iter(buf, &end);
214 + if (tag && *tag)
215 + gtk_text_buffer_insert_with_tags_by_name(buf, &end, line, -1, tag, NULL);
216 + else
217 + gtk_text_buffer_insert(buf, &end, line, -1);
218 + gtk_text_buffer_insert(buf, &end, "\n", -1);
219 + gtk_text_buffer_get_end_iter(buf, &end);
220 + gtk_text_view_scroll_to_iter(view, &end, 0.0, FALSE, 0.0, 0.0);
221 +}
222 +
223 +static void
224 +log_clear(GtkWidget *scroll)
225 +{
226 + GtkTextView *view = log_view_of(scroll);
227 + gtk_text_buffer_set_text(gtk_text_view_get_buffer(view), "", -1);
228 +}
229 +
230 +/* ── Parsowanie TSV ──────────────────────────────────────────────────────── */
231 +static char **
232 +split_tabs(const char *line)
233 +{
234 + return g_strsplit(line, "\t", -1);
235 +}
236 +
237 +/* ── Budowa okna ─────────────────────────────────────────────────────────── */
238 +static GtkWidget *
239 +page_box(void)
240 +{
241 + GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
242 + gtk_container_set_border_width(GTK_CONTAINER(box), 16);
243 +
244 + GtkWidget *title = gtk_label_new(NULL);
245 + gtk_label_set_xalign(GTK_LABEL(title), 0.0);
246 + PangoAttrList *attrs = pango_attr_list_new();
247 + pango_attr_list_insert(attrs, pango_attr_weight_new(PANGO_WEIGHT_BOLD));
248 + pango_attr_list_insert(attrs, pango_attr_scale_new(1.35));
249 + gtk_label_set_attributes(GTK_LABEL(title), attrs);
250 + pango_attr_list_unref(attrs);
251 + gtk_box_pack_start(GTK_BOX(box), title, FALSE, FALSE, 0);
252 +
253 + GtkWidget *sub = gtk_label_new(NULL);
254 + gtk_label_set_xalign(GTK_LABEL(sub), 0.0);
255 + gtk_widget_set_opacity(sub, 0.65);
256 + gtk_box_pack_start(GTK_BOX(box), sub, FALSE, FALSE, 0);
257 +
258 + return box;
259 +}
260 +
261 +static GtkWidget *
262 +build_news_page(App *app)
263 +{
264 + GtkWidget *box = page_box();
265 + /* Tytuł i podtytuł rejestrujemy w rejestrze tłumaczeń. */
266 + GList *kids = gtk_container_get_children(GTK_CONTAINER(box));
267 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 0)), "news_title", TRUE);
268 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 1)), "news_subtitle", TRUE);
269 + g_list_free(kids);
270 +
271 + GtkWidget *bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
272 + app->news_refresh = gtk_button_new_with_label(pw_tr("common_refresh"));
273 + app->news_browser = gtk_button_new_with_label(pw_tr("news_open_browser"));
274 + tr_register(app, app->news_refresh, "common_refresh", FALSE);
275 + tr_register(app, app->news_browser, "news_open_browser", FALSE);
276 + app->news_meta = gtk_label_new("");
277 + gtk_widget_set_opacity(app->news_meta, 0.6);
278 + gtk_box_pack_start(GTK_BOX(bar), app->news_refresh, FALSE, FALSE, 0);
279 + gtk_box_pack_start(GTK_BOX(bar), app->news_browser, FALSE, FALSE, 0);
280 + gtk_box_pack_end(GTK_BOX(bar), app->news_meta, FALSE, FALSE, 0);
281 + gtk_box_pack_start(GTK_BOX(box), bar, FALSE, FALSE, 4);
282 +
283 + app->news_view = gtk_text_view_new();
284 + gtk_text_view_set_editable(GTK_TEXT_VIEW(app->news_view), FALSE);
285 + gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(app->news_view), FALSE);
286 + gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(app->news_view), GTK_WRAP_WORD_CHAR);
287 + gtk_text_view_set_left_margin(GTK_TEXT_VIEW(app->news_view), 10);
288 + gtk_text_view_set_right_margin(GTK_TEXT_VIEW(app->news_view), 10);
289 + GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(app->news_view));
290 + gtk_text_buffer_create_tag(buf, "h", "weight", PANGO_WEIGHT_BOLD,
291 + "scale", 1.15, "pixels-above-lines", 10,
292 + "pixels-below-lines", 4, NULL);
293 + gtk_text_buffer_create_tag(buf, "note", "left-margin", 18, NULL);
294 + gtk_text_buffer_create_tag(buf, "dim", "foreground", "#888888", NULL);
295 +
296 + GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
297 + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
298 + GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
299 + gtk_container_add(GTK_CONTAINER(scroll), app->news_view);
300 + gtk_box_pack_start(GTK_BOX(box), scroll, TRUE, TRUE, 0);
301 + return box;
302 +}
303 +
304 +/* ── Nowości: wczytywanie ────────────────────────────────────────────────── */
305 +static void
306 +news_on_line(const char *line, gpointer data)
307 +{
308 + App *app = data;
309 + char **f = split_tabs(line);
310 + GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(app->news_view));
311 + GtkTextIter end;
312 + gtk_text_buffer_get_end_iter(buf, &end);
313 +
314 + if (g_strcmp0(f[0], "UPDATED") == 0 && f[1]) {
315 + char *txt = g_strdup_printf("%s: %s", pw_tr("news_updated"), f[1]);
316 + gtk_label_set_text(GTK_LABEL(app->news_meta), txt);
317 + g_free(txt);
318 + } else if (g_strcmp0(f[0], "CACHED") == 0 && g_strcmp0(f[1], "1") == 0) {
319 + const char *cur = gtk_label_get_text(GTK_LABEL(app->news_meta));
320 + char *txt = g_strdup_printf("%s • %s", cur, pw_tr("news_cached"));
321 + gtk_label_set_text(GTK_LABEL(app->news_meta), txt);
322 + g_free(txt);
323 + } else if (g_strcmp0(f[0], "ERROR") == 0 && f[1] && *f[1]) {
324 + /* Pokaż PRZYCZYNĘ niepowodzenia (np. brak sieci) obok stanu pobrania.
325 + * Bez tego użytkownik widzi tylko ogólne „nie udało się pobrać” i nie
326 + * wie, czy problemem jest sieć, DNS, certyfikat czy adres serwera. */
327 + const char *cur = gtk_label_get_text(GTK_LABEL(app->news_meta));
328 + char *txt = g_strdup_printf("%s%s%s", cur, *cur ? " • " : "", f[1]);
329 + gtk_label_set_text(GTK_LABEL(app->news_meta), txt);
330 + g_free(txt);
331 + } else if (g_strcmp0(f[0], "TITLE") == 0 && f[1] && *f[1]) {
332 + gtk_text_buffer_insert_with_tags_by_name(buf, &end, f[1], -1, "h", NULL);
333 + gtk_text_buffer_insert(buf, &end, "\n", -1);
334 + } else if (g_strcmp0(f[0], "REL") == 0) {
335 + gtk_text_buffer_insert_with_tags_by_name(buf, &end, f[1] ? f[1] : "", -1,
336 + "h", NULL);
337 + gtk_text_buffer_insert(buf, &end, "\n", -1);
338 + } else if (g_strcmp0(f[0], "NOTE") == 0) {
339 + gtk_text_buffer_insert_with_tags_by_name(buf, &end, "• ", -1, "note",
340 + NULL);
341 + gtk_text_buffer_insert(buf, &end, f[1] ? f[1] : "", -1);
342 + gtk_text_buffer_insert(buf, &end, "\n", -1);
343 + }
344 + g_strfreev(f);
345 +}
346 +
347 +static void
348 +news_on_done(int status, gpointer data)
349 +{
350 + App *app = data;
351 + GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(app->news_view));
352 + if (gtk_text_buffer_get_char_count(buf) == 0) {
353 + const char *msg = (status == 0) ? pw_tr("news_empty")
354 + : pw_tr("news_fetch_error");
355 + GtkTextIter end;
356 + gtk_text_buffer_get_end_iter(buf, &end);
357 + gtk_text_buffer_insert_with_tags_by_name(buf, &end, msg, -1, "dim", NULL);
358 + }
359 +}
360 +
361 +static void
362 +news_reload(App *app)
363 +{
364 + /* Bufor czyścimy, a stan ładowania pokazujemy w etykiecie obok – inaczej
365 + * tekst „Ładowanie…" zostałby nad treścią nowości. */
366 + gtk_text_buffer_set_text(
367 + gtk_text_view_get_buffer(GTK_TEXT_VIEW(app->news_view)), "", -1);
368 + gtk_label_set_text(GTK_LABEL(app->news_meta), pw_tr("common_loading"));
369 + const char *args[] = {"news", pw_i18n_lang(), NULL};
370 + pw_backend(args, news_on_line, news_on_done, app);
371 +}
372 +
373 +static void
374 +on_news_refresh(GtkButton *btn, gpointer data)
375 +{
376 + (void) btn;
377 + news_reload((App *) data);
378 +}
379 +
380 +static void
381 +on_news_browser(GtkButton *btn, gpointer data)
382 +{
383 + (void) btn;
384 + (void) data;
385 + char *url = g_strdup_printf(
386 + "https://docs.paganlinux.eu/docs/paganlinux?lang=%s", pw_i18n_lang());
387 + GError *err = NULL;
388 + if (!gtk_show_uri_on_window(GTK_WINDOW(g_app->window), url,
389 + GDK_CURRENT_TIME, &err)) {
390 + g_clear_error(&err);
391 + }
392 + g_free(url);
393 +}
394 +
395 +/* ── Instalator ──────────────────────────────────────────────────────────── */
396 +static void
397 +install_update_state(App *app)
398 +{
399 + gboolean live = pw_is_live();
400 + gboolean cal = pw_have(PW_CALAMARES);
401 + if (live && cal) {
402 + gtk_label_set_text(GTK_LABEL(app->install_status), "");
403 + gtk_widget_set_sensitive(app->install_btn, TRUE);
404 + } else if (live) {
405 + gtk_label_set_text(GTK_LABEL(app->install_status),
406 + pw_tr("install_missing"));
407 + gtk_widget_set_sensitive(app->install_btn, FALSE);
408 + } else {
409 + gtk_label_set_text(GTK_LABEL(app->install_status),
410 + pw_tr("install_live_only"));
411 + gtk_widget_set_sensitive(app->install_btn, FALSE);
412 + }
413 +}
414 +
415 +static void
416 +on_install_done(int status, gpointer data)
417 +{
418 + App *app = data;
419 + if (status == 0)
420 + log_append(app->install_log, pw_tr("install_done"), "ok");
421 + else {
422 + char *msg = g_strdup_printf("%s (%d)", pw_tr("common_error"), status);
423 + log_append(app->install_log, msg, "err");
424 + g_free(msg);
425 + }
426 +}
427 +
428 +static void
429 +on_install_line(const char *line, gpointer data)
430 +{
431 + log_append(((App *) data)->install_log, line, "");
432 +}
433 +
434 +static void
435 +on_install_clicked(GtkButton *btn, gpointer data)
436 +{
437 + (void) btn;
438 + App *app = data;
439 + GtkWidget *dlg = gtk_message_dialog_new(
440 + GTK_WINDOW(app->window), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
441 + GTK_BUTTONS_YES_NO, "%s", pw_tr("install_confirm"));
442 + int resp = gtk_dialog_run(GTK_DIALOG(dlg));
443 + gtk_widget_destroy(dlg);
444 + if (resp != GTK_RESPONSE_YES)
445 + return;
446 +
447 + log_clear(app->install_log);
448 + log_append(app->install_log, pw_tr("install_running"), "hdr");
449 + const char *argv[] = {PW_CALAMARES, NULL};
450 + pw_spawn(argv, NULL, on_install_line, on_install_done, app);
451 +}
452 +
453 +/* ── Aktualizacja ────────────────────────────────────────────────────────── */
454 +static void
455 +update_set_busy(App *app, gboolean busy)
456 +{
457 + app->update_busy = busy;
458 + gtk_widget_set_sensitive(app->update_check_btn, !busy);
459 + gtk_widget_set_sensitive(app->update_btn, !busy);
460 +}
461 +
462 +static void
463 +on_update_line(const char *line, gpointer data)
464 +{
465 + log_append(((App *) data)->update_log, line, "");
466 +}
467 +
468 +/* ── Uruchamianie z uprawnieniami root (z pytaniem o hasło) ──────────────── */
469 +static char *
470 +ask_password(App *app)
471 +{
472 + GtkWidget *dlg = gtk_dialog_new_with_buttons(
473 + pw_tr("common_password_title"), GTK_WINDOW(app->window),
474 + GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
475 + pw_tr("common_cancel"), GTK_RESPONSE_CANCEL,
476 + pw_tr("common_yes"), GTK_RESPONSE_OK, NULL);
477 + GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(dlg));
478 + GtkWidget *lbl = gtk_label_new(pw_tr("common_password_prompt"));
479 + gtk_label_set_xalign(GTK_LABEL(lbl), 0.0);
480 + GtkWidget *entry = gtk_entry_new();
481 + gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
482 + gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
483 + gtk_box_pack_start(GTK_BOX(content), lbl, FALSE, FALSE, 8);
484 + gtk_box_pack_start(GTK_BOX(content), entry, FALSE, FALSE, 8);
485 + gtk_widget_show_all(content);
486 + gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
487 +
488 + char *pw = NULL;
489 + if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK)
490 + pw = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
491 + gtk_widget_destroy(dlg);
492 + return pw;
493 +}
494 +
495 +/* Uruchom polecenie z uprawnieniami; pyta o hasło, jeśli trzeba (sudo -S). */
496 +static void
497 +run_privileged(App *app, const char *const cmd[], PwLineFunc on_line,
498 + PwDoneFunc on_done, gpointer data)
499 +{
500 + char **argv = pw_privileged_argv(cmd);
501 + if (pw_privileged_needs_password()) {
502 + char *pw = ask_password(app);
503 + if (!pw) {
504 + if (on_line)
505 + on_line("! Anulowano (brak hasła).", data);
506 + if (on_done)
507 + on_done(130, data);
508 + g_strfreev(argv);
509 + return;
510 + }
511 + char *input = g_strconcat(pw, "\n", NULL);
512 + pw_spawn((const char *const *) argv, input, on_line, on_done, data);
513 + g_free(input);
514 + g_free(pw);
515 + } else {
516 + pw_spawn((const char *const *) argv, NULL, on_line, on_done, data);
517 + }
518 + g_strfreev(argv);
519 +}
520 +
521 +/* ── Sprawdzenie aktualizacji ────────────────────────────────────────────── */
522 +static void
523 +on_check_line(const char *line, gpointer data)
524 +{
525 + App *app = data;
526 + char **f = split_tabs(line);
527 + if (g_strcmp0(f[0], "UPDATES") == 0 && f[1]) {
528 + int n = atoi(f[1]);
529 + char *msg;
530 + GtkStyleContext *ctx = gtk_widget_get_style_context(app->update_result);
531 + gtk_style_context_remove_class(ctx, "warning");
532 + gtk_style_context_remove_class(ctx, "success");
533 + if (n == 0) {
534 + msg = g_strdup(pw_tr("update_uptodate"));
535 + gtk_style_context_add_class(ctx, "success");
536 + } else {
537 + msg = g_strdup_printf(pw_tr("update_available"), n);
538 + gtk_style_context_add_class(ctx, "warning");
539 + }
540 + gtk_label_set_text(GTK_LABEL(app->update_result), msg);
541 + g_free(msg);
542 + }
543 + g_strfreev(f);
544 +}
545 +
546 +static void
547 +on_check_done(int status, gpointer data)
548 +{
549 + App *app = data;
550 + update_set_busy(app, FALSE);
551 + if (status != 0)
552 + gtk_label_set_text(GTK_LABEL(app->update_result),
553 + pw_tr("update_failed"));
554 +}
555 +
556 +static void
557 +on_update_check_clicked(GtkButton *btn, gpointer data)
558 +{
559 + (void) btn;
560 + App *app = data;
561 + log_clear(app->update_log);
562 + gtk_label_set_text(GTK_LABEL(app->update_result), pw_tr("common_working"));
563 + update_set_busy(app, TRUE);
564 + log_append(app->update_log, pw_tr("update_sync"), "hdr");
565 + const char *cmd[] = {"/usr/bin/env", "PAG_YES=1", pw_pag_path(), "update",
566 + NULL};
567 + run_privileged(app, cmd, on_update_line, NULL, app);
568 + /* Po synchronizacji liczymy aktualizacje backendem. */
569 + const char *args[] = {"updates", NULL};
570 + pw_backend(args, on_check_line, on_check_done, app);
571 +}
572 +
573 +/* ── Pełna aktualizacja ──────────────────────────────────────────────────── */
574 +static void
575 +on_upgrade_done(int status, gpointer data)
576 +{
577 + App *app = data;
578 + update_set_busy(app, FALSE);
579 + if (status == 0) {
580 + log_append(app->update_log, pw_tr("update_done"), "ok");
581 + log_append(app->update_log, pw_tr("update_reboot"), "warn");
582 + gtk_label_set_text(GTK_LABEL(app->update_result), pw_tr("update_done"));
583 + } else {
584 + log_append(app->update_log, pw_tr("update_failed"), "err");
585 + gtk_label_set_text(GTK_LABEL(app->update_result),
586 + pw_tr("update_failed"));
587 + }
588 +}
589 +
590 +static void
591 +on_sync_done(int status, gpointer data)
592 +{
593 + App *app = data;
594 + if (status != 0) {
595 + update_set_busy(app, FALSE);
596 + log_append(app->update_log, pw_tr("update_failed"), "err");
597 + gtk_label_set_text(GTK_LABEL(app->update_result),
598 + pw_tr("update_failed"));
599 + return;
600 + }
601 + log_append(app->update_log, pw_tr("update_upgrade"), "hdr");
602 + const char *cmd[] = {"/usr/bin/env", "PAG_YES=1", pw_pag_path(), "upgrade",
603 + NULL};
604 + run_privileged(app, cmd, on_update_line, on_upgrade_done, app);
605 +}
606 +
607 +static void
608 +on_update_clicked(GtkButton *btn, gpointer data)
609 +{
610 + (void) btn;
611 + App *app = data;
612 + GtkWidget *dlg = gtk_message_dialog_new(
613 + GTK_WINDOW(app->window), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
614 + GTK_BUTTONS_YES_NO, "%s", pw_tr("update_confirm"));
615 + int resp = gtk_dialog_run(GTK_DIALOG(dlg));
616 + gtk_widget_destroy(dlg);
617 + if (resp != GTK_RESPONSE_YES)
618 + return;
619 +
620 + log_clear(app->update_log);
621 + gtk_label_set_text(GTK_LABEL(app->update_result), pw_tr("common_working"));
622 + update_set_busy(app, TRUE);
623 + log_append(app->update_log, pw_tr("update_sync"), "hdr");
624 + const char *cmd[] = {"/usr/bin/env", "PAG_YES=1", pw_pag_path(), "update",
625 + NULL};
626 + run_privileged(app, cmd, on_update_line, on_sync_done, app);
627 +}
628 +
629 +/* Otwórz polecenie w emulatorze terminala (pełny TTY, kolory, paski postępu).
630 + * Używane dla aktualizacji, gdy użytkownik woli widzieć przebieg w terminalu. */
631 +static void
632 +open_in_terminal(const char *const words[])
633 +{
634 + static const struct {
635 + const char *term;
636 + const char *flag;
637 + } terms[] = {
638 + {"xfce4-terminal", "-x"},
639 + {"x-terminal-emulator", "-e"},
640 + {"xterm", "-e"},
641 + };
642 + for (gsize i = 0; i < G_N_ELEMENTS(terms); i++) {
643 + if (!pw_have(terms[i].term))
644 + continue;
645 + GPtrArray *arr = g_ptr_array_new();
646 + g_ptr_array_add(arr, g_strdup(terms[i].term));
647 + g_ptr_array_add(arr, g_strdup(terms[i].flag));
648 + for (gsize k = 0; words[k]; k++)
649 + g_ptr_array_add(arr, g_strdup(words[k]));
650 + g_ptr_array_add(arr, NULL);
651 + pw_spawn((const char *const *) arr->pdata, NULL, NULL, NULL, NULL);
652 + g_ptr_array_free(arr, TRUE);
653 + return;
654 + }
655 +}
656 +
657 +static void
658 +on_update_terminal_clicked(GtkButton *btn, gpointer data)
659 +{
660 + (void) btn;
661 + (void) data;
662 + const char *words[6];
663 + int n = 0;
664 + if (!pw_is_root())
665 + words[n++] = "sudo";
666 + if (pw_have("pagan-update"))
667 + words[n++] = "pagan-update";
668 + else {
669 + words[n++] = "/bin/sh";
670 + words[n++] = "-c";
671 + words[n++] = "pag update && pag upgrade";
672 + }
673 + words[n] = NULL;
674 + open_in_terminal(words);
675 +}
676 +
677 +/* ── Sklep ───────────────────────────────────────────────────────────────── */
678 +static void
679 +package_free(gpointer p)
680 +{
681 + Package *pkg = p;
682 + if (!pkg)
683 + return;
684 + g_free(pkg->name);
685 + g_free(pkg->version);
686 + g_free(pkg->description);
687 + g_free(pkg->depends);
688 + g_free(pkg->license);
689 + g_free(pkg);
690 +}
691 +
692 +static void
693 +store_clear_data(App *app)
694 +{
695 + if (app->packages) {
696 + g_hash_table_destroy(app->packages);
697 + app->packages = NULL;
698 + }
699 + if (app->installed) {
700 + g_hash_table_destroy(app->installed);
701 + app->installed = NULL;
702 + }
703 +}
704 +
705 +static gboolean
706 +store_filter_visible(GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
707 +{
708 + App *app = data;
709 + const char *q = gtk_entry_get_text(GTK_ENTRY(app->store_search));
710 + if (!q || !*q)
711 + return TRUE;
712 + char *name = NULL, *desc = NULL;
713 + gtk_tree_model_get(model, iter, COL_NAME, &name, COL_DESC, &desc, -1);
714 + char *lname = name ? g_utf8_strdown(name, -1) : NULL;
715 + char *ldesc = desc ? g_utf8_strdown(desc, -1) : NULL;
716 + char *lq = g_utf8_strdown(q, -1);
717 + gboolean ok = (lname && strstr(lname, lq)) || (ldesc && strstr(ldesc, lq));
718 + g_free(name);
719 + g_free(desc);
720 + g_free(lname);
721 + g_free(ldesc);
722 + g_free(lq);
723 + return ok;
724 +}
725 +
726 +static void
727 +store_refresh_count(App *app)
728 +{
729 + int shown = 0, inst = 0;
730 + GtkTreeIter iter;
731 + gboolean valid = gtk_tree_model_get_iter_first(
732 + GTK_TREE_MODEL(app->store_filter), &iter);
733 + while (valid) {
734 + shown++;
735 + gboolean is_inst = FALSE;
736 + gtk_tree_model_get(GTK_TREE_MODEL(app->store_filter), &iter,
737 + COL_INSTALLED, &is_inst, -1);
738 + if (is_inst)
739 + inst++;
740 + valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(app->store_filter), &iter);
741 + }
742 + char *txt = g_strdup_printf(pw_tr("store_count"), shown, inst);
743 + gtk_label_set_text(GTK_LABEL(app->store_count), txt);
744 + g_free(txt);
745 +}
746 +
747 +static void
748 +on_store_search_changed(GtkEditable *e, gpointer data)
749 +{
750 + (void) e;
751 + App *app = data;
752 + gtk_tree_model_filter_refilter(app->store_filter);
753 + store_refresh_count(app);
754 +}
755 +
756 +static void
757 +store_show_details(App *app)
758 +{
759 + GtkTreeIter iter;
760 + const char *text;
761 + if (!app->store_selected ||
762 + !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(app->store_filter), &iter)) {
763 + text = pw_tr("store_select");
764 + gtk_label_set_text(GTK_LABEL(app->store_details), text);
765 + return;
766 + }
767 + Package *pkg = g_hash_table_lookup(app->packages, app->store_selected);
768 + if (!pkg) {
769 + gtk_label_set_text(GTK_LABEL(app->store_details), pw_tr("store_select"));
770 + return;
771 + }
772 + gboolean inst = g_hash_table_contains(app->installed, pkg->name);
773 + char *size = pw_format_size(pkg->size);
774 + /* Pola pakietu trafiają do Pango markup – escapujemy, bo opis może
775 + * zawierać znaki < > &. */
776 + char *e_name = g_markup_escape_text(pkg->name, -1);
777 + char *e_ver = g_markup_escape_text(pkg->version ? pkg->version : "", -1);
778 + char *e_lic = g_markup_escape_text(
779 + (pkg->license && *pkg->license) ? pkg->license : pw_tr("store_none"), -1);
780 + char *e_dep = g_markup_escape_text(
781 + (pkg->depends && *pkg->depends) ? pkg->depends : pw_tr("store_none"), -1);
782 + char *e_desc = g_markup_escape_text(pkg->description ? pkg->description : "",
783 + -1);
784 + char *txt = g_strdup_printf(
785 + "<b>%s</b>\n%s: %s\n%s: %s\n%s: %s\n%s: %s\n\n%s: %s\n\n%s",
786 + e_name, pw_tr("store_col_version"), e_ver,
787 + pw_tr("store_col_size"), size, pw_tr("store_license"), e_lic,
788 + pw_tr("store_details"),
789 + inst ? pw_tr("store_installed") : pw_tr("store_not_installed"),
790 + pw_tr("store_depends"), e_dep, e_desc);
791 + gtk_label_set_markup(GTK_LABEL(app->store_details), txt);
792 + g_free(txt);
793 + g_free(size);
794 + g_free(e_name);
795 + g_free(e_ver);
796 + g_free(e_lic);
797 + g_free(e_dep);
798 + g_free(e_desc);
799 +}
800 +
801 +static void
802 +on_store_selection(GtkTreeSelection *sel, gpointer data)
803 +{
804 + App *app = data;
805 + GtkTreeModel *model;
806 + GtkTreeIter iter;
807 + if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
808 + g_free(app->store_selected);
809 + gtk_tree_model_get(model, &iter, COL_NAME, &app->store_selected, -1);
810 + } else {
811 + g_free(app->store_selected);
812 + app->store_selected = NULL;
813 + }
814 + store_show_details(app);
815 +}
816 +
817 +static void
818 +store_add_row(App *app, Package *pkg)
819 +{
820 + gboolean inst = g_hash_table_contains(app->installed, pkg->name);
821 + char *size = pw_format_size(pkg->size);
822 + char *shown = g_strdup_printf("%s%s", inst ? "● " : "", pkg->name);
823 + GtkTreeIter iter;
824 + gtk_list_store_append(app->store_model, &iter);
825 + gtk_list_store_set(app->store_model, &iter,
826 + COL_NAME, shown,
827 + COL_VERSION, pkg->version,
828 + COL_SIZE, size,
829 + COL_DESC, pkg->description,
830 + COL_INSTALLED, inst, -1);
831 + g_free(size);
832 + g_free(shown);
833 +}
834 +
835 +static void
836 +store_rebuild_view(App *app)
837 +{
838 + gtk_list_store_clear(app->store_model);
839 + if (!app->packages)
840 + return;
841 + GList *keys = g_hash_table_get_keys(app->packages);
842 + keys = g_list_sort(keys, (GCompareFunc) g_strcmp0);
843 + for (GList *l = keys; l; l = l->next)
844 + store_add_row(app, g_hash_table_lookup(app->packages, l->data));
845 + g_list_free(keys);
846 + gtk_tree_model_filter_refilter(app->store_filter);
847 + store_refresh_count(app);
848 +}
849 +
850 +static void
851 +store_on_line(const char *line, gpointer data)
852 +{
853 + App *app = data;
854 + char **f = split_tabs(line);
855 + if (g_strcmp0(f[0], "PKG") == 0 && f[1]) {
856 + Package *pkg = g_new0(Package, 1);
857 + pkg->name = g_strdup(f[1]);
858 + pkg->version = g_strdup(f[2] ? f[2] : "");
859 + pkg->size = f[3] ? g_ascii_strtoull(f[3], NULL, 10) : 0;
860 + pkg->description = g_strdup(f[4] ? f[4] : "");
861 + pkg->depends = g_strdup(f[5] ? f[5] : "");
862 + pkg->license = g_strdup(f[6] ? f[6] : "");
863 + g_hash_table_insert(app->packages, g_strdup(pkg->name), pkg);
864 + } else if (g_strcmp0(f[0], "INST") == 0 && f[1]) {
865 + g_hash_table_insert(app->installed, g_strdup(f[1]),
866 + g_strdup(f[2] ? f[2] : ""));
867 + }
868 + g_strfreev(f);
869 +}
870 +
871 +static void
872 +store_on_done(int status, gpointer data)
873 +{
874 + App *app = data;
875 + if (status != 0)
876 + gtk_label_set_text(GTK_LABEL(app->store_count), pw_tr("store_error"));
877 + store_rebuild_view(app);
878 + if (app->store_selected)
879 + store_show_details(app);
880 +}
881 +
882 +static void
883 +store_load(App *app)
884 +{
885 + store_clear_data(app);
886 + app->packages = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
887 + package_free);
888 + app->installed = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
889 + g_free);
890 + gtk_label_set_text(GTK_LABEL(app->store_count), pw_tr("store_loading"));
891 + const char *args[] = {"repo", NULL};
892 + pw_backend(args, store_on_line, store_on_done, app);
893 +}
894 +
895 +static void
896 +on_store_refresh(GtkButton *btn, gpointer data)
897 +{
898 + (void) btn;
899 + store_load((App *) data);
900 +}
901 +
902 +typedef struct {
903 + App *app;
904 + char *name;
905 + const char *ok_key;
906 + const char *fail_key;
907 +} StoreAction;
908 +
909 +static void
910 +store_action_line(const char *line, gpointer data)
911 +{
912 + StoreAction *act = data;
913 + log_append(act->app->store_log, line, "");
914 +}
915 +
916 +static void
917 +store_action_done(int status, gpointer data)
918 +{
919 + StoreAction *act = data;
920 + App *app = act->app;
921 + if (status == 0) {
922 + char *msg = g_strdup_printf(pw_tr(act->ok_key), act->name);
923 + log_append(app->store_log, msg, "ok");
924 + g_free(msg);
925 + /* Odśwież stan zainstalowanych pakietów. */
926 + const char *args[] = {"installed", NULL};
927 + pw_backend(args, store_on_line, store_on_done, app);
928 + } else {
929 + char *msg = g_strdup_printf(pw_tr(act->fail_key), act->name);
930 + log_append(app->store_log, msg, "err");
931 + g_free(msg);
932 + }
933 + g_free(act->name);
934 + g_free(act);
935 +}
936 +
937 +static void
938 +store_run_pkg_action(App *app, const char *action, const char *ok_key,
939 + const char *fail_key)
940 +{
941 + if (!app->store_selected)
942 + return;
943 +
944 + char *msg = g_strdup_printf(pw_tr("store_installing"), app->store_selected);
945 + log_clear(app->store_log);
946 + log_append(app->store_log, msg, "hdr");
947 + g_free(msg);
948 +
949 + StoreAction *act = g_new0(StoreAction, 1);
950 + act->app = app;
951 + act->name = g_strdup(app->store_selected);
952 + act->ok_key = ok_key;
953 + act->fail_key = fail_key;
954 +
955 + const char *cmd[] = {"/usr/bin/env", "PAG_YES=1", pw_pag_path(), action,
956 + "-y", app->store_selected, NULL};
957 + /* pag install/remove wymaga root – uruchamiamy przez warstwę uprawnień. */
958 + run_privileged(app, cmd, store_action_line, store_action_done, act);
959 +}
960 +
961 +static void
962 +on_store_install(GtkButton *btn, gpointer data)
963 +{
964 + (void) btn;
965 + App *app = data;
966 + if (!app->store_selected)
967 + return;
968 + char *q = g_strdup_printf(pw_tr("store_confirm"), app->store_selected);
969 + GtkWidget *dlg = gtk_message_dialog_new(
970 + GTK_WINDOW(app->window), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
971 + GTK_BUTTONS_YES_NO, "%s", q);
972 + g_free(q);
973 + int resp = gtk_dialog_run(GTK_DIALOG(dlg));
974 + gtk_widget_destroy(dlg);
975 + if (resp != GTK_RESPONSE_YES)
976 + return;
977 + store_run_pkg_action(app, "install", "store_install_ok", "store_install_fail");
978 +}
979 +
980 +static void
981 +on_store_remove(GtkButton *btn, gpointer data)
982 +{
983 + (void) btn;
984 + App *app = data;
985 + if (!app->store_selected)
986 + return;
987 + char *q = g_strdup_printf(pw_tr("store_confirm_remove"), app->store_selected);
988 + GtkWidget *dlg = gtk_message_dialog_new(
989 + GTK_WINDOW(app->window), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION,
990 + GTK_BUTTONS_YES_NO, "%s", q);
991 + g_free(q);
992 + int resp = gtk_dialog_run(GTK_DIALOG(dlg));
993 + gtk_widget_destroy(dlg);
994 + if (resp != GTK_RESPONSE_YES)
995 + return;
996 + store_run_pkg_action(app, "remove", "store_remove_ok", "store_remove_fail");
997 +}
998 +
999 +/* ── Ustawienia ──────────────────────────────────────────────────────────── */
1000 +static void
1001 +settings_fill_timezones(App *app)
1002 +{
1003 + /* Synchronicznie – lista stref jest potrzebna od razu, a zapytanie trwa
1004 + * milisekundy (bez sieci). */
1005 + char *out = pw_run_capture((const char *const[]) {
1006 + pw_backend_path(), "timezones", NULL});
1007 + if (!out)
1008 + return;
1009 + char **lines = g_strsplit(out, "\n", -1);
1010 + for (gsize i = 0; lines[i]; i++) {
1011 + char **f = split_tabs(lines[i]);
1012 + if (g_strcmp0(f[0], "TZ") == 0 && f[1])
1013 + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->set_tz_combo),
1014 + f[1]);
1015 + g_strfreev(f);
1016 + }
1017 + g_strfreev(lines);
1018 + g_free(out);
1019 +}
1020 +
1021 +static void
1022 +settings_on_line(const char *line, gpointer data)
1023 +{
1024 + App *app = data;
1025 + char **f = split_tabs(line);
1026 + if (g_strcmp0(f[0], "LOCALE") == 0 && f[1] && *f[1]) {
1027 + gtk_combo_box_set_active(GTK_COMBO_BOX(app->set_lang_combo),
1028 + g_strcmp0(f[1], "en") == 0 ? 1 : 0);
1029 + } else if (g_strcmp0(f[0], "KEYMAP") == 0 && f[1]) {
1030 + gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(app->set_keymap_combo))),
1031 + f[1]);
1032 + } else if (g_strcmp0(f[0], "TIMEZONE") == 0 && f[1]) {
1033 + GtkWidget *entry = gtk_bin_get_child(GTK_BIN(app->set_tz_combo));
1034 + gtk_entry_set_text(GTK_ENTRY(entry), f[1]);
1035 + } else if (g_strcmp0(f[0], "HOSTNAME") == 0 && f[1]) {
1036 + gtk_entry_set_text(GTK_ENTRY(app->set_host_entry), f[1]);
1037 + }
1038 + g_strfreev(f);
1039 +}
1040 +
1041 +static void
1042 +settings_on_done(int status, gpointer data)
1043 +{
1044 + (void) status;
1045 + App *app = data;
1046 + gtk_label_set_text(GTK_LABEL(app->set_status), "");
1047 +}
1048 +
1049 +static void
1050 +settings_load(App *app)
1051 +{
1052 + gtk_label_set_text(GTK_LABEL(app->set_status), pw_tr("settings_loading"));
1053 + const char *args[] = {"sysinfo", NULL};
1054 + pw_backend(args, settings_on_line, settings_on_done, app);
1055 +}
1056 +
1057 +static void
1058 +on_settings_apply_done(int status, gpointer data)
1059 +{
1060 + App *app = data;
1061 + if (status == 0)
1062 + gtk_label_set_text(GTK_LABEL(app->set_status), pw_tr("settings_saved"));
1063 + else
1064 + gtk_label_set_text(GTK_LABEL(app->set_status), pw_tr("settings_failed"));
1065 +}
1066 +
1067 +/* Wartość bezpieczna do wstawienia w polecenie powłoki: litery/cyfry oraz
1068 + * znaki z `extra`. Chroni przed wstrzyknięciem poleceń z pól formularza. */
1069 +static gboolean
1070 +valid_setting_value(const char *value, const char *extra)
1071 +{
1072 + if (!value || !*value)
1073 + return FALSE;
1074 + for (const char *p = value; *p; p++) {
1075 + if (g_ascii_isalnum(*p) || strchr(extra, *p))
1076 + continue;
1077 + return FALSE;
1078 + }
1079 + return TRUE;
1080 +}
1081 +
1082 +static void
1083 +on_settings_apply(GtkButton *btn, gpointer data)
1084 +{
1085 + (void) btn;
1086 + App *app = data;
1087 +
1088 + const char *langs[] = {"pl", "en"};
1089 + const char *locales[] = {"pl_PL.UTF-8", "en_US.UTF-8"};
1090 + int li = gtk_combo_box_get_active(GTK_COMBO_BOX(app->set_lang_combo));
1091 + if (li < 0 || li > 1)
1092 + li = 0;
1093 +
1094 + /* Język interfejsu zapisujemy od razu (bez root). */
1095 + pw_i18n_set_lang(langs[li]);
1096 + g_free(app->cfg->lang);
1097 + app->cfg->lang = g_strdup(langs[li]);
1098 + pw_config_save(app->cfg);
1099 + gtk_combo_box_set_active(GTK_COMBO_BOX(app->lang_combo), li);
1100 + retranslate(app);
1101 +
1102 + char *locale = g_strdup_printf("LANG=%s", locales[li]);
1103 + const char *keymap = gtk_entry_get_text(
1104 + GTK_ENTRY(gtk_bin_get_child(GTK_BIN(app->set_keymap_combo))));
1105 + const char *tz = gtk_entry_get_text(
1106 + GTK_ENTRY(gtk_bin_get_child(GTK_BIN(app->set_tz_combo))));
1107 + const char *host = gtk_entry_get_text(GTK_ENTRY(app->set_host_entry));
1108 +
1109 + /* Walidacja: wartości trafiają do polecenia powłoki. */
1110 + if (keymap && *keymap && !valid_setting_value(keymap, ",+- "))
1111 + keymap = NULL;
1112 + if (tz && *tz && !valid_setting_value(tz, "/_+- "))
1113 + tz = NULL;
1114 + if (host && *host && !valid_setting_value(host, ".-"))
1115 + host = NULL;
1116 +
1117 + gtk_label_set_text(GTK_LABEL(app->set_status), pw_tr("common_working"));
1118 +
1119 + /* Kolejne kroki uruchamiamy szeregowo – każde własne pytanie o hasło
1120 + * byłoby uciążliwe, więc gdy trzeba hasła, robimy wszystkie w jednym
1121 + * poleceniu powłoki. */
1122 + GPtrArray *cmd = g_ptr_array_new();
1123 + GPtrArray *parts = g_ptr_array_new_with_free_func(g_free);
1124 + g_ptr_array_add(parts, g_strdup_printf("localectl set-locale %s", locale));
1125 + if (keymap && *keymap)
1126 + g_ptr_array_add(parts, g_strdup_printf("localectl set-x11-keymap %s",
1127 + keymap));
1128 + if (tz && *tz)
1129 + g_ptr_array_add(parts, g_strdup_printf("timedatectl set-timezone %s", tz));
1130 + if (host && *host)
1131 + g_ptr_array_add(parts, g_strdup_printf("hostnamectl set-hostname %s",
1132 + host));
1133 + g_ptr_array_add(parts, NULL);
1134 + char *joined = g_strjoinv(" && ", (char **) parts->pdata);
1135 +
1136 + g_ptr_array_add(cmd, g_strdup("/bin/sh"));
1137 + g_ptr_array_add(cmd, g_strdup("-c"));
1138 + g_ptr_array_add(cmd, g_strdup(joined));
1139 + g_ptr_array_add(cmd, NULL);
1140 + run_privileged(app, (const char *const *) cmd->pdata, NULL,
1141 + on_settings_apply_done, app);
1142 +
1143 + g_ptr_array_free(parts, TRUE);
1144 + g_ptr_array_free(cmd, TRUE);
1145 + g_free(joined);
1146 + g_free(locale);
1147 +}
1148 +
1149 +static void
1150 +on_settings_wifi(GtkButton *btn, gpointer data)
1151 +{
1152 + (void) btn;
1153 + (void) data;
1154 + const char *terms[][3] = {
1155 + {"xfce4-terminal", "-e", "pagan-wifi"},
1156 + {"x-terminal-emulator", "-e", "pagan-wifi"},
1157 + {"xterm", "-e", "pagan-wifi"},
1158 + };
1159 + for (gsize i = 0; i < G_N_ELEMENTS(terms); i++) {
1160 + if (!pw_have(terms[i][0]))
1161 + continue;
1162 + const char *argv[] = {terms[i][0], terms[i][1], terms[i][2], NULL};
1163 + pw_spawn(argv, NULL, NULL, NULL, NULL);
1164 + return;
1165 + }
1166 + GtkWidget *dlg = gtk_message_dialog_new(
1167 + GTK_WINDOW(g_app->window), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO,
1168 + GTK_BUTTONS_CLOSE, "%s", pw_tr("settings_network_hint"));
1169 + gtk_dialog_run(GTK_DIALOG(dlg));
1170 + gtk_widget_destroy(dlg);
1171 +}
1172 +
1173 +/* ── „Nie pokazuj więcej" ────────────────────────────────────────────────── */
1174 +static void
1175 +on_dont_show_toggled(GtkToggleButton *btn, gpointer data)
1176 +{
1177 + App *app = data;
1178 + app->cfg->show_on_login = !gtk_toggle_button_get_active(btn);
1179 + pw_config_save(app->cfg);
1180 +}
1181 +
1182 +/* ── Budowa stron ────────────────────────────────────────────────────────── */
1183 +static GtkWidget *
1184 +build_install_page(App *app)
1185 +{
1186 + GtkWidget *box = page_box();
1187 + GList *kids = gtk_container_get_children(GTK_CONTAINER(box));
1188 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 0)), "install_title", TRUE);
1189 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 1)), "install_subtitle",
1190 + TRUE);
1191 + g_list_free(kids);
1192 +
1193 + GtkWidget *desc = gtk_label_new(pw_tr("install_desc"));
1194 + gtk_label_set_xalign(GTK_LABEL(desc), 0.0);
1195 + gtk_label_set_line_wrap(GTK_LABEL(desc), TRUE);
1196 + tr_register(app, desc, "install_desc", TRUE);
1197 + gtk_box_pack_start(GTK_BOX(box), desc, FALSE, FALSE, 8);
1198 +
1199 + app->install_status = gtk_label_new("");
1200 + gtk_label_set_xalign(GTK_LABEL(app->install_status), 0.0);
1201 + gtk_label_set_line_wrap(GTK_LABEL(app->install_status), TRUE);
1202 + gtk_box_pack_start(GTK_BOX(box), app->install_status, FALSE, FALSE, 4);
1203 +
1204 + app->install_btn = gtk_button_new_with_label(pw_tr("install_button"));
1205 + tr_register(app, app->install_btn, "install_button", FALSE);
1206 + gtk_widget_set_halign(app->install_btn, GTK_ALIGN_START);
1207 + gtk_box_pack_start(GTK_BOX(box), app->install_btn, FALSE, FALSE, 6);
1208 +
1209 + app->install_log = log_new(220);
1210 + gtk_box_pack_start(GTK_BOX(box), app->install_log, TRUE, TRUE, 4);
1211 + return box;
1212 +}
1213 +
1214 +static GtkWidget *
1215 +build_update_page(App *app)
1216 +{
1217 + GtkWidget *box = page_box();
1218 + GList *kids = gtk_container_get_children(GTK_CONTAINER(box));
1219 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 0)), "update_title", TRUE);
1220 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 1)), "update_subtitle", TRUE);
1221 + g_list_free(kids);
1222 +
1223 + GtkWidget *desc = gtk_label_new(pw_tr("update_desc"));
1224 + gtk_label_set_xalign(GTK_LABEL(desc), 0.0);
1225 + gtk_label_set_line_wrap(GTK_LABEL(desc), TRUE);
1226 + tr_register(app, desc, "update_desc", TRUE);
1227 + gtk_box_pack_start(GTK_BOX(box), desc, FALSE, FALSE, 8);
1228 +
1229 + GtkWidget *bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
1230 + app->update_check_btn = gtk_button_new_with_label(pw_tr("update_check_button"));
1231 + app->update_btn = gtk_button_new_with_label(pw_tr("update_button"));
1232 + app->update_terminal_btn = gtk_button_new_with_label(
1233 + pw_tr("update_terminal_button"));
1234 + tr_register(app, app->update_check_btn, "update_check_button", FALSE);
1235 + tr_register(app, app->update_btn, "update_button", FALSE);
1236 + tr_register(app, app->update_terminal_btn, "update_terminal_button", FALSE);
1237 + app->update_result = gtk_label_new("");
1238 + gtk_box_pack_start(GTK_BOX(bar), app->update_check_btn, FALSE, FALSE, 0);
1239 + gtk_box_pack_start(GTK_BOX(bar), app->update_btn, FALSE, FALSE, 0);
1240 + gtk_box_pack_start(GTK_BOX(bar), app->update_terminal_btn, FALSE, FALSE, 0);
1241 + gtk_box_pack_start(GTK_BOX(bar), app->update_result, FALSE, FALSE, 10);
1242 + gtk_box_pack_start(GTK_BOX(box), bar, FALSE, FALSE, 4);
1243 +
1244 + app->update_log = log_new(240);
1245 + gtk_box_pack_start(GTK_BOX(box), app->update_log, TRUE, TRUE, 4);
1246 + return box;
1247 +}
1248 +
1249 +static GtkWidget *
1250 +build_store_page(App *app)
1251 +{
1252 + GtkWidget *box = page_box();
1253 + GList *kids = gtk_container_get_children(GTK_CONTAINER(box));
1254 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 0)), "store_title", TRUE);
1255 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 1)), "store_subtitle", TRUE);
1256 + g_list_free(kids);
1257 +
1258 + GtkWidget *bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
1259 + app->store_search = gtk_search_entry_new();
1260 + gtk_entry_set_placeholder_text(GTK_ENTRY(app->store_search),
1261 + pw_tr("store_search_placeholder"));
1262 + GtkWidget *refresh = gtk_button_new_with_label(pw_tr("common_refresh"));
1263 + tr_register(app, refresh, "common_refresh", FALSE);
1264 + gtk_box_pack_start(GTK_BOX(bar), app->store_search, TRUE, TRUE, 0);
1265 + gtk_box_pack_start(GTK_BOX(bar), refresh, FALSE, FALSE, 0);
1266 + gtk_box_pack_start(GTK_BOX(box), bar, FALSE, FALSE, 4);
1267 +
1268 + app->store_count = gtk_label_new("");
1269 + gtk_label_set_xalign(GTK_LABEL(app->store_count), 0.0);
1270 + gtk_widget_set_opacity(app->store_count, 0.6);
1271 + gtk_box_pack_start(GTK_BOX(box), app->store_count, FALSE, FALSE, 0);
1272 +
1273 + app->store_model = gtk_list_store_new(N_COLS, G_TYPE_STRING, G_TYPE_STRING,
1274 + G_TYPE_STRING, G_TYPE_STRING,
1275 + G_TYPE_BOOLEAN);
1276 + app->store_filter = GTK_TREE_MODEL_FILTER(
1277 + gtk_tree_model_filter_new(GTK_TREE_MODEL(app->store_model), NULL));
1278 + gtk_tree_model_filter_set_visible_func(app->store_filter,
1279 + store_filter_visible, app, NULL);
1280 +
1281 + app->store_tree = gtk_tree_view_new_with_model(
1282 + GTK_TREE_MODEL(app->store_filter));
1283 + GtkCellRenderer *r = gtk_cell_renderer_text_new();
1284 + app->store_col_name = gtk_tree_view_column_new_with_attributes(
1285 + pw_tr("store_col_name"), r, "text", COL_NAME, NULL);
1286 + gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(app->store_col_name), TRUE);
1287 + gtk_tree_view_append_column(GTK_TREE_VIEW(app->store_tree),
1288 + app->store_col_name);
1289 + r = gtk_cell_renderer_text_new();
1290 + app->store_col_version = gtk_tree_view_column_new_with_attributes(
1291 + pw_tr("store_col_version"), r, "text", COL_VERSION, NULL);
1292 + gtk_tree_view_append_column(GTK_TREE_VIEW(app->store_tree),
1293 + app->store_col_version);
1294 + r = gtk_cell_renderer_text_new();
1295 + app->store_col_size = gtk_tree_view_column_new_with_attributes(
1296 + pw_tr("store_col_size"), r, "text", COL_SIZE, NULL);
1297 + gtk_tree_view_append_column(GTK_TREE_VIEW(app->store_tree),
1298 + app->store_col_size);
1299 + r = gtk_cell_renderer_text_new();
1300 + app->store_col_desc = gtk_tree_view_column_new_with_attributes(
1301 + pw_tr("store_col_desc"), r, "text", COL_DESC, NULL);
1302 + gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(app->store_col_desc), TRUE);
1303 + gtk_tree_view_append_column(GTK_TREE_VIEW(app->store_tree),
1304 + app->store_col_desc);
1305 +
1306 + GtkTreeSelection *sel = gtk_tree_view_get_selection(
1307 + GTK_TREE_VIEW(app->store_tree));
1308 + g_signal_connect(sel, "changed", G_CALLBACK(on_store_selection), app);
1309 +
1310 + GtkWidget *paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
1311 + GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
1312 + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
1313 + GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1314 + gtk_container_add(GTK_CONTAINER(scroll), app->store_tree);
1315 + gtk_paned_pack1(GTK_PANED(paned), scroll, TRUE, FALSE);
1316 +
1317 + GtkWidget *right = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
1318 + gtk_container_set_border_width(GTK_CONTAINER(right), 8);
1319 + app->store_details = gtk_label_new(pw_tr("store_select"));
1320 + gtk_label_set_xalign(GTK_LABEL(app->store_details), 0.0);
1321 + gtk_label_set_yalign(GTK_LABEL(app->store_details), 0.0);
1322 + gtk_label_set_line_wrap(GTK_LABEL(app->store_details), TRUE);
1323 + gtk_label_set_selectable(GTK_LABEL(app->store_details), TRUE);
1324 + gtk_box_pack_start(GTK_BOX(right), app->store_details, TRUE, TRUE, 0);
1325 + app->store_install_btn = gtk_button_new_with_label(pw_tr("store_install"));
1326 + app->store_remove_btn = gtk_button_new_with_label(pw_tr("store_remove"));
1327 + tr_register(app, app->store_install_btn, "store_install", FALSE);
1328 + tr_register(app, app->store_remove_btn, "store_remove", FALSE);
1329 + gtk_box_pack_start(GTK_BOX(right), app->store_install_btn, FALSE, FALSE, 0);
1330 + gtk_box_pack_start(GTK_BOX(right), app->store_remove_btn, FALSE, FALSE, 0);
1331 + gtk_paned_pack2(GTK_PANED(paned), right, FALSE, FALSE);
1332 + gtk_paned_set_position(GTK_PANED(paned), 560);
1333 + gtk_box_pack_start(GTK_BOX(box), paned, TRUE, TRUE, 4);
1334 +
1335 + app->store_log = log_new(90);
1336 + gtk_box_pack_start(GTK_BOX(box), app->store_log, FALSE, FALSE, 0);
1337 +
1338 + g_signal_connect(app->store_search, "changed",
1339 + G_CALLBACK(on_store_search_changed), app);
1340 + g_signal_connect(refresh, "clicked", G_CALLBACK(on_store_refresh), app);
1341 + g_signal_connect(app->store_install_btn, "clicked",
1342 + G_CALLBACK(on_store_install), app);
1343 + g_signal_connect(app->store_remove_btn, "clicked",
1344 + G_CALLBACK(on_store_remove), app);
1345 + return box;
1346 +}
1347 +
1348 +static GtkWidget *
1349 +build_settings_page(App *app)
1350 +{
1351 + GtkWidget *box = page_box();
1352 + GList *kids = gtk_container_get_children(GTK_CONTAINER(box));
1353 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 0)), "settings_title", TRUE);
1354 + tr_register(app, GTK_WIDGET(g_list_nth_data(kids, 1)), "settings_subtitle",
1355 + TRUE);
1356 + g_list_free(kids);
1357 +
1358 + GtkWidget *grid = gtk_grid_new();
1359 + gtk_grid_set_row_spacing(GTK_GRID(grid), 8);
1360 + gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
1361 + gtk_box_pack_start(GTK_BOX(box), grid, FALSE, FALSE, 6);
1362 +
1363 + GtkWidget *l;
1364 +
1365 + l = gtk_label_new(pw_tr("settings_language"));
1366 + gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1367 + tr_register(app, l, "settings_language", TRUE);
1368 + gtk_grid_attach(GTK_GRID(grid), l, 0, 0, 1, 1);
1369 + app->set_lang_combo = gtk_combo_box_text_new();
1370 + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->set_lang_combo),
1371 + "Polski");
1372 + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->set_lang_combo),
1373 + "English");
1374 + gtk_grid_attach(GTK_GRID(grid), app->set_lang_combo, 1, 0, 1, 1);
1375 +
1376 + l = gtk_label_new(pw_tr("settings_keyboard"));
1377 + gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1378 + tr_register(app, l, "settings_keyboard", TRUE);
1379 + gtk_grid_attach(GTK_GRID(grid), l, 0, 1, 1, 1);
1380 + app->set_keymap_combo = gtk_combo_box_text_new_with_entry();
1381 + static const char *keymaps[] = {"pl", "us", "gb", "de", "fr", "es", "it",
1382 + "ru", "ua", "cz", "sk", "nl", "se", "pt"};
1383 + for (gsize i = 0; i < G_N_ELEMENTS(keymaps); i++)
1384 + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->set_keymap_combo),
1385 + keymaps[i]);
1386 + gtk_grid_attach(GTK_GRID(grid), app->set_keymap_combo, 1, 1, 1, 1);
1387 +
1388 + l = gtk_label_new(pw_tr("settings_timezone"));
1389 + gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1390 + tr_register(app, l, "settings_timezone", TRUE);
1391 + gtk_grid_attach(GTK_GRID(grid), l, 0, 2, 1, 1);
1392 + app->set_tz_combo = gtk_combo_box_text_new_with_entry();
1393 + gtk_grid_attach(GTK_GRID(grid), app->set_tz_combo, 1, 2, 1, 1);
1394 +
1395 + l = gtk_label_new(pw_tr("settings_hostname"));
1396 + gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1397 + tr_register(app, l, "settings_hostname", TRUE);
1398 + gtk_grid_attach(GTK_GRID(grid), l, 0, 3, 1, 1);
1399 + app->set_host_entry = gtk_entry_new();
1400 + gtk_grid_attach(GTK_GRID(grid), app->set_host_entry, 1, 3, 1, 1);
1401 +
1402 + l = gtk_label_new(pw_tr("settings_network"));
1403 + gtk_label_set_xalign(GTK_LABEL(l), 0.0);
1404 + tr_register(app, l, "settings_network", TRUE);
1405 + gtk_grid_attach(GTK_GRID(grid), l, 0, 4, 1, 1);
1406 + app->set_wifi_btn = gtk_button_new_with_label(pw_tr("settings_wifi_button"));
1407 + tr_register(app, app->set_wifi_btn, "settings_wifi_button", FALSE);
1408 + gtk_widget_set_halign(app->set_wifi_btn, GTK_ALIGN_START);
1409 + gtk_grid_attach(GTK_GRID(grid), app->set_wifi_btn, 1, 4, 1, 1);
1410 +
1411 + GtkWidget *bar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
1412 + app->set_apply_btn = gtk_button_new_with_label(pw_tr("settings_apply"));
1413 + tr_register(app, app->set_apply_btn, "settings_apply", FALSE);
1414 + app->set_status = gtk_label_new("");
1415 + gtk_box_pack_start(GTK_BOX(bar), app->set_apply_btn, FALSE, FALSE, 0);
1416 + gtk_box_pack_start(GTK_BOX(bar), app->set_status, FALSE, FALSE, 0);
1417 + gtk_box_pack_start(GTK_BOX(box), bar, FALSE, FALSE, 10);
1418 +
1419 + GtkWidget *hint = gtk_label_new(pw_tr("settings_restart_hint"));
1420 + gtk_label_set_xalign(GTK_LABEL(hint), 0.0);
1421 + gtk_widget_set_opacity(hint, 0.6);
1422 + tr_register(app, hint, "settings_restart_hint", TRUE);
1423 + gtk_box_pack_start(GTK_BOX(box), hint, FALSE, FALSE, 0);
1424 +
1425 + GtkWidget *about = gtk_label_new(NULL);
1426 + gtk_label_set_xalign(GTK_LABEL(about), 0.0);
1427 + gtk_label_set_line_wrap(GTK_LABEL(about), TRUE);
1428 + char *about_txt = g_strdup_printf("<b>%s</b>\n%s", pw_tr("settings_about"),
1429 + pw_tr("settings_about_text"));
1430 + gtk_label_set_markup(GTK_LABEL(about), about_txt);
1431 + g_free(about_txt);
1432 + gtk_box_pack_start(GTK_BOX(box), about, FALSE, FALSE, 12);
1433 +
1434 + g_signal_connect(app->set_apply_btn, "clicked",
1435 + G_CALLBACK(on_settings_apply), app);
1436 + g_signal_connect(app->set_wifi_btn, "clicked",
1437 + G_CALLBACK(on_settings_wifi), app);
1438 +
1439 + settings_fill_timezones(app);
1440 + return box;
1441 +}
1442 +
1443 +/* ── Nawigacja / nagłówek ────────────────────────────────────────────────── */
1444 +static void
1445 +on_sidebar_row(GtkListBox *lb, GtkListBoxRow *row, gpointer data)
1446 +{
1447 + (void) lb;
1448 + App *app = data;
1449 + if (!row)
1450 + return;
1451 + const char *name = g_object_get_data(G_OBJECT(row), "page");
1452 + gtk_stack_set_visible_child_name(GTK_STACK(app->stack), name);
1453 +}
1454 +
1455 +/* Wybierz stronę po nazwie ("news", "install", …). */
1456 +static void
1457 +select_page(App *app, const char *name)
1458 +{
1459 + static const char *pages[] = {"news", "install", "update", "store",
1460 + "settings"};
1461 + int idx = 0;
1462 + if (name) {
1463 + for (int i = 0; i < 5; i++) {
1464 + if (g_strcmp0(pages[i], name) == 0) {
1465 + idx = i;
1466 + break;
1467 + }
1468 + }
1469 + }
1470 + GtkListBoxRow *row = gtk_list_box_get_row_at_index(GTK_LIST_BOX(app->sidebar),
1471 + idx);
1472 + if (row)
1473 + gtk_list_box_select_row(GTK_LIST_BOX(app->sidebar), row);
1474 + else
1475 + gtk_stack_set_visible_child_name(GTK_STACK(app->stack), pages[idx]);
1476 +}
1477 +
1478 +static void
1479 +on_lang_changed(GtkComboBox *combo, gpointer data)
1480 +{
1481 + App *app = data;
1482 + int idx = gtk_combo_box_get_active(combo);
1483 + const char *lang = (idx == 1) ? "en" : "pl";
1484 + pw_i18n_set_lang(lang);
1485 + g_free(app->cfg->lang);
1486 + app->cfg->lang = g_strdup(lang);
1487 + pw_config_save(app->cfg);
1488 + retranslate(app);
1489 + news_reload(app);
1490 + if (app->store_selected)
1491 + store_show_details(app);
1492 +}
1493 +
1494 +static GtkWidget *
1495 +build_sidebar(App *app)
1496 +{
1497 + GtkWidget *lb = gtk_list_box_new();
1498 + gtk_list_box_set_selection_mode(GTK_LIST_BOX(lb), GTK_SELECTION_SINGLE);
1499 + const char *pages[] = {"news", "install", "update", "store", "settings"};
1500 + const char *keys[] = {"nav_news", "nav_install", "nav_update", "nav_store",
1501 + "nav_settings"};
1502 + for (gsize i = 0; i < G_N_ELEMENTS(pages); i++) {
1503 + GtkWidget *row = gtk_list_box_row_new();
1504 + GtkWidget *lbl = gtk_label_new(pw_tr(keys[i]));
1505 + gtk_label_set_xalign(GTK_LABEL(lbl), 0.0);
1506 + gtk_widget_set_margin_start(lbl, 10);
1507 + gtk_widget_set_margin_end(lbl, 10);
1508 + gtk_widget_set_margin_top(lbl, 8);
1509 + gtk_widget_set_margin_bottom(lbl, 8);
1510 + gtk_container_add(GTK_CONTAINER(row), lbl);
1511 + g_object_set_data(G_OBJECT(row), "page", (gpointer) pages[i]);
1512 + gtk_list_box_insert(GTK_LIST_BOX(lb), row, -1);
1513 + tr_register(app, lbl, keys[i], TRUE);
1514 + }
1515 + GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
1516 + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
1517 + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
1518 + gtk_widget_set_size_request(scroll, 180, -1);
1519 + gtk_container_add(GTK_CONTAINER(scroll), lb);
1520 + g_signal_connect(lb, "row-selected", G_CALLBACK(on_sidebar_row), app);
1521 + app->sidebar = lb;
1522 + return scroll;
1523 +}
1524 +
1525 +static void
1526 +window_destroy_cb(GtkWidget *w, gpointer data)
1527 +{
1528 + (void) w;
1529 + App *app = data;
1530 + app->window = NULL;
1531 + if (!app->tray_mode)
1532 + gtk_main_quit();
1533 +}
1534 +
1535 +/* W trybie apletu zamknięcie okna tylko je ukrywa – tray działa dalej. */
1536 +static gboolean
1537 +window_delete_cb(GtkWidget *w, GdkEvent *event, gpointer data)
1538 +{
1539 + (void) event;
1540 + App *app = data;
1541 + if (app->tray_mode) {
1542 + gtk_widget_hide(w);
1543 + return TRUE;
1544 + }
1545 + return FALSE;
1546 +}
1547 +
1548 +static void
1549 +build_main_window(App *app)
1550 +{
1551 + app->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1552 + gtk_window_set_title(GTK_WINDOW(app->window), pw_tr("app_title"));
1553 + gtk_window_set_default_size(GTK_WINDOW(app->window), 1040, 700);
1554 + gtk_window_set_position(GTK_WINDOW(app->window), GTK_WIN_POS_CENTER);
1555 + gtk_window_set_icon_name(GTK_WINDOW(app->window), "pagan-welcome");
1556 + g_signal_connect(app->window, "destroy", G_CALLBACK(window_destroy_cb), app);
1557 + g_signal_connect(app->window, "delete-event", G_CALLBACK(window_delete_cb),
1558 + app);
1559 +
1560 + GtkWidget *outer = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
1561 + gtk_container_add(GTK_CONTAINER(app->window), outer);
1562 +
1563 + /* Nagłówek */
1564 + GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
1565 + gtk_container_set_border_width(GTK_CONTAINER(header), 12);
1566 + GtkWidget *titles = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
1567 + app->header_title = gtk_label_new(pw_tr("app_title"));
1568 + gtk_label_set_xalign(GTK_LABEL(app->header_title), 0.0);
1569 + PangoAttrList *attrs = pango_attr_list_new();
1570 + pango_attr_list_insert(attrs, pango_attr_weight_new(PANGO_WEIGHT_BOLD));
1571 + pango_attr_list_insert(attrs, pango_attr_scale_new(1.3));
1572 + gtk_label_set_attributes(GTK_LABEL(app->header_title), attrs);
1573 + pango_attr_list_unref(attrs);
1574 + app->header_tagline = gtk_label_new(pw_tr("app_tagline"));
1575 + gtk_label_set_xalign(GTK_LABEL(app->header_tagline), 0.0);
1576 + gtk_widget_set_opacity(app->header_tagline, 0.7);
1577 + gtk_box_pack_start(GTK_BOX(titles), app->header_title, FALSE, FALSE, 0);
1578 + gtk_box_pack_start(GTK_BOX(titles), app->header_tagline, FALSE, FALSE, 0);
1579 + gtk_box_pack_start(GTK_BOX(header), titles, FALSE, FALSE, 0);
1580 +
1581 + GtkWidget *langbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
1582 + GtkWidget *langlbl = gtk_label_new(pw_tr("common_language"));
1583 + gtk_box_pack_start(GTK_BOX(langbox), langlbl, FALSE, FALSE, 0);
1584 + app->lang_combo = gtk_combo_box_text_new();
1585 + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->lang_combo), "Polski");
1586 + gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(app->lang_combo), "English");
1587 + gtk_combo_box_set_active(GTK_COMBO_BOX(app->lang_combo),
1588 + g_strcmp0(app->cfg->lang, "en") == 0 ? 1 : 0);
1589 + g_signal_connect(app->lang_combo, "changed", G_CALLBACK(on_lang_changed), app);
1590 + gtk_box_pack_start(GTK_BOX(langbox), app->lang_combo, FALSE, FALSE, 0);
1591 + app->dont_show_check = gtk_check_button_new_with_label(
1592 + pw_tr("dont_show_again"));
1593 + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(app->dont_show_check),
1594 + !app->cfg->show_on_login);
1595 + g_signal_connect(app->dont_show_check, "toggled",
1596 + G_CALLBACK(on_dont_show_toggled), app);
1597 + gtk_box_pack_start(GTK_BOX(langbox), app->dont_show_check, FALSE, FALSE, 6);
1598 + gtk_box_pack_end(GTK_BOX(header), langbox, FALSE, FALSE, 0);
1599 + gtk_box_pack_start(GTK_BOX(outer), header, FALSE, FALSE, 0);
1600 + gtk_box_pack_start(GTK_BOX(outer), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL),
1601 + FALSE, FALSE, 0);
1602 +
1603 + /* Ciało: sidebar + stack */
1604 + GtkWidget *body = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
1605 + gtk_box_pack_start(GTK_BOX(body), build_sidebar(app), FALSE, FALSE, 0);
1606 + gtk_box_pack_start(GTK_BOX(body), gtk_separator_new(GTK_ORIENTATION_VERTICAL),
1607 + FALSE, FALSE, 0);
1608 + app->stack = gtk_stack_new();
1609 + gtk_stack_set_transition_type(GTK_STACK(app->stack),
1610 + GTK_STACK_TRANSITION_TYPE_CROSSFADE);
1611 + gtk_stack_add_named(GTK_STACK(app->stack), build_news_page(app), "news");
1612 + gtk_stack_add_named(GTK_STACK(app->stack), build_install_page(app), "install");
1613 + gtk_stack_add_named(GTK_STACK(app->stack), build_update_page(app), "update");
1614 + gtk_stack_add_named(GTK_STACK(app->stack), build_store_page(app), "store");
1615 + gtk_stack_add_named(GTK_STACK(app->stack), build_settings_page(app), "settings");
1616 + gtk_box_pack_start(GTK_BOX(body), app->stack, TRUE, TRUE, 0);
1617 + gtk_box_pack_start(GTK_BOX(outer), body, TRUE, TRUE, 0);
1618 +
1619 + /* Sygnały akcji */
1620 + g_signal_connect(app->news_refresh, "clicked", G_CALLBACK(on_news_refresh), app);
1621 + g_signal_connect(app->news_browser, "clicked", G_CALLBACK(on_news_browser), app);
1622 + g_signal_connect(app->install_btn, "clicked", G_CALLBACK(on_install_clicked),
1623 + app);
1624 + g_signal_connect(app->update_check_btn, "clicked",
1625 + G_CALLBACK(on_update_check_clicked), app);
1626 + g_signal_connect(app->update_btn, "clicked", G_CALLBACK(on_update_clicked), app);
1627 + g_signal_connect(app->update_terminal_btn, "clicked",
1628 + G_CALLBACK(on_update_terminal_clicked), app);
1629 +
1630 + /* Wybór strony i wstępne wczytanie danych. Ważna kolejność: show_all
1631 + * rozgłasza widoczność na WSZYSTKIE dzieci GtkStack, więc widoczną stronę
1632 + * ustawiamy dopiero po nim. */
1633 + gtk_widget_show_all(app->window);
1634 + select_page(app, app->start_page ? app->start_page : "news");
1635 + install_update_state(app);
1636 + news_reload(app);
1637 + store_load(app);
1638 + settings_load(app);
1639 +}
1640 +
1641 +/* ── Aplet tray ──────────────────────────────────────────────────────────── */
1642 +static void
1643 +tray_notify(App *app, int count)
1644 +{
1645 + (void) app;
1646 + if (!notify_is_initted() || count <= 0)
1647 + return;
1648 + char *body = g_strdup_printf(pw_tr("tray_notify_body"), count);
1649 + NotifyNotification *n = notify_notification_new(pw_tr("tray_notify_title"),
1650 + body, "software-update-available");
1651 + g_free(body);
1652 + notify_notification_set_urgency(n, NOTIFY_URGENCY_NORMAL);
1653 + GError *err = NULL;
1654 + if (!notify_notification_show(n, &err))
1655 + g_clear_error(&err);
1656 + g_object_unref(n);
1657 +}
1658 +
1659 +static void
1660 +tray_check_done(int status, gpointer data)
1661 +{
1662 + App *app = data;
1663 + app->tray_busy = FALSE;
1664 + if (status != 0)
1665 + return;
1666 + int count = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(app->tray_icon),
1667 + "updates"));
1668 + if (count > 0) {
1669 + char *tip = g_strdup_printf("%s – %d", pw_tr("tray_tooltip"), count);
1670 + gtk_status_icon_set_tooltip_text(app->tray_icon, tip);
1671 + g_free(tip);
1672 + /* Powiadomienie pokazujemy TYLKO RAZ dla danego stanu aktualizacji.
1673 + * Aplet sprawdza je co 6 h (i przy każdym kliknięciu „Sprawdź
1674 + * aktualizacje”), więc bez tego warunku użytkownik dostawał to samo
1675 + * powiadomienie w kółko. Gdy liczba się zmieni (doszły nowe
1676 + * aktualizacje) – powiadamiamy ponownie. */
1677 + if (count != app->tray_notified) {
1678 + tray_notify(app, count);
1679 + app->tray_notified = count;
1680 + }
1681 + } else {
1682 + gtk_status_icon_set_tooltip_text(app->tray_icon, pw_tr("tray_up_to_date"));
1683 + /* Brak aktualizacji → następny zestaw znów będzie „nowy” i powiadomi. */
1684 + app->tray_notified = 0;
1685 + }
1686 +}
1687 +
1688 +static void
1689 +tray_check_line(const char *line, gpointer data)
1690 +{
1691 + App *app = data;
1692 + char **f = split_tabs(line);
1693 + if (g_strcmp0(f[0], "UPDATES") == 0 && f[1])
1694 + g_object_set_data(G_OBJECT(app->tray_icon), "updates",
1695 + GINT_TO_POINTER(atoi(f[1])));
1696 + g_strfreev(f);
1697 +}
1698 +
1699 +static gboolean
1700 +tray_check(gpointer data)
1701 +{
1702 + App *app = data;
1703 + if (app->tray_busy)
1704 + return G_SOURCE_CONTINUE;
1705 + app->tray_busy = TRUE;
1706 + const char *args[] = {"updates", NULL};
1707 + pw_backend(args, tray_check_line, tray_check_done, app);
1708 + return G_SOURCE_CONTINUE;
1709 +}
1710 +
1711 +static void
1712 +tray_open_window(GtkMenuItem *item, gpointer data)
1713 +{
1714 + (void) item;
1715 + App *app = data;
1716 + if (!app->window)
1717 + build_main_window(app);
1718 + gtk_window_present(GTK_WINDOW(app->window));
1719 +}
1720 +
1721 +static void
1722 +tray_update_now(GtkMenuItem *item, gpointer data)
1723 +{
1724 + (void) item;
1725 + App *app = data;
1726 + if (!app->window)
1727 + build_main_window(app);
1728 + gtk_window_present(GTK_WINDOW(app->window));
1729 + /* Przełącz na stronę aktualizacji i uruchom aktualizację. */
1730 + gtk_stack_set_visible_child_name(GTK_STACK(app->stack), "update");
1731 + on_update_clicked(NULL, app);
1732 +}
1733 +
1734 +static void
1735 +tray_quit(GtkMenuItem *item, gpointer data)
1736 +{
1737 + (void) item;
1738 + (void) data;
1739 + gtk_main_quit();
1740 +}
1741 +
1742 +static void
1743 +tray_activate(GtkStatusIcon *icon, gpointer data)
1744 +{
1745 + (void) icon;
1746 + tray_open_window(NULL, data);
1747 +}
1748 +
1749 +static void
1750 +tray_popup(GtkStatusIcon *icon, guint button, guint time, gpointer data)
1751 +{
1752 + (void) icon;
1753 + App *app = data;
1754 + gtk_menu_popup(GTK_MENU(app->tray_menu), NULL, NULL,
1755 + gtk_status_icon_position_menu, app->tray_icon, button, time);
1756 +}
1757 +
1758 +static void
1759 +tray_check_clicked(GtkMenuItem *item, gpointer data)
1760 +{
1761 + (void) item;
1762 + App *app = data;
1763 + if (!app->tray_busy)
1764 + tray_check(app);
1765 +}
1766 +
1767 +static void
1768 +tray_open_settings(GtkMenuItem *item, gpointer data)
1769 +{
1770 + (void) item;
1771 + App *app = data;
1772 + if (!app->window)
1773 + build_main_window(app);
1774 + gtk_window_present(GTK_WINDOW(app->window));
1775 + gtk_stack_set_visible_child_name(GTK_STACK(app->stack), "settings");
1776 +}
1777 +
1778 +static void
1779 +tray_start(App *app)
1780 +{
1781 + app->tray_mode = TRUE;
1782 + app->tray_menu = gtk_menu_new();
1783 +
1784 + const char *keys[] = {"tray_check", "tray_update", "tray_open",
1785 + "tray_settings", "tray_quit"};
1786 + for (int i = 0; i < 5; i++) {
1787 + app->tray_items[i] = gtk_menu_item_new_with_label(pw_tr(keys[i]));
1788 + gtk_menu_shell_append(GTK_MENU_SHELL(app->tray_menu),
1789 + app->tray_items[i]);
1790 + if (i == 1 || i == 3)
1791 + gtk_menu_shell_append(GTK_MENU_SHELL(app->tray_menu),
1792 + gtk_separator_menu_item_new());
1793 + }
1794 + g_signal_connect(app->tray_items[0], "activate",
1795 + G_CALLBACK(tray_check_clicked), app);
1796 + g_signal_connect(app->tray_items[1], "activate",
1797 + G_CALLBACK(tray_update_now), app);
1798 + g_signal_connect(app->tray_items[2], "activate",
1799 + G_CALLBACK(tray_open_window), app);
1800 + g_signal_connect(app->tray_items[3], "activate",
1801 + G_CALLBACK(tray_open_settings), app);
1802 + g_signal_connect(app->tray_items[4], "activate", G_CALLBACK(tray_quit), app);
1803 + gtk_widget_show_all(app->tray_menu);
1804 +
1805 + if (g_file_test("/usr/share/pixmaps/pagan-welcome.png", G_FILE_TEST_EXISTS))
1806 + app->tray_icon = gtk_status_icon_new_from_file(
1807 + "/usr/share/pixmaps/pagan-welcome.png");
1808 + else
1809 + app->tray_icon = gtk_status_icon_new_from_icon_name(
1810 + "software-update-available");
1811 + gtk_status_icon_set_tooltip_text(app->tray_icon, pw_tr("tray_tooltip"));
1812 + gtk_status_icon_set_visible(app->tray_icon, TRUE);
1813 + g_signal_connect(app->tray_icon, "activate", G_CALLBACK(tray_activate), app);
1814 + g_signal_connect(app->tray_icon, "popup-menu", G_CALLBACK(tray_popup), app);
1815 +
1816 + /* Pierwsze sprawdzenie po 20 s, potem cyklicznie. */
1817 + app->tray_notified = -1; /* o niczym jeszcze nie powiadomiliśmy */
1818 + g_timeout_add_seconds(20, tray_check, app);
1819 + app->tray_timer = g_timeout_add_seconds(PW_TRAY_INTERVAL_SEC, tray_check, app);
1820 +
1821 + /* Okno na starcie tylko gdy użytkownik sobie tego życzy. */
1822 + if (app->cfg->show_on_login) {
1823 + build_main_window(app);
1824 + gtk_widget_show_all(app->window);
1825 + }
1826 +}
1827 +
1828 +/* ── CLI ─────────────────────────────────────────────────────────────────── */
1829 +static int
1830 +cli_check(void)
1831 +{
1832 + char *out = pw_run_capture((const char *const[]) {
1833 + pw_backend_path(), "updates", NULL});
1834 + if (!out) {
1835 + g_printerr("Nie udało się uruchomić backendu: %s\n", pw_backend_path());
1836 + return 1;
1837 + }
1838 + char **lines = g_strsplit(out, "\n", -1);
1839 + int rc = 1;
1840 + for (gsize i = 0; lines[i]; i++) {
1841 + char **f = split_tabs(lines[i]);
1842 + if (g_strcmp0(f[0], "UPDATES") == 0 && f[1]) {
1843 + g_print("%d\n", atoi(f[1]));
1844 + rc = 0;
1845 + }
1846 + g_strfreev(f);
1847 + }
1848 + g_strfreev(lines);
1849 + g_free(out);
1850 + return rc;
1851 +}
1852 +
1853 +static void
1854 +app_free(App *app)
1855 +{
1856 + if (!app)
1857 + return;
1858 + pw_config_free(app->cfg);
1859 + g_free(app->store_selected);
1860 + if (app->packages)
1861 + g_hash_table_destroy(app->packages);
1862 + if (app->installed)
1863 + g_hash_table_destroy(app->installed);
1864 + for (GList *l = app->tr_entries; l; l = g_list_next(l)) {
1865 + TrEntry *e = l->data;
1866 + g_free(e->key);
1867 + g_free(e);
1868 + }
1869 + g_list_free(app->tr_entries);
1870 + g_free(app);
1871 +}
1872 +
1873 +int
1874 +main(int argc, char **argv)
1875 +{
1876 + gboolean tray = FALSE;
1877 + const char *start_page = NULL;
1878 + for (int i = 1; i < argc; i++) {
1879 + if (g_strcmp0(argv[i], "--tray") == 0)
1880 + tray = TRUE;
1881 + else if (g_strcmp0(argv[i], "--page") == 0 && i + 1 < argc)
1882 + start_page = argv[++i];
1883 + else if (g_strcmp0(argv[i], "--version") == 0) {
1884 + g_print("pagan-welcome %s\n", PW_VERSION);
1885 + return 0;
1886 + } else if (g_strcmp0(argv[i], "--check") == 0) {
1887 + return cli_check();
1888 + } else if (g_strcmp0(argv[i], "--help") == 0 ||
1889 + g_strcmp0(argv[i], "-h") == 0) {
1890 + g_print("Użycie: pagan-welcome [--tray|--check|--version|"
1891 + " --page <news|install|update|store|settings>]\n");
1892 + return 0;
1893 + }
1894 + }
1895 +
1896 + gtk_init(&argc, &argv);
1897 + notify_init("pagan-welcome");
1898 +
1899 + g_app = g_new0(App, 1);
1900 + g_app->cfg = pw_config_load();
1901 + g_app->start_page = start_page;
1902 + pw_i18n_set_lang(g_app->cfg->lang);
1903 +
1904 + if (tray) {
1905 + gtk_window_set_default_icon_name("pagan-welcome");
1906 + tray_start(g_app);
1907 + } else {
1908 + build_main_window(g_app);
1909 + }
1910 +
1911 + gtk_main();
1912 +
1913 + if (g_app->tray_icon)
1914 + g_object_unref(g_app->tray_icon);
1915 + if (notify_is_initted())
1916 + notify_uninit();
1917 + app_free(g_app);
1918 + return 0;
1919 +}
0 1920 new file mode 100755
@@ -0,0 +1,15 @@
1 +[Desktop Entry]
2 +Type=Application
3 +Version=1.0
4 +Name=Pagan-Welcome
5 +Name[pl]=Pagan-Welcome
6 +Comment=Start centre for PaganLinux
7 +Comment[pl]=Centrum startowe PaganLinux
8 +Comment[de]=Startzentrum für PaganLinux
9 +Exec=/usr/bin/pagan-welcome
10 +Icon=pagan-welcome
11 +Terminal=false
12 +Categories=System;Settings;Utility;
13 +Keywords=pagan;paganlinux;welcome;news;updates;store;
14 +Keywords[pl]=pagan;paganlinux;nowosci;aktualizacje;sklep;
15 +StartupNotify=true
0 16 new file mode 100644
1 17 Binary files /dev/null and b/pagan-welcome.png differ
2 18 new file mode 100644
@@ -0,0 +1,229 @@
1 +/* pagan-welcome – implementacja tłumaczeń PL/EN. */
2 +#include "pw-i18n.h"
3 +
4 +#include <stdarg.h>
5 +#include <string.h>
6 +
7 +typedef struct {
8 + const char *key;
9 + const char *pl;
10 + const char *en;
11 +} Entry;
12 +
13 +static const Entry TABLE[] = {
14 + /* ── Aplikacja ─────────────────────────────────────────────────────── */
15 + {"app_title", "Pagan-Welcome", "Pagan-Welcome"},
16 + {"app_tagline", "Witaj w PaganLinux", "Welcome to PaganLinux"},
17 +
18 + /* ── Nawigacja ─────────────────────────────────────────────────────── */
19 + {"nav_news", "Nowości", "News"},
20 + {"nav_install", "Instalator", "Installer"},
21 + {"nav_update", "Aktualizacja", "Update"},
22 + {"nav_store", "Sklep", "Store"},
23 + {"nav_settings", "Ustawienia", "Settings"},
24 +
25 + /* ── Wspólne ───────────────────────────────────────────────────────── */
26 + {"common_refresh", "Odśwież", "Refresh"},
27 + {"common_loading", "Ładowanie…", "Loading…"},
28 + {"common_working", "Pracuję…", "Working…"},
29 + {"common_error", "Błąd", "Error"},
30 + {"common_close", "Zamknij", "Close"},
31 + {"common_cancel", "Anuluj", "Cancel"},
32 + {"common_yes", "Tak", "Yes"},
33 + {"common_no", "Nie", "No"},
34 + {"common_language", "Język", "Language"},
35 + {"common_never", "nigdy", "never"},
36 + {"common_password_title", "Hasło administratora", "Administrator password"},
37 + {"common_password_prompt",
38 + "Ta operacja wymaga uprawnień root.\nPodaj hasło sudo:",
39 + "This operation requires root privileges.\nEnter your sudo password:"},
40 +
41 + /* ── Nowości ───────────────────────────────────────────────────────── */
42 + {"news_title", "Co nowego w PaganLinux", "What's new in PaganLinux"},
43 + {"news_subtitle", "Najnowsze informacje o wydaniach systemu",
44 + "Latest system release information"},
45 + {"news_open_browser", "Otwórz w przeglądarce", "Open in browser"},
46 + {"news_updated", "Zaktualizowano", "Updated"},
47 + {"news_cached", "Dane z pamięci podręcznej", "Cached data"},
48 + {"news_empty", "Brak dostępnych nowości.", "No news available."},
49 + {"news_fetch_error", "Nie udało się pobrać nowości.",
50 + "Failed to fetch the news."},
51 +
52 + /* ── Instalator ────────────────────────────────────────────────────── */
53 + {"install_title", "Instalator systemu", "System installer"},
54 + {"install_subtitle", "Zainstaluj PaganLinux na dysku",
55 + "Install PaganLinux to disk"},
56 + {"install_desc",
57 + "Uruchom graficzny instalator Calamares, aby zainstalować PaganLinux na "
58 + "dysku twardym.\n\nUwaga: wszystkie dane na wybranym dysku lub partycji "
59 + "zostaną nadpisane. Przed instalacją wykonaj kopię zapasową.",
60 + "Launch the Calamares graphical installer to install PaganLinux on a hard "
61 + "drive.\n\nWarning: all data on the selected disk or partition will be "
62 + "overwritten. Back up your data before installing."},
63 + {"install_button", "Uruchom instalator", "Launch installer"},
64 + {"install_live_only",
65 + "Instalator jest dostępny tylko w sesji live (uruchomionej z pendrive'a "
66 + "lub ISO). Ten system jest już zainstalowany na dysku.",
67 + "The installer is only available in a live session (booted from a USB "
68 + "stick or ISO). This system is already installed on disk."},
69 + {"install_running", "Instalator jest uruchomiony…", "Installer is running…"},
70 + {"install_done", "Instalator zakończył pracę.", "Installer finished."},
71 + {"install_missing", "Nie znaleziono programu Calamares (/usr/bin/calamares).",
72 + "Calamares not found (/usr/bin/calamares)."},
73 + {"install_confirm", "Uruchomić instalator systemu?",
74 + "Launch the system installer?"},
75 +
76 + /* ── Aktualizacja ──────────────────────────────────────────────────── */
77 + {"update_title", "Aktualizacja systemu", "System update"},
78 + {"update_subtitle", "PaganLinux to system typu rolling release",
79 + "PaganLinux is a rolling release"},
80 + {"update_desc",
81 + "Pobierz najnowsze pakiety z repozytorium PAG i zaktualizuj system.\n\n"
82 + "Zalecane jest regularne aktualizowanie systemu. Aktualizacja obejmuje "
83 + "jądro, sterowniki i całe oprogramowanie.",
84 + "Fetch the latest packages from the PAG repository and update the "
85 + "system.\n\nRegular updates are recommended. An update covers the kernel, "
86 + "drivers and all software."},
87 + {"update_button", "Aktualizuj system", "Update system"},
88 + {"update_check_button", "Sprawdź aktualizacje", "Check for updates"},
89 + {"update_running", "Aktualizacja w toku…", "Updating…"},
90 + {"update_done", "Aktualizacja zakończona.", "Update finished."},
91 + {"update_failed", "Aktualizacja nie powiodła się.", "Update failed."},
92 + {"update_uptodate", "System jest aktualny.", "System is up to date."},
93 + {"update_available", "Dostępne aktualizacje: %d", "Available updates: %d"},
94 + {"update_confirm", "Rozpocząć aktualizację systemu?",
95 + "Start the system update?"},
96 + {"update_reboot", "Zalecany restart po aktualizacji jądra.",
97 + "A reboot is recommended after a kernel update."},
98 + {"update_terminal_button", "Aktualizuj w terminalu", "Update in terminal"},
99 + {"update_sync", "Synchronizacja repozytorium…", "Syncing repository…"},
100 + {"update_upgrade", "Aktualizacja pakietów…", "Upgrading packages…"},
101 +
102 + /* ── Sklep ─────────────────────────────────────────────────────────── */
103 + {"store_title", "Sklep z pakietami", "Package store"},
104 + {"store_subtitle", "Przeglądaj i instaluj oprogramowanie z repozytorium PAG",
105 + "Browse and install software from the PAG repository"},
106 + {"store_search_placeholder", "Szukaj pakietu (nazwa lub opis)…",
107 + "Search packages (name or description)…"},
108 + {"store_col_name", "Pakiet", "Package"},
109 + {"store_col_version", "Wersja", "Version"},
110 + {"store_col_size", "Rozmiar", "Size"},
111 + {"store_col_desc", "Opis", "Description"},
112 + {"store_install", "Zainstaluj", "Install"},
113 + {"store_remove", "Usuń", "Remove"},
114 + {"store_installed", "Zainstalowany", "Installed"},
115 + {"store_not_installed", "Niezainstalowany", "Not installed"},
116 + {"store_details", "Szczegóły", "Details"},
117 + {"store_depends", "Zależności", "Dependencies"},
118 + {"store_license", "Licencja", "License"},
119 + {"store_loading", "Pobieram listę pakietów…", "Fetching package list…"},
120 + {"store_error", "Nie udało się pobrać listy pakietów.",
121 + "Failed to fetch the package list."},
122 + {"store_no_results", "Brak wyników.", "No results."},
123 + {"store_count", "Pakietów: %d • zainstalowanych: %d",
124 + "Packages: %d • installed: %d"},
125 + {"store_select", "Wybierz pakiet z listy, aby zobaczyć szczegóły.",
126 + "Select a package from the list to see details."},
127 + {"store_installing", "Instaluję %s…", "Installing %s…"},
128 + {"store_install_ok", "Zainstalowano: %s", "Installed: %s"},
129 + {"store_install_fail", "Instalacja nie powiodła się: %s",
130 + "Installation failed: %s"},
131 + {"store_confirm", "Zainstalować pakiet „%s”?", "Install package \"%s\"?"},
132 + {"store_confirm_remove", "Usunąć pakiet „%s”?", "Remove package \"%s\"?"},
133 + {"store_remove_ok", "Usunięto: %s", "Removed: %s"},
134 + {"store_remove_fail", "Nie udało się usunąć: %s", "Failed to remove: %s"},
135 + {"store_none", "brak", "none"},
136 +
137 + /* ── Ustawienia ────────────────────────────────────────────────────── */
138 + {"settings_title", "Ustawienia podstawowe", "Basic settings"},
139 + {"settings_subtitle", "Język, klawiatura, czas i sieć",
140 + "Language, keyboard, time and network"},
141 + {"settings_language", "Język systemu", "System language"},
142 + {"settings_keyboard", "Układ klawiatury", "Keyboard layout"},
143 + {"settings_timezone", "Strefa czasowa", "Timezone"},
144 + {"settings_hostname", "Nazwa komputera", "Hostname"},
145 + {"settings_network", "Sieć", "Network"},
146 + {"settings_network_hint", "Połącz z siecią Wi-Fi (NetworkManager).",
147 + "Connect to a Wi-Fi network (NetworkManager)."},
148 + {"settings_wifi_button", "Połącz z Wi-Fi", "Connect to Wi-Fi"},
149 + {"settings_apply", "Zastosuj", "Apply"},
150 + {"settings_saved", "Zapisano ustawienia.", "Settings saved."},
151 + {"settings_failed", "Nie udało się zapisać ustawień.",
152 + "Failed to save the settings."},
153 + {"settings_restart_hint", "Zmiana języka wymaga ponownego zalogowania.",
154 + "Changing the language requires re-login."},
155 + {"settings_about", "O systemie", "About"},
156 + {"settings_about_text",
157 + "PaganLinux – niezależna polska dystrybucja Linuksa.\n"
158 + "Zbudowana od podstaw (Linux From Scratch) z własnym menedżerem pakietów "
159 + "pag i systemem budowania.",
160 + "PaganLinux – an independent Polish Linux distribution.\n"
161 + "Built from scratch (Linux From Scratch) with its own package manager pag "
162 + "and build system."},
163 + {"settings_loading", "Wczytuję ustawienia…", "Loading settings…"},
164 +
165 + /* ── Nie pokazuj więcej / autostart ────────────────────────────────── */
166 + {"dont_show_again", "Nie pokazuj tego okna przy logowaniu",
167 + "Don't show this window at login"},
168 + {"autostart_enabled", "Pagan-Welcome będzie się uruchamiał przy logowaniu.",
169 + "Pagan-Welcome will start at login."},
170 + {"autostart_disabled", "Pagan-Welcome nie będzie się uruchamiał przy logowaniu.",
171 + "Pagan-Welcome will not start at login."},
172 +
173 + /* ── Aplet / tray ──────────────────────────────────────────────────── */
174 + {"tray_check", "Sprawdź aktualizacje", "Check for updates"},
175 + {"tray_update", "Aktualizuj system", "Update system"},
176 + {"tray_open", "Otwórz Pagan-Welcome", "Open Pagan-Welcome"},
177 + {"tray_settings", "Ustawienia", "Settings"},
178 + {"tray_quit", "Zakończ", "Quit"},
179 + {"tray_updates_available", "Dostępne aktualizacje: %d",
180 + "Available updates: %d"},
181 + {"tray_up_to_date", "System jest aktualny", "System is up to date"},
182 + {"tray_checking", "Sprawdzam aktualizacje…", "Checking for updates…"},
183 + {"tray_notify_title", "PaganLinux – aktualizacje",
184 + "PaganLinux – updates"},
185 + {"tray_notify_body",
186 + "Dostępnych jest %d aktualizacji pakietów. Kliknij, aby otworzyć "
187 + "Pagan-Welcome.",
188 + "%d package updates are available. Click to open Pagan-Welcome."},
189 + {"tray_tooltip", "PaganLinux – aktualizacje", "PaganLinux – updates"},
190 +};
191 +
192 +static const char *cur_lang = "pl";
193 +
194 +void
195 +pw_i18n_set_lang(const char *lang)
196 +{
197 + if (lang && (g_strcmp0(lang, "en") == 0 || g_strcmp0(lang, "pl") == 0))
198 + cur_lang = g_strcmp0(lang, "en") == 0 ? "en" : "pl";
199 + else
200 + cur_lang = "pl";
201 +}
202 +
203 +const char *
204 +pw_i18n_lang(void)
205 +{
206 + return cur_lang;
207 +}
208 +
209 +const char *
210 +pw_tr(const char *key)
211 +{
212 + const gboolean en = (g_strcmp0(cur_lang, "en") == 0);
213 + for (gsize i = 0; i < G_N_ELEMENTS(TABLE); i++) {
214 + if (g_strcmp0(TABLE[i].key, key) == 0)
215 + return en ? TABLE[i].en : TABLE[i].pl;
216 + }
217 + return key;
218 +}
219 +
220 +char *
221 +pw_trf(const char *key, ...)
222 +{
223 + const char *fmt = pw_tr(key);
224 + va_list ap;
225 + va_start(ap, key);
226 + char *out = g_strdup_vprintf(fmt, ap);
227 + va_end(ap);
228 + return out;
229 +}
0 230 new file mode 100644
@@ -0,0 +1,21 @@
1 +/* pagan-welcome – tłumaczenia interfejsu (PL/EN).
2 + *
3 + * Tabela par klucz → {polski, angielski}. Brak tłumaczenia spada do polskiego,
4 + * a gdy i tam klucza nie ma – zwracany jest sam klucz (łatwo wykryć braki).
5 + */
6 +#ifndef PW_I18N_H
7 +#define PW_I18N_H
8 +
9 +#include <glib.h>
10 +
11 +/* Ustaw aktywny język ("pl"/"en"). Nieznany kod → "pl". */
12 +void pw_i18n_set_lang(const char *lang);
13 +const char *pw_i18n_lang(void);
14 +
15 +/* Przetłumaczony tekst dla klucza. */
16 +const char *pw_tr(const char *key);
17 +
18 +/* Jak pw_tr, ale z podstawieniem argumentów printf (zwraca nowy łańcuch). */
19 +char *pw_trf(const char *key, ...) G_GNUC_PRINTF(1, 2);
20 +
21 +#endif /* PW_I18N_H */
0 22 new file mode 100644
@@ -0,0 +1,479 @@
1 +/* pagan-welcome – implementacja konfiguracji i uruchamiania poleceń. */
2 +#include "pw-util.h"
3 +
4 +#include <gio/gio.h>
5 +#include <errno.h>
6 +#include <limits.h>
7 +#include <stdio.h>
8 +#include <string.h>
9 +#include <unistd.h>
10 +
11 +/* ── Konfiguracja ────────────────────────────────────────────────────────── */
12 +static char *
13 +config_dir(void)
14 +{
15 + return g_build_filename(g_get_user_config_dir(), "pagan-welcome", NULL);
16 +}
17 +
18 +static char *
19 +config_path(void)
20 +{
21 + char *dir = config_dir();
22 + char *path = g_build_filename(dir, "config.ini", NULL);
23 + g_free(dir);
24 + return path;
25 +}
26 +
27 +static char *
28 +env_lang_default(void)
29 +{
30 + const char *env = g_getenv("LC_ALL");
31 + if (!env || !*env)
32 + env = g_getenv("LC_MESSAGES");
33 + if (!env || !*env)
34 + env = g_getenv("LANG");
35 + if (env && g_str_has_prefix(env, "en"))
36 + return g_strdup("en");
37 + return g_strdup("pl");
38 +}
39 +
40 +PwConfig *
41 +pw_config_load(void)
42 +{
43 + PwConfig *cfg = g_new0(PwConfig, 1);
44 + cfg->lang = env_lang_default();
45 + cfg->show_on_login = TRUE;
46 +
47 + char *path = config_path();
48 + GKeyFile *kf = g_key_file_new();
49 + if (g_key_file_load_from_file(kf, path, G_KEY_FILE_NONE, NULL)) {
50 + char *lang = g_key_file_get_string(kf, "general", "language", NULL);
51 + if (lang && (g_strcmp0(lang, "pl") == 0 || g_strcmp0(lang, "en") == 0)) {
52 + g_free(cfg->lang);
53 + cfg->lang = lang;
54 + lang = NULL;
55 + }
56 + g_free(lang);
57 + if (g_key_file_has_key(kf, "general", "show_on_login", NULL))
58 + cfg->show_on_login = g_key_file_get_boolean(kf, "general",
59 + "show_on_login", NULL);
60 + }
61 + g_key_file_free(kf);
62 + g_free(path);
63 + return cfg;
64 +}
65 +
66 +void
67 +pw_config_save(const PwConfig *cfg)
68 +{
69 + GKeyFile *kf = g_key_file_new();
70 + g_key_file_set_string(kf, "general", "language", cfg->lang);
71 + g_key_file_set_boolean(kf, "general", "show_on_login", cfg->show_on_login);
72 +
73 + char *dir = config_dir();
74 + g_mkdir_with_parents(dir, 0755);
75 + char *path = config_path();
76 + g_key_file_save_to_file(kf, path, NULL);
77 + g_free(path);
78 + g_free(dir);
79 + g_key_file_free(kf);
80 +}
81 +
82 +void
83 +pw_config_free(PwConfig *cfg)
84 +{
85 + if (!cfg)
86 + return;
87 + g_free(cfg->lang);
88 + g_free(cfg);
89 +}
90 +
91 +/* ── Backend ─────────────────────────────────────────────────────────────── */
92 +const char *
93 +pw_backend_path(void)
94 +{
95 + static char *cached = NULL;
96 + if (cached)
97 + return cached;
98 +
99 + const char *env = g_getenv("PAGAN_WELCOME_BACKEND");
100 + if (env && g_file_test(env, G_FILE_TEST_IS_EXECUTABLE)) {
101 + cached = g_strdup(env);
102 + return cached;
103 + }
104 + const char *candidates[] = {
105 + "/usr/bin/pagan-welcome-backend",
106 + "/usr/lib/pagan-welcome/pagan-welcome-backend.py",
107 + };
108 + for (gsize i = 0; i < G_N_ELEMENTS(candidates); i++) {
109 + if (g_file_test(candidates[i], G_FILE_TEST_EXISTS)) {
110 + cached = g_strdup(candidates[i]);
111 + return cached;
112 + }
113 + }
114 + /* Obok pliku wykonywalnego – tryb uruchomienia ze źródeł. */
115 + char buf[PATH_MAX];
116 + ssize_t n = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
117 + if (n > 0) {
118 + buf[n] = '\0';
119 + char *dir = g_path_get_dirname(buf);
120 + char *local = g_build_filename(dir, "pagan-welcome-backend.py", NULL);
121 + char *local2 = g_build_filename(dir, "pagan-welcome-backend", NULL);
122 + if (g_file_test(local, G_FILE_TEST_EXISTS))
123 + cached = local;
124 + else if (g_file_test(local2, G_FILE_TEST_EXISTS))
125 + cached = local2;
126 + else
127 + g_free(local);
128 + if (!cached)
129 + g_free(local2);
130 + g_free(dir);
131 + }
132 + if (!cached)
133 + cached = g_strdup("pagan-welcome-backend");
134 + return cached;
135 +}
136 +
137 +const char *
138 +pw_pag_path(void)
139 +{
140 + static char *cached = NULL;
141 + if (cached)
142 + return cached;
143 + if (g_file_test("/usr/bin/pag", G_FILE_TEST_EXISTS))
144 + cached = g_strdup("/usr/bin/pag");
145 + else
146 + cached = g_strdup("pag");
147 + return cached;
148 +}
149 +
150 +/* ── Uruchamianie poleceń ────────────────────────────────────────────────── */
151 +typedef struct {
152 + PwLineFunc func;
153 + char *line;
154 + gpointer data;
155 +} LineMsg;
156 +
157 +static gboolean
158 +line_idle(gpointer p)
159 +{
160 + LineMsg *m = p;
161 + m->func(m->line, m->data);
162 + g_free(m->line);
163 + g_free(m);
164 + return G_SOURCE_REMOVE;
165 +}
166 +
167 +typedef struct {
168 + PwDoneFunc func;
169 + int status;
170 + gpointer data;
171 +} DoneMsg;
172 +
173 +static gboolean
174 +done_idle(gpointer p)
175 +{
176 + DoneMsg *m = p;
177 + m->func(m->status, m->data);
178 + g_free(m);
179 + return G_SOURCE_REMOVE;
180 +}
181 +
182 +typedef struct {
183 + char **argv;
184 + char *input;
185 + PwLineFunc on_line;
186 + PwDoneFunc on_done;
187 + gpointer data;
188 +} Job;
189 +
190 +static void
191 +job_emit_line(Job *j, const char *line)
192 +{
193 + if (!j->on_line)
194 + return;
195 + LineMsg *m = g_new0(LineMsg, 1);
196 + m->func = j->on_line;
197 + m->line = g_strdup(line);
198 + m->data = j->data;
199 + g_idle_add(line_idle, m);
200 +}
201 +
202 +static void
203 +job_finish(Job *j, int status)
204 +{
205 + if (j->on_done) {
206 + DoneMsg *m = g_new0(DoneMsg, 1);
207 + m->func = j->on_done;
208 + m->status = status;
209 + m->data = j->data;
210 + g_idle_add(done_idle, m);
211 + }
212 +}
213 +
214 +static gpointer
215 +job_thread(gpointer p)
216 +{
217 + Job *j = p;
218 + GError *err = NULL;
219 + GSubprocessFlags flags = G_SUBPROCESS_FLAGS_STDOUT_PIPE |
220 + G_SUBPROCESS_FLAGS_STDERR_MERGE;
221 + if (j->input)
222 + flags |= G_SUBPROCESS_FLAGS_STDIN_PIPE;
223 +
224 + GSubprocess *proc = g_subprocess_newv((const gchar * const *) j->argv,
225 + flags, &err);
226 + if (!proc) {
227 + job_emit_line(j, err ? err->message : "błąd uruchomienia");
228 + g_clear_error(&err);
229 + job_finish(j, 127);
230 + goto out;
231 + }
232 +
233 + if (j->input) {
234 + GOutputStream *in = g_subprocess_get_stdin_pipe(proc);
235 + gsize written = 0;
236 + g_output_stream_write_all(in, j->input, strlen(j->input), &written,
237 + NULL, NULL);
238 + g_output_stream_close(in, NULL, NULL);
239 + }
240 +
241 + GInputStream *out = g_subprocess_get_stdout_pipe(proc);
242 + GDataInputStream *dis = g_data_input_stream_new(out);
243 + char *line;
244 + while ((line = g_data_input_stream_read_line(dis, NULL, NULL, NULL)) != NULL) {
245 + job_emit_line(j, line);
246 + g_free(line);
247 + }
248 + g_object_unref(dis);
249 + g_subprocess_wait(proc, NULL, NULL);
250 +
251 + int status = -1;
252 + if (g_subprocess_get_if_exited(proc))
253 + status = g_subprocess_get_exit_status(proc);
254 + g_object_unref(proc);
255 + job_finish(j, status);
256 +
257 +out:
258 + g_strfreev(j->argv);
259 + g_free(j->input);
260 + g_free(j);
261 + return NULL;
262 +}
263 +
264 +void
265 +pw_spawn(const char *const argv[], const char *input, PwLineFunc on_line,
266 + PwDoneFunc on_done, gpointer data)
267 +{
268 + Job *j = g_new0(Job, 1);
269 + /* argv jako NULL-zakończona kopia. */
270 + gsize n = 0;
271 + while (argv[n])
272 + n++;
273 + j->argv = g_new0(char *, n + 1);
274 + for (gsize i = 0; i < n; i++)
275 + j->argv[i] = g_strdup(argv[i]);
276 + j->input = input ? g_strdup(input) : NULL;
277 + j->on_line = on_line;
278 + j->on_done = on_done;
279 + j->data = data;
280 + g_thread_unref(g_thread_new("pw-spawn", job_thread, j));
281 +}
282 +
283 +void
284 +pw_backend(const char *const args[], PwLineFunc on_line, PwDoneFunc on_done,
285 + gpointer data)
286 +{
287 + gsize n = 0;
288 + while (args[n])
289 + n++;
290 + char **argv = g_new0(char *, n + 2);
291 + argv[0] = g_strdup(pw_backend_path());
292 + for (gsize i = 0; i < n; i++)
293 + argv[i + 1] = g_strdup(args[i]);
294 + pw_spawn((const char *const *) argv, NULL, on_line, on_done, data);
295 + g_strfreev(argv);
296 +}
297 +
298 +/* ── Uprawnienia root ────────────────────────────────────────────────────── */
299 +gboolean
300 +pw_is_root(void)
301 +{
302 + return geteuid() == 0;
303 +}
304 +
305 +gboolean
306 +pw_have(const char *cmd)
307 +{
308 + if (!cmd || !*cmd)
309 + return FALSE;
310 + if (g_path_is_absolute(cmd))
311 + return g_file_test(cmd, G_FILE_TEST_IS_EXECUTABLE);
312 + char *found = g_find_program_in_path(cmd);
313 + gboolean ok = (found != NULL);
314 + g_free(found);
315 + return ok;
316 +}
317 +
318 +static gboolean
319 +polkit_agent_running(void)
320 +{
321 + /* Wynik zapamiętujemy – agent polkit nie pojawia się w trakcie sesji, a
322 + * pgrep w pętli spawnowałby kilka procesów przy każdej akcji. */
323 + static int cached = -1;
324 + if (cached >= 0)
325 + return cached == 1;
326 +
327 + static const char *names[] = {
328 + "polkit-gnome-authentication-agent-1", "xfce-polkit",
329 + "polkit-kde-authentication-agent-1", "mate-polkit",
330 + "lxpolkit", "polkit-mate-authentication-agent-1",
331 + };
332 + cached = 0;
333 + for (gsize i = 0; i < G_N_ELEMENTS(names); i++) {
334 + const char *argv[] = {"pgrep", "-x", names[i], NULL};
335 + char *out = pw_run_capture(argv);
336 + gboolean found = out && *out;
337 + g_free(out);
338 + if (found) {
339 + cached = 1;
340 + break;
341 + }
342 + }
343 + return cached == 1;
344 +}
345 +
346 +gboolean
347 +pw_privileged_needs_password(void)
348 +{
349 + if (pw_is_root())
350 + return FALSE;
351 + if (pw_have("pkexec") && polkit_agent_running())
352 + return FALSE;
353 + return TRUE;
354 +}
355 +
356 +char **
357 +pw_privileged_argv(const char *const cmd[])
358 +{
359 + GPtrArray *arr = g_ptr_array_new();
360 + if (pw_is_root()) {
361 + /* bez prefiksu */
362 + } else if (pw_have("pkexec") && polkit_agent_running()) {
363 + g_ptr_array_add(arr, g_strdup("pkexec"));
364 + } else if (pw_have("sudo")) {
365 + g_ptr_array_add(arr, g_strdup("sudo"));
366 + g_ptr_array_add(arr, g_strdup("-S"));
367 + }
368 + for (gsize i = 0; cmd[i]; i++)
369 + g_ptr_array_add(arr, g_strdup(cmd[i]));
370 + g_ptr_array_add(arr, NULL);
371 + return (char **) g_ptr_array_free(arr, FALSE);
372 +}
373 +
374 +/* ── Pomocnicze ──────────────────────────────────────────────────────────── */
375 +char *
376 +pw_run_capture(const char *const argv[])
377 +{
378 + char *out = NULL;
379 + GError *err = NULL;
380 + if (!g_spawn_sync(NULL, (char **) argv, NULL,
381 + G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL,
382 + &out, NULL, NULL, &err)) {
383 + g_clear_error(&err);
384 + return NULL;
385 + }
386 + if (out) {
387 + g_strstrip(out); /* modyfikuje w miejscu */
388 + return out;
389 + }
390 + return NULL;
391 +}
392 +
393 +gboolean
394 +pw_is_live(void)
395 +{
396 + char *cmdline = NULL;
397 + if (g_file_get_contents("/proc/cmdline", &cmdline, NULL, NULL)) {
398 + gboolean live = (strstr(cmdline, "pagan.live") != NULL);
399 + if (!live) {
400 + /* samotne "live" jako osobny parametr */
401 + char **parts = g_strsplit_set(cmdline, " \t\n", -1);
402 + for (gsize i = 0; parts[i]; i++) {
403 + if (g_strcmp0(parts[i], "live") == 0) {
404 + live = TRUE;
405 + break;
406 + }
407 + }
408 + g_strfreev(parts);
409 + }
410 + g_free(cmdline);
411 + if (live)
412 + return TRUE;
413 + }
414 + if (g_file_test("/run/live", G_FILE_TEST_IS_DIR) ||
415 + g_file_test("/lib/live/mount", G_FILE_TEST_IS_DIR) ||
416 + g_file_test("/live/root", G_FILE_TEST_IS_DIR))
417 + return TRUE;
418 + char *mounts = NULL;
419 + if (g_file_get_contents("/proc/mounts", &mounts, NULL, NULL)) {
420 + gboolean overlay = (strstr(mounts, " / overlay ") != NULL);
421 + g_free(mounts);
422 + if (overlay)
423 + return TRUE;
424 + }
425 + return FALSE;
426 +}
427 +
428 +/* Porównaj dwa segmenty wersji: liczbowo gdy oba liczbowe, inaczej tekstowo. */
429 +static int
430 +seg_cmp(const char *a, const char *b)
431 +{
432 + gboolean na = (*a != '\0');
433 + gboolean nb = (*b != '\0');
434 + for (const char *p = a; *p; p++)
435 + if (!g_ascii_isdigit(*p)) { na = FALSE; break; }
436 + for (const char *p = b; *p; p++)
437 + if (!g_ascii_isdigit(*p)) { nb = FALSE; break; }
438 + if (na && nb) {
439 + long va = strtol(a, NULL, 10);
440 + long vb = strtol(b, NULL, 10);
441 + return (va < vb) ? -1 : (va > vb) ? 1 : 0;
442 + }
443 + return g_strcmp0(a, b);
444 +}
445 +
446 +int
447 +pw_version_cmp(const char *a, const char *b)
448 +{
449 + char **sa = g_strsplit_set(a ? a : "", "._+~-", -1);
450 + char **sb = g_strsplit_set(b ? b : "", "._+~-", -1);
451 + int result = 0;
452 + for (gsize i = 0; sa[i] || sb[i]; i++) {
453 + const char *x = sa[i] ? sa[i] : "";
454 + const char *y = sb[i] ? sb[i] : "";
455 + int c = seg_cmp(x, y);
456 + if (c != 0) {
457 + result = c;
458 + break;
459 + }
460 + }
461 + g_strfreev(sa);
462 + g_strfreev(sb);
463 + return result;
464 +}
465 +
466 +char *
467 +pw_format_size(guint64 bytes)
468 +{
469 + static const char *units[] = {"B", "KB", "MB", "GB", "TB"};
470 + double v = (double) bytes;
471 + int u = 0;
472 + while (v >= 1024.0 && u < 4) {
473 + v /= 1024.0;
474 + u++;
475 + }
476 + if (u == 0)
477 + return g_strdup_printf("%" G_GUINT64_FORMAT " %s", bytes, units[u]);
478 + return g_strdup_printf("%.1f %s", v, units[u]);
479 +}
0 480 new file mode 100644
@@ -0,0 +1,50 @@
1 +/* pagan-welcome – konfiguracja, uruchamianie poleceń, wykrywanie środowiska. */
2 +#ifndef PW_UTIL_H
3 +#define PW_UTIL_H
4 +
5 +#include <glib.h>
6 +
7 +/* ── Konfiguracja użytkownika (~/.config/pagan-welcome/config.ini) ───────── */
8 +typedef struct {
9 + char *lang; /* "pl" / "en" */
10 + gboolean show_on_login; /* czy pokazywać okno przy logowaniu */
11 +} PwConfig;
12 +
13 +PwConfig *pw_config_load(void);
14 +void pw_config_save(const PwConfig *cfg);
15 +void pw_config_free(PwConfig *cfg);
16 +
17 +/* ── Backend (pagan-welcome-backend) ─────────────────────────────────────── */
18 +const char *pw_backend_path(void);
19 +/* Ścieżka do menedżera pakietów pag (/usr/bin/pag lub z PATH). */
20 +const char *pw_pag_path(void);
21 +
22 +/* ── Uruchamianie poleceń ────────────────────────────────────────────────── */
23 +typedef void (*PwLineFunc)(const char *line, gpointer data);
24 +typedef void (*PwDoneFunc)(int status, gpointer data);
25 +
26 +/* Uruchom polecenie asynchronicznie; `on_line` dla każdej linii wyjścia
27 + * (stdout+stderr scalone), `on_done` z kodem wyjścia. Oba callbacki wołane
28 + * w wątku głównym. `input` (jeśli nie NULL) trafia na stdin. */
29 +void pw_spawn(const char *const argv[], const char *input,
30 + PwLineFunc on_line, PwDoneFunc on_done, gpointer data);
31 +
32 +/* Uruchom backend z listą argumentów (zakończoną NULL). */
33 +void pw_backend(const char *const args[], PwLineFunc on_line,
34 + PwDoneFunc on_done, gpointer data);
35 +
36 +/* ── Uprawnienia root ────────────────────────────────────────────────────── */
37 +gboolean pw_is_root(void);
38 +/* TRUE, gdy trzeba podać hasło (używamy sudo -S zamiast pkexec). */
39 +gboolean pw_privileged_needs_password(void);
40 +/* Zbuduj argv z prefiksem uprawnień (do uwolnienia g_strfreev). */
41 +char **pw_privileged_argv(const char *const cmd[]);
42 +
43 +/* ── Pomocnicze ──────────────────────────────────────────────────────────── */
44 +gboolean pw_have(const char *cmd);
45 +char *pw_run_capture(const char *const argv[]);
46 +gboolean pw_is_live(void);
47 +int pw_version_cmp(const char *a, const char *b);
48 +char *pw_format_size(guint64 bytes);
49 +
50 +#endif /* PW_UTIL_H */