új telepítő

12 files changed, 3467 insertions, 0 deletions

diff --git a/raveos-center/raveos_center/oldalak/__init__.py b/raveos-center/raveos_center/oldalak/__init__.py
new file mode 100644
index 0000000..36a9048
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/__init__.py
@@ -0,0 +1,2 @@
+FENT = ["attekintes", "alkalmazasok", "frissitesek", "rendszer", "visszajelzes"]
+LENT = []
diff --git a/raveos-center/raveos_center/oldalak/alkalmazasok.py b/raveos-center/raveos_center/oldalak/alkalmazasok.py
new file mode 100644
index 0000000..4ab95e6
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/alkalmazasok.py
@@ -0,0 +1,508 @@
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QFrame,
+    QHBoxLayout,
+    QLineEdit,
+    QMessageBox,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from raveos_center import katalogus
+from raveos_center.elemek import Kartya, Oldal, cimke, frissit_stilus, gomb
+from raveos_center.folyamat import FolyamatAblak
+from raveos_center.hatter import gyorsitott
+
+AZON = "alkalmazasok"
+MENU = "Alkalmazások"
+IKON = "alkalmazasok"
+
+CSAK_TELEPITETT = "telepitett"
+
+
+class KattinthatoSor(QWidget):
+    def __init__(self, jelolo):
+        super().__init__()
+        self.jelolo = jelolo
+        self.setCursor(Qt.CursorShape.PointingHandCursor)
+
+    def mouseReleaseEvent(self, esemeny):
+        if esemeny.button() == Qt.MouseButton.LeftButton and self.rect().contains(esemeny.position().toPoint()):
+            self.jelolo.toggle()
+        super().mouseReleaseEvent(esemeny)
+
+
+class AppSor(QWidget):
+    def __init__(self, app, oldal):
+        super().__init__()
+        self.app = app
+        self.oldal = oldal
+        self.telepitve = False
+        self.setObjectName("appsor")
+        self.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(16, 12, 16, 12)
+        doboz.setSpacing(8)
+
+        felso = QHBoxLayout()
+        felso.setSpacing(14)
+        self.jelolo = QCheckBox()
+        self.jelolo.setVisible(app["type"] != "message")
+        self.jelolo.toggled.connect(self._sor_jelolve)
+        felso.addWidget(self.jelolo)
+        betu = cimke(app["name"][:1].upper(), "kezdobetu")
+        betu.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        betu.setFixedSize(36, 36)
+        felso.addWidget(betu)
+        szovegek = QVBoxLayout()
+        szovegek.setSpacing(2)
+        nevsor = QHBoxLayout()
+        nevsor.setSpacing(10)
+        nev = cimke(app["name"])
+        nev.setStyleSheet("font-size: 14px; font-weight: 600;")
+        nevsor.addWidget(nev)
+        nevsor.addWidget(cimke(katalogus.forras(app), "monohalvany"))
+        self.allapot = cimke("TELEPÍTVE", "allapotcimke")
+        self.allapot.setProperty("szin", "zold")
+        self.allapot.hide()
+        nevsor.addWidget(self.allapot)
+        nevsor.addStretch(1)
+        szovegek.addLayout(nevsor)
+        leiras = katalogus.loc(app.get("desc"))
+        self.leiras = cimke(leiras, "halvany")
+        self.leiras.setToolTip(leiras)
+        self.leiras.setMinimumWidth(80)
+        szovegek.addWidget(self.leiras)
+        felso.addLayout(szovegek, 1)
+
+        self.eltavolit_gomb = None
+        if app["type"] == "choice":
+            self.eltavolit_gomb = gomb("Eltávolítás", kicsi=True)
+            self.eltavolit_gomb.clicked.connect(lambda: self._opcio_muvelet(False))
+            felso.addWidget(self.eltavolit_gomb)
+        self.gomb = gomb("", kicsi=True)
+        self.gomb.setMinimumWidth(110)
+        self.gomb.clicked.connect(self._kattint)
+        felso.addWidget(self.gomb)
+        doboz.addLayout(felso)
+
+        self.opciok = []
+        if app["type"] == "choice":
+            self._opcio_lista(doboz)
+        elif app["type"] != "message":
+            self.setCursor(Qt.CursorShape.PointingHandCursor)
+        self.frissit(oldal.index)
+
+    def mouseReleaseEvent(self, esemeny):
+        if (
+            esemeny.button() == Qt.MouseButton.LeftButton
+            and self.app["type"] not in ("choice", "message")
+            and self.rect().contains(esemeny.position().toPoint())
+        ):
+            self.jelolo.toggle()
+        super().mouseReleaseEvent(esemeny)
+
+    def resizeEvent(self, esemeny):
+        super().resizeEvent(esemeny)
+        teljes = self.leiras.toolTip()
+        self.leiras.setText(
+            self.leiras.fontMetrics().elidedText(teljes, Qt.TextElideMode.ElideRight, max(80, self.leiras.width()))
+        )
+
+    def _opcio_lista(self, doboz):
+        lista = QVBoxLayout()
+        lista.setContentsMargins(82, 4, 0, 0)
+        lista.setSpacing(6)
+        fej = QHBoxLayout()
+        fej.addWidget(cimke("VÁLASSZ, AKÁR TÖBBET IS", "monohalvany"))
+        fej.addStretch(1)
+        mind = gomb("Mind kijelölése", kicsi=True)
+        mind.clicked.connect(self._mind)
+        fej.addWidget(mind)
+        lista.addLayout(fej)
+        for o in self.app.get("options", []):
+            jelolo = QCheckBox(o["name"])
+            jelolo.setMinimumWidth(130)
+            jelolo.toggled.connect(lambda _: self._gombok_opcio())
+            kontener = KattinthatoSor(jelolo)
+            sor = QHBoxLayout(kontener)
+            sor.setContentsMargins(0, 2, 0, 2)
+            sor.setSpacing(10)
+            sor.addWidget(jelolo)
+            leiras = cimke(katalogus.loc(o.get("desc")), "halvany")
+            sor.addWidget(leiras, 1)
+            allapot = cimke("TELEPÍTVE", "allapotcimke")
+            allapot.setProperty("szin", "zold")
+            sor.addWidget(allapot)
+            lista.addWidget(kontener)
+            self.opciok.append((jelolo, allapot, o))
+        doboz.addLayout(lista)
+
+    def _mind(self):
+        mind = all(j.isChecked() for j, _, _ in self.opciok)
+        for j, _, _ in self.opciok:
+            j.setChecked(not mind)
+
+    def _sor_jelolve(self, jelolve):
+        if self.opciok:
+            for j, _, _ in self.opciok:
+                j.blockSignals(True)
+                j.setChecked(jelolve)
+                j.blockSignals(False)
+            self._gombok_opcio()
+        self.oldal.kijeles_valtozott()
+
+    def torol_kijeles(self):
+        self.jelolo.setChecked(False)
+
+    def telepitendo(self):
+        if self.app["type"] == "choice":
+            opciok = self._kijelolt(False)
+            return (self.app, opciok) if opciok else None
+        if self.jelolo.isChecked() and not self.telepitve and self.app["type"] != "message":
+            return (self.app, None)
+        return None
+
+    def eltavolitando(self):
+        if self.app["type"] == "choice":
+            opciok = self._kijelolt(True)
+            return (self.app, opciok) if opciok else None
+        if self.jelolo.isChecked() and self.telepitve and katalogus.eltavolithato(self.app):
+            return (self.app, None)
+        return None
+
+    def _kijelolt(self, telepitett):
+        return [
+            o["id"]
+            for j, _, o in self.opciok
+            if j.isChecked() and katalogus.opcio_telepitve(o, self.oldal.index) == telepitett
+        ]
+
+    def _gombok_opcio(self):
+        uj = self._kijelolt(False)
+        regi = self._kijelolt(True)
+        self.jelolo.blockSignals(True)
+        self.jelolo.setChecked(any(j.isChecked() for j, _, _ in self.opciok))
+        self.jelolo.blockSignals(False)
+        self.oldal.kijeles_valtozott()
+        self.gomb.setText(f"Telepítés ({len(uj)})" if uj else "Telepítés")
+        self.gomb.setEnabled(bool(uj))
+        self.gomb.setProperty("fo", True)
+        frissit_stilus(self.gomb)
+        self.eltavolit_gomb.setText(f"Eltávolítás ({len(regi)})" if regi else "Eltávolítás")
+        self.eltavolit_gomb.setEnabled(bool(regi))
+
+    def _opcio_muvelet(self, telepites):
+        kijelolt = self._kijelolt(not telepites)
+        if kijelolt:
+            self.oldal.muvelet(self.app, telepites, kijelolt)
+
+    def frissit(self, index):
+        if self.app["type"] == "choice":
+            db = 0
+            for _, allapot, o in self.opciok:
+                fent = katalogus.opcio_telepitve(o, index)
+                allapot.setVisible(fent)
+                db += fent
+            self.telepitve = db > 0
+            self.allapot.setText(f"{db} / {len(self.opciok)} TELEPÍTVE")
+            self.allapot.setVisible(db > 0)
+            self._gombok_opcio()
+            return
+        if self.app["type"] == "message":
+            self.gomb.setText("Tudnivalók")
+            self.gomb.setProperty("fo", False)
+        else:
+            self.telepitve = katalogus.telepitve(self.app, index)
+            self.allapot.setVisible(self.telepitve)
+            if self.telepitve:
+                self.gomb.setText("Eltávolítás")
+                self.gomb.setEnabled(katalogus.eltavolithato(self.app))
+                self.gomb.setProperty("fo", False)
+            else:
+                self.gomb.setText("Telepítés")
+                self.gomb.setEnabled(True)
+                self.gomb.setProperty("fo", True)
+        frissit_stilus(self.gomb)
+
+    def _kattint(self):
+        if self.app["type"] == "message":
+            QMessageBox.information(self, self.app["name"], katalogus.loc(self.app.get("message")))
+            return
+        if self.app["type"] == "choice":
+            self._opcio_muvelet(True)
+            return
+        self.oldal.muvelet(self.app, not self.telepitve)
+
+
+class Csoport(QWidget):
+    def __init__(self, nev):
+        super().__init__()
+        self.nev = nev
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 0, 0, 0)
+        doboz.setSpacing(10)
+        self.fejlec = cimke("", "h2")
+        doboz.addWidget(self.fejlec)
+        self.lista = Kartya(terkoz=0, margo=0)
+        doboz.addWidget(self.lista)
+        self.sorok = []
+
+    def hozzaad(self, sor):
+        self.sorok.append(sor)
+        self.lista.elrendezes.addWidget(sor)
+
+    def szur(self, lathatok):
+        db = 0
+        utolso = None
+        for sor in self.sorok:
+            lathato = sor in lathatok
+            sor.setVisible(lathato)
+            sor.setProperty("utolso", False)
+            if lathato:
+                db += 1
+                utolso = sor
+        if utolso:
+            utolso.setProperty("utolso", True)
+        for sor in self.sorok:
+            frissit_stilus(sor)
+        self.fejlec.setText(f"{self.nev.upper()} · {db}")
+        self.setVisible(db > 0)
+        return db
+
+
+class Alkalmazasok(Oldal):
+    def __init__(self, kozpont):
+        super().__init__(kozpont, "PACMAN · AUR · FLATPAK", "Alkalmazások")
+        self.katalogus = []
+        self.index = {"pacman": set(), "flatpak": set()}
+        self.sorok = []
+        self.csoportok = {}
+        self.kategoria = "all"
+
+        self.kereso = QLineEdit()
+        self.kereso.setPlaceholderText("Keresés, pl. Steam, OBS, Discord")
+        self.kereso.setClearButtonEnabled(True)
+        self.kereso.setMinimumWidth(220)
+        self.kereso.setMaximumWidth(340)
+        self.kereso.textChanged.connect(self._szur)
+        self.fejlec_gomb(self.kereso)
+
+        pillek = QHBoxLayout()
+        pillek.setSpacing(8)
+        self.pillek = {}
+        for azon, nev in katalogus.KATEGORIAK + [(CSAK_TELEPITETT, "Csak telepítettek")]:
+            p = QPushButton(nev)
+            p.setObjectName("pill")
+            p.setCursor(Qt.CursorShape.PointingHandCursor)
+            p.clicked.connect(lambda _=False, a=azon: self._kategoria(a))
+            self.pillek[azon] = p
+            if azon == CSAK_TELEPITETT:
+                pillek.addStretch(1)
+            pillek.addWidget(p)
+        self.torzs.addLayout(pillek)
+
+        self.kiemelt = Kartya(terkoz=8, margo=24)
+        self.kiemelt.setObjectName("kiemelt")
+        ks = QHBoxLayout()
+        ks.setSpacing(24)
+        kszoveg = QVBoxLayout()
+        kszoveg.setSpacing(6)
+        kszoveg.addWidget(cimke("CSOMAG · GAMING ALAPOK", "eyebrow"))
+        kszoveg.addWidget(cimke("EGY KATTINTÁS, MINDEN AMI JÁTÉKHOZ KELL", "h2", True))
+        kszoveg.addWidget(
+            cimke("Steam (Proton-GE-vel), Lutris, Heroic, GameMode és MangoHud egyben, előre beállítva.", "masodlagos", True)
+        )
+        ks.addLayout(kszoveg, 1)
+        self.kiemelt_gomb = gomb("Csomag telepítése", fo=True)
+        self.kiemelt_gomb.clicked.connect(self._gaming_alapok)
+        ks.addWidget(self.kiemelt_gomb, 0, Qt.AlignmentFlag.AlignVCenter)
+        self.kiemelt.elrendezes.addLayout(ks)
+        self.torzs.addWidget(self.kiemelt)
+
+        self.hiba = cimke("", "figyelem", True)
+        self.hiba.hide()
+        self.torzs.addWidget(self.hiba)
+        self._kijeles_sav()
+        self.lista = QVBoxLayout()
+        self.lista.setSpacing(28)
+        self.torzs.addLayout(self.lista)
+        self.ures = cimke("Nincs találat.", "halvany")
+        self.ures.hide()
+        self.torzs.addWidget(self.ures)
+        self.torzs.addStretch(1)
+        self._betolt()
+        self._kategoria("all")
+
+    def _kijeles_sav(self):
+        self.sav = QFrame(self)
+        self.sav.setObjectName("kijelessav")
+        s = QHBoxLayout(self.sav)
+        s.setContentsMargins(48, 12, 48, 12)
+        s.setSpacing(8)
+        self.sav_szoveg = cimke("", "mono")
+        s.addWidget(self.sav_szoveg)
+        s.addStretch(1)
+        torles = gomb("Kijelölés törlése", kicsi=True)
+        torles.clicked.connect(self._kijeles_torles)
+        s.addWidget(torles)
+        self.sav_eltavolit = gomb("Kijelöltek eltávolítása")
+        self.sav_eltavolit.clicked.connect(lambda: self._tomeges(False))
+        s.addWidget(self.sav_eltavolit)
+        self.sav_telepit = gomb("Kijelöltek telepítése", fo=True)
+        self.sav_telepit.clicked.connect(lambda: self._tomeges(True))
+        s.addWidget(self.sav_telepit)
+        self.sav.hide()
+
+    def resizeEvent(self, esemeny):
+        super().resizeEvent(esemeny)
+        magassag = self.sav.sizeHint().height()
+        self.sav.setGeometry(0, self.height() - magassag, self.width(), magassag)
+
+    def kijeles_valtozott(self):
+        if not hasattr(self, "sav"):
+            return
+        uj = [x for x in (s.telepitendo() for s in self.sorok) if x]
+        regi = [x for x in (s.eltavolitando() for s in self.sorok) if x]
+        kijelolt = sum(1 for s in self.sorok if s.jelolo.isChecked())
+        latszik = kijelolt > 0
+        self.sav.setVisible(latszik)
+        self.setViewportMargins(0, 0, 0, self.sav.sizeHint().height() if latszik else 0)
+        self.sav_szoveg.setText(f"{kijelolt} KIJELÖLVE")
+        self.sav_telepit.setText(f"Kijelöltek telepítése ({len(uj)})")
+        self.sav_telepit.setEnabled(bool(uj))
+        self.sav_eltavolit.setText(f"Kijelöltek eltávolítása ({len(regi)})")
+        self.sav_eltavolit.setEnabled(bool(regi))
+        if latszik:
+            self.sav.raise_()
+            magassag = self.sav.sizeHint().height()
+            self.sav.setGeometry(0, self.height() - magassag, self.width(), magassag)
+
+    def _kijeles_torles(self):
+        for s in self.sorok:
+            s.torol_kijeles()
+
+    def _nev(self, app, opciok):
+        if opciok:
+            return ", ".join(f"{app['name']}: {o['name']}" for o in app.get("options", []) if o["id"] in opciok)
+        return app["name"]
+
+    def _tomeges(self, telepites):
+        tetelek = [x for x in ((s.telepitendo() if telepites else s.eltavolitando()) for s in self.sorok) if x]
+        if not tetelek:
+            return
+        nevek = [self._nev(app, opciok) for app, opciok in tetelek]
+        if not telepites:
+            valasz = QMessageBox.question(
+                self,
+                "Eltávolítás",
+                "Biztosan eltávolítod ezeket?\n\n" + "\n".join(nevek),
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                QMessageBox.StandardButton.No,
+            )
+            if valasz != QMessageBox.StandardButton.Yes:
+                return
+        lepesek = []
+        for app, opciok in tetelek:
+            for lepes in katalogus.lepesek(app, telepites, opciok):
+                lepes.kotelezo = False
+                lepesek.append(lepes)
+        if not lepesek:
+            return
+        cim = f"{'Telepítés' if telepites else 'Eltávolítás'}: {len(tetelek)} alkalmazás"
+        FolyamatAblak(self, cim, lepesek, "Minden lépés sikeresen lefutott.", "Nem minden lépés sikerült.").exec()
+        self._kijeles_torles()
+        self.megjelenik()
+
+    def _betolt(self):
+        try:
+            self.katalogus = katalogus.betolt()
+        except (OSError, ValueError, RuntimeError) as e:
+            self.hiba.setText(f"Az alkalmazáskatalógus nem tölthető be: {e}")
+            self.hiba.show()
+            return
+        for azon, nev in katalogus.KATEGORIAK[1:]:
+            csoport = Csoport(nev)
+            self.csoportok[azon] = csoport
+            self.lista.addWidget(csoport)
+        for app in self.katalogus:
+            csoport = self.csoportok.get(app["category"]) or self.csoportok["System"]
+            sor = AppSor(app, self)
+            self.sorok.append(sor)
+            csoport.hozzaad(sor)
+
+    def megjelenik(self, *_):
+        gyorsitott("telepitett", katalogus.telepitett_index, kesz=self._index_kesz, kor=30)
+
+    def _index_kesz(self, index):
+        if index == self.index:
+            return
+        self.index = index
+        for s in self.sorok:
+            s.frissit(index)
+        alap = [a for a in self.katalogus if a["id"] in katalogus.GAMING_ALAPOK]
+        hianyzik = [a for a in alap if not katalogus.telepitve(a, index)]
+        self.kiemelt_gomb.setEnabled(bool(hianyzik))
+        self.kiemelt_gomb.setText("Csomag telepítése" if hianyzik else "Minden telepítve")
+        self._szur()
+
+    def _kategoria(self, azon):
+        self.kategoria = azon
+        for a, p in self.pillek.items():
+            p.setProperty("aktiv", a == azon)
+            frissit_stilus(p)
+        self._szur()
+
+    def _szur(self):
+        szoveg = self.kereso.text().strip().lower()
+        lathatok = set()
+        for s in self.sorok:
+            app = s.app
+            if self.kategoria == CSAK_TELEPITETT:
+                jo = s.telepitve
+            else:
+                jo = self.kategoria == "all" or app["category"] == self.kategoria
+            if jo and (not szoveg or szoveg in app["name"].lower() or szoveg in katalogus.loc(app.get("desc")).lower()):
+                lathatok.add(s)
+        osszes = sum(c.szur(lathatok) for c in self.csoportok.values())
+        self.ures.setText(
+            "Még nincs telepítve egyetlen alkalmazás sem a listából."
+            if self.kategoria == CSAK_TELEPITETT and not szoveg
+            else "Nincs találat."
+        )
+        self.ures.setVisible(osszes == 0)
+        self.kiemelt.setVisible(self.kategoria in ("all", "Games") and not szoveg)
+
+    def muvelet(self, app, telepites, opciok=None):
+        if not telepites:
+            nevek = ", ".join(o["name"] for o in app.get("options", []) if o["id"] in (opciok or [])) or app["name"]
+            valasz = QMessageBox.question(
+                self,
+                "Eltávolítás",
+                f"Biztosan eltávolítod: {nevek}?",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                QMessageBox.StandardButton.No,
+            )
+            if valasz != QMessageBox.StandardButton.Yes:
+                return
+        lepesek = katalogus.lepesek(app, telepites, opciok)
+        if not lepesek:
+            return
+        cim = f"{'Telepítés' if telepites else 'Eltávolítás'}: {app['name']}"
+        FolyamatAblak(self, cim, lepesek, f"{app['name']} {'telepítve' if telepites else 'eltávolítva'}.").exec()
+        self.megjelenik()
+
+    def _gaming_alapok(self):
+        lepesek = []
+        for app in self.katalogus:
+            if app["id"] in katalogus.GAMING_ALAPOK and not katalogus.telepitve(app, self.index):
+                lepesek += katalogus.lepesek(app, True)
+        if not lepesek:
+            return
+        FolyamatAblak(self, "Gaming alapok telepítése", lepesek, "A Gaming alapok telepítve.").exec()
+        self.megjelenik()
+
+
+OLDAL = Alkalmazasok
diff --git a/raveos-center/raveos_center/oldalak/attekintes.py b/raveos-center/raveos_center/oldalak/attekintes.py
new file mode 100644
index 0000000..9ebc848
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/attekintes.py
@@ -0,0 +1,262 @@
+from datetime import datetime
+
+from PyQt6.QtCore import Qt, QUrl
+from PyQt6.QtGui import QDesktopServices
+from PyQt6.QtWidgets import QHBoxLayout, QMessageBox, QProgressBar, QPushButton, QVBoxLayout, QWidget
+
+from raveos_center import gaming, muveletek, rendszerinfo
+from raveos_center.elemek import Kartya, Oldal, Racs, cimke, frissit_stilus, gomb
+from raveos_center.hatter import ervenytelenit, gyorsitott, tarolt
+
+AZON = "attekintes"
+MENU = "Áttekintés"
+IKON = "attekintes"
+
+GYORS = [
+    ("01", "Alkalmazás telepítése", "Böngészés kategóriák szerint", "alkalmazasok", ()),
+    ("02", "Rendszerfrissítés", "pacman + AUR + Flatpak", "frissitesek", ()),
+    ("03", "Driverek", "GPU, Wi-Fi, kontrollerek", "rendszer", ("driverek",)),
+    ("04", "Takarítás", "Cache, árva csomagok", "rendszer", ("karbantartas",)),
+    ("05", "Gaming tweakek", "GameMode, Proton, MangoHud", "rendszer", ("gaming",)),
+    ("06", "Visszaállítás", "Snapshot betöltése", "rendszer", ("snapshotok",)),
+]
+
+KOZOSSEG = [
+    ("rp1.hu", "https://rp1.hu"),
+    ("Discord", "https://discord.gg/gSdVMXRFQc"),
+    ("Stream", "https://kick.com/rpslair"),
+]
+
+
+class Csempe(QPushButton):
+    def __init__(self, kod, cim, alcim):
+        super().__init__()
+        self.setObjectName("csempe")
+        self.setCursor(Qt.CursorShape.PointingHandCursor)
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(18, 18, 18, 18)
+        doboz.setSpacing(4)
+        self.kod = cimke(kod, "monozold")
+        doboz.addWidget(self.kod)
+        doboz.addStretch(1)
+        self.cim = cimke(cim)
+        self.cim.setStyleSheet("font-size: 15px; font-weight: 600;")
+        doboz.addWidget(self.cim)
+        self.alcim = cimke(alcim, "halvany", True)
+        doboz.addWidget(self.alcim)
+        for c in (self.kod, self.cim, self.alcim):
+            c.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+
+
+def allapotkartya(cim):
+    kartya = Kartya(cim)
+    ertek = cimke("...", "nagyszam")
+    kartya.elrendezes.addWidget(ertek)
+    return kartya, ertek
+
+
+class Attekintes(Oldal):
+    def __init__(self, kozpont):
+        super().__init__(kozpont, "ÜDV ÚJRA", "Áttekintés")
+        self.frissites_gomb = self.fejlec_gomb(gomb("Frissítés most", fo=True))
+        self.frissites_gomb.clicked.connect(lambda: self.kozpont.mutat("frissitesek"))
+        self.snapshot_gomb = self.fejlec_gomb(gomb("Snapshot készítése"))
+        self.snapshot_gomb.clicked.connect(lambda: self.kozpont.mutat("rendszer", "snapshotok", "uj"))
+
+        allapot = Racs(220)
+        k, self.frissites_szam = allapotkartya("Frissítések")
+        self.frissites_szam.setProperty("zold", True)
+        self.frissites_reszlet = cimke("ellenőrzés...", "masodlagos")
+        k.elrendezes.addWidget(self.frissites_reszlet)
+        allapot.hozzaad(k)
+
+        k, self.snapshot_ertek = allapotkartya("Utolsó snapshot")
+        self.snapshot_reszlet = cimke("", "masodlagos")
+        k.elrendezes.addWidget(self.snapshot_reszlet)
+        allapot.hozzaad(k)
+
+        k, self.lemez_ertek = allapotkartya("Lemez")
+        self.lemez_sav = QProgressBar()
+        self.lemez_sav.setObjectName("sav")
+        self.lemez_sav.setTextVisible(False)
+        self.lemez_sav.setFixedHeight(6)
+        k.elrendezes.addWidget(self.lemez_sav)
+        allapot.hozzaad(k)
+
+        k, self.gaming_ertek = allapotkartya("Gaming mód")
+        self.gaming_adat = None
+        self.gaming_gomb = gomb("...", kicsi=True)
+        self.gaming_gomb.clicked.connect(self._gaming_valt)
+        k.elrendezes.addWidget(self.gaming_gomb, 0, Qt.AlignmentFlag.AlignLeft)
+        allapot.hozzaad(k)
+        self.torzs.addWidget(allapot)
+
+        also = QHBoxLayout()
+        also.setSpacing(24)
+        bal = QVBoxLayout()
+        bal.setSpacing(16)
+        bal.addWidget(cimke("GYORS MŰVELETEK", "h2"))
+        self.gyors = Racs(180, 12)
+        self.csempek = []
+        for kod, cim, alcim, cel, al in GYORS:
+            csempe = Csempe(kod, cim, alcim)
+            csempe.clicked.connect(lambda _=False, c=cel, a=al: self.kozpont.mutat(c, *a))
+            self.csempek.append((csempe, cel, al))
+            self.gyors.hozzaad(csempe)
+        bal.addWidget(self.gyors)
+        bal.addStretch(1)
+        also.addLayout(bal, 2)
+
+        jobb = QVBoxLayout()
+        jobb.setSpacing(16)
+        jobb.addWidget(cimke("RENDSZER", "h2"))
+        self.info = Kartya(terkoz=0, margo=20)
+        self.info.elrendezes.setContentsMargins(20, 8, 20, 8)
+        self.info_sorok = {}
+        for kulcs in ("Kernel", "Asztal", "CPU", "GPU", "Memória", "Fájlrendszer", "Uptime"):
+            sor = QWidget()
+            sl = QHBoxLayout(sor)
+            sl.setContentsMargins(0, 12, 0, 12)
+            sl.addWidget(cimke(kulcs, "monohalvany"))
+            sl.addStretch(1)
+            ertek = cimke("...", "mono")
+            ertek.setAlignment(Qt.AlignmentFlag.AlignRight)
+            ertek.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+            sl.addWidget(ertek)
+            self.info_sorok[kulcs] = ertek
+            self.info.elrendezes.addWidget(sor)
+        jobb.addWidget(self.info)
+
+        kozosseg = Kartya("Közösség", terkoz=12)
+        nev = cimke("RaveCore")
+        nev.setStyleSheet("font-size: 15px; font-weight: 600;")
+        kozosseg.elrendezes.addWidget(nev)
+        kozosseg.elrendezes.addWidget(
+            cimke("Kérdésed van, vagy hibát találtál? Gyere a közösségbe, vagy írj nekünk hibajegyet.", "masodlagos", True)
+        )
+        linkek = QHBoxLayout()
+        linkek.setSpacing(16)
+        for szoveg, cim in KOZOSSEG:
+            link = cimke(f'<a href="{cim}" style="color:#62a052; text-decoration:none">{szoveg}</a>', "link")
+            link.setOpenExternalLinks(True)
+            linkek.addWidget(link)
+        self.hibajegy_link = cimke('<a href="#" style="color:#62a052; text-decoration:none">Hibajegy</a>', "link")
+        self.hibajegy_link.linkActivated.connect(lambda _: self.kozpont.mutat("visszajelzes"))
+        linkek.addWidget(self.hibajegy_link)
+        linkek.addStretch(1)
+        kozosseg.elrendezes.addLayout(linkek)
+        jobb.addWidget(kozosseg)
+        jobb.addStretch(1)
+        also.addLayout(jobb, 1)
+        self.torzs.addLayout(also)
+        self.torzs.addStretch(1)
+
+    def megjelenik(self, *_):
+        self.frissites_gomb.setEnabled(self.kozpont.van("frissitesek"))
+        self.snapshot_gomb.setEnabled(self.kozpont.van("rendszer", "snapshotok"))
+        if tarolt("gaming") is None:
+            self.gaming_gomb.setEnabled(False)
+        gyorsitott("gaming", gaming.allapot, kesz=self._gaming_kesz, kor=30)
+        for csempe, cel, al in self.csempek:
+            elerheto = self.kozpont.van(cel, *al)
+            csempe.setEnabled(elerheto)
+            csempe.setToolTip("" if elerheto else "Hamarosan")
+        self._lemez()
+        gyorsitott("info", self._info_gyujt, kesz=self._info_kesz, kor=300)
+        gyorsitott("frissitesek", rendszerinfo.frissitesek, kesz=self._frissites_kesz, hiba=self._frissites_hiba, kor=60)
+        gyorsitott("snapshot", rendszerinfo.utolso_snapshot, kesz=self._snapshot_kesz, kor=60)
+
+    def _gaming_kesz(self, adat):
+        self.gaming_adat = adat
+        aktiv = gaming.gaming_mod_aktiv(adat)
+        self.gaming_ertek.setText("BEKAPCSOLVA" if aktiv else "KIKAPCSOLVA")
+        self.gaming_ertek.setProperty("zold", aktiv)
+        frissit_stilus(self.gaming_ertek)
+        self.gaming_gomb.setText("Kikapcsolás" if aktiv else "Bekapcsolás")
+        self.gaming_gomb.setProperty("fo", not aktiv)
+        frissit_stilus(self.gaming_gomb)
+        valtozas = gaming.gaming_mod_valtozasok(adat, not aktiv)
+        self.gaming_gomb.setEnabled(bool(valtozas) and muveletek.helper_elerheto())
+        self.gaming_gomb.setToolTip(
+            "" if valtozas else "Ezen a gépen a Gaming mód elemei nem kapcsolhatók ki, a GameMode a Rendszer > Gaming fülön távolítható el."
+        )
+
+    def _gaming_valt(self):
+        if not self.gaming_adat:
+            return
+        from raveos_center.oldalak.rendszer.gaming import alkalmaz
+
+        self.gaming_gomb.setEnabled(False)
+        aktiv = gaming.gaming_mod_aktiv(self.gaming_adat)
+        hiba = alkalmaz(self, gaming.gaming_mod_valtozasok(self.gaming_adat, not aktiv))
+        if hiba:
+            QMessageBox.warning(self, "Gaming mód", hiba)
+        ervenytelenit("gaming")
+        gyorsitott("gaming", gaming.allapot, kesz=self._gaming_kesz)
+
+    def _lemez(self):
+        hasznalt, ossz = rendszerinfo.lemez()
+        self.lemez_ertek.setText(f"{hasznalt / 1e9:.0f} / {ossz / 1e9:.0f} GB")
+        self.lemez_sav.setValue(int(hasznalt * 100 / ossz) if ossz else 0)
+
+    @staticmethod
+    def _info_gyujt():
+        gpu = ", ".join(rendszerinfo.gpuk()) or "ismeretlen"
+        driver = ", ".join(rendszerinfo.gpu_driverek())
+        return {
+            "Kernel": rendszerinfo.kernel(),
+            "Asztal": rendszerinfo.asztal(),
+            "CPU": rendszerinfo.cpu(),
+            "GPU": f"{gpu} · {driver}" if driver else gpu,
+            "Memória": rendszerinfo.memoria(),
+            "Fájlrendszer": rendszerinfo.fajlrendszer(),
+            "Uptime": rendszerinfo.uzemido(),
+        }
+
+    def _info_kesz(self, adat):
+        for kulcs, ertek in adat.items():
+            self.info_sorok[kulcs].setText(ertek)
+
+    def _frissites_kesz(self, csomagok):
+        szam = len(csomagok)
+        self.kozpont.jelveny("frissitesek", szam)
+        if not szam:
+            self.frissites_szam.setText("NAPRAKÉSZ")
+            self.frissites_reszlet.setText("nincs elérhető frissítés")
+            return
+        self.frissites_szam.setText(f"{szam} ELÉRHETŐ")
+        reszek = []
+        ujrainditos = sum(1 for c in csomagok if c["ujrainditas"])
+        aur = sum(1 for c in csomagok if c["forras"] == "aur")
+        flatpak = sum(1 for c in csomagok if c["forras"] == "flatpak")
+        if ujrainditos:
+            reszek.append(f"{ujrainditos} újraindítást igényel")
+        if aur:
+            reszek.append(f"{aur} AUR")
+        if flatpak:
+            reszek.append(f"{flatpak} Flatpak")
+        self.frissites_reszlet.setText(" · ".join(reszek) or "csak hivatalos csomagok")
+
+    def _frissites_hiba(self, _):
+        self.frissites_szam.setText("-")
+        self.frissites_reszlet.setText("az ellenőrzés nem sikerült")
+
+    def _snapshot_kesz(self, snapshot):
+        if snapshot is None:
+            self.snapshot_ertek.setText("-")
+            self.snapshot_reszlet.setText("a snapper nem érhető el")
+            return
+        if not snapshot:
+            self.snapshot_ertek.setText("NINCS")
+            self.snapshot_reszlet.setText("még nem készült snapshot")
+            return
+        try:
+            ido = datetime.fromisoformat(snapshot.get("date", ""))
+            nap = (datetime.now() - ido).days
+            self.snapshot_ertek.setText("MA" if nap == 0 else f"{nap} NAPJA")
+        except (TypeError, ValueError):
+            self.snapshot_ertek.setText("?")
+        self.snapshot_reszlet.setText(f"btrfs · {snapshot.get('description') or snapshot.get('type', '')}")
+
+
+OLDAL = Attekintes
diff --git a/raveos-center/raveos_center/oldalak/frissitesek.py b/raveos-center/raveos_center/oldalak/frissitesek.py
new file mode 100644
index 0000000..baa1ccc
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/frissitesek.py
@@ -0,0 +1,331 @@
+from datetime import datetime
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import (
+    QAbstractItemView,
+    QCheckBox,
+    QHBoxLayout,
+    QHeaderView,
+    QPlainTextEdit,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from raveos_center import muveletek, rendszerinfo, snapshotok
+from raveos_center.elemek import Kartya, Oldal, Racs, cimke, gomb
+from raveos_center.hatter import ervenytelenit, hatterben
+
+AZON = "frissitesek"
+MENU = "Frissítések"
+IKON = "frissitesek"
+
+FORRAS = {"pacman": "pacman", "aur": "AUR", "flatpak": "Flatpak"}
+
+
+def mb(meret):
+    if meret is None:
+        return "-"
+    return f"{meret / 1e6:.1f} MB"
+
+
+class Frissitesek(Oldal):
+    def __init__(self, kozpont):
+        super().__init__(kozpont, "UTOLSÓ ELLENŐRZÉS: -", "Frissítések", kitolt=True)
+        self.csomagok = []
+        self.ujrainditas_kell = False
+        self.futtato = muveletek.Futtato(self)
+        self.futtato.sor.connect(self._naplo)
+        self.futtato.kesz.connect(self._futas_kesz)
+
+        self.torzs.setSpacing(20)
+        self.ellenorzes = self.fejlec_gomb(gomb("Ellenőrzés"))
+        self.ellenorzes.clicked.connect(lambda: self._ellenoriz(True))
+        self.inditas = self.fejlec_gomb(gomb("Nincs kijelölve", fo=True))
+        self.inditas.clicked.connect(self._indit)
+
+        osszegzes = Racs(220)
+        k = Kartya("Kijelölve")
+        self.kijelolt = cimke("0 / 0 CSOMAG", "nagyszam")
+        k.elrendezes.addWidget(self.kijelolt)
+        osszegzes.hozzaad(k)
+        k = Kartya("Letöltés")
+        self.letoltes = cimke("0 MB", "nagyszam")
+        k.elrendezes.addWidget(self.letoltes)
+        osszegzes.hozzaad(k)
+        k = Kartya("Biztonság")
+        self.snapshot = QCheckBox("Snapshot készítése frissítés előtt")
+        self.snapshot.setChecked(True)
+        k.elrendezes.addWidget(self.snapshot)
+        self.snapshot_megj = cimke("", "halvany", True)
+        k.elrendezes.addWidget(self.snapshot_megj)
+        osszegzes.hozzaad(k)
+        self.torzs.addWidget(osszegzes)
+
+        self.figyelem = cimke("", "figyelem", True)
+        self.figyelem.hide()
+        self.torzs.addWidget(self.figyelem)
+        self.ujraindito_sav = QWidget()
+        us = QHBoxLayout(self.ujraindito_sav)
+        us.setContentsMargins(0, 0, 0, 0)
+        us.setSpacing(12)
+        us.addWidget(
+            cimke("A frissítés után újraindítás szükséges, hogy az új kernel vagy driver betöltődjön.", "figyelem", True),
+            1,
+        )
+        ujraindit = gomb("Újraindítás most", fo=True)
+        ujraindit.clicked.connect(self._ujraindit)
+        us.addWidget(ujraindit)
+        self.ujraindito_sav.hide()
+        self.torzs.addWidget(self.ujraindito_sav)
+
+        csomag_resz = QVBoxLayout()
+        csomag_resz.setSpacing(12)
+        fej = QHBoxLayout()
+        fej.addWidget(cimke("CSOMAGOK", "h2"))
+        fej.addStretch(1)
+        self.mind = gomb("Mind kijelölése", kicsi=True)
+        self.mind.clicked.connect(self._mind)
+        fej.addWidget(self.mind)
+        csomag_resz.addLayout(fej)
+        csomag_resz.addWidget(
+            cimke(
+                "A hivatalos csomagok (pacman) csak együtt frissíthetők: Arch-alapú rendszeren a részleges frissítés "
+                "elronthatja a rendszert. Az AUR és a Flatpak csomagok egyenként is kijelölhetők.",
+                "halvany",
+                True,
+            )
+        )
+        self.tabla = QTableWidget(0, 6)
+        self.tabla.setHorizontalHeaderLabels(["", "Csomag", "Forrás", "Jelenlegi", "Új", "Méret"])
+        self.tabla.verticalHeader().hide()
+        self.tabla.setShowGrid(False)
+        self.tabla.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        self.tabla.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.tabla.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        fejlec = self.tabla.horizontalHeader()
+        fejlec.setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
+        fejlec.setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
+        fejlec.setDefaultAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+        self.tabla.setMinimumHeight(120)
+        self.tabla.itemChanged.connect(self._valtozott)
+        csomag_resz.addWidget(self.tabla, 1)
+        self.ures = cimke("", "masodlagos", True)
+        self.ures.hide()
+        csomag_resz.addWidget(self.ures)
+        self.torzs.addLayout(csomag_resz, 3)
+
+        naplo_resz = QVBoxLayout()
+        naplo_resz.setSpacing(12)
+        naplo_resz.addWidget(cimke("NAPLÓ", "h2"))
+        self.naplo = QPlainTextEdit()
+        self.naplo.setObjectName("naplo")
+        self.naplo.setReadOnly(True)
+        self.naplo.setMaximumBlockCount(5000)
+        self.naplo.setMinimumHeight(90)
+        naplo_resz.addWidget(self.naplo, 1)
+        self.torzs.addLayout(naplo_resz, 2)
+
+    def indulaskor(self):
+        self._ellenoriz(False)
+
+    def megjelenik(self, *_):
+        snapper = rendszerinfo.snapper_elerheto()
+        automatikus = snapper and snapshotok.snap_pac()
+        self.snapshot.setVisible(not automatikus)
+        self.snapshot.setEnabled(snapper and not automatikus and not self.futtato.fut())
+        if automatikus:
+            self.snapshot.setChecked(False)
+            self.snapshot_megj.setText(
+                "Minden csomagművelet előtt automatikusan snapshot készül, ha gond van, a Rendszer > Snapshotok "
+                "fülön vissza tudsz állni."
+            )
+        elif not snapper:
+            self.snapshot.setChecked(False)
+            self.snapshot_megj.setText("Snapshot csak btrfs fájlrendszeren, beállított snapperrel készíthető.")
+        else:
+            self.snapshot_megj.setText("Ha a frissítés után gond van, erre vissza tudsz állni.")
+        if not muveletek.helper_elerheto():
+            self.figyelem.setText(
+                "A RaveOS Center rendszerhelpere nincs telepítve, ezért a rendszercsomagok frissítése nem indítható."
+            )
+            self.figyelem.show()
+        if not self.futtato.fut() and not self.csomagok:
+            self._ellenoriz(False)
+
+    def _naplo(self, szoveg):
+        self.naplo.appendPlainText(szoveg)
+
+    def _ellenoriz(self, friss):
+        if self.futtato.fut():
+            return
+        self.ellenorzes.setEnabled(False)
+        self.ellenorzes.setText("Ellenőrzés...")
+        self._naplo(":: Frissítések ellenőrzése (pacman, AUR, Flatpak)...")
+        hatterben(rendszerinfo.frissitesek, friss, kesz=self._ellenorzes_kesz, hiba=self._ellenorzes_hiba)
+
+    def _ellenorzes_vege(self):
+        self.ellenorzes.setEnabled(True)
+        self.ellenorzes.setText("Ellenőrzés")
+        mikor = rendszerinfo.frissites_ellenorizve()
+        if mikor:
+            self.eyebrow.setText(f"UTOLSÓ ELLENŐRZÉS: {datetime.fromtimestamp(mikor):%H:%M}")
+
+    def _ellenorzes_kesz(self, csomagok):
+        ervenytelenit("frissitesek")
+        self._ellenorzes_vege()
+        self.csomagok = csomagok
+        szamok = {f: sum(1 for c in csomagok if c["forras"] == f) for f in FORRAS}
+        self._naplo(
+            f":: {len(csomagok)} frissítés: {szamok['pacman']} pacman, {szamok['aur']} AUR, {szamok['flatpak']} Flatpak"
+        )
+        self.kozpont.jelveny(AZON, len(csomagok))
+        self._tablat_tolt()
+
+    def _ellenorzes_hiba(self, uzenet):
+        self._ellenorzes_vege()
+        self._naplo(f"[HIBA] {uzenet}")
+        self.figyelem.setText(f"Az ellenőrzés nem sikerült: {uzenet}")
+        self.figyelem.show()
+
+    def _tablat_tolt(self):
+        self.tabla.blockSignals(True)
+        self.tabla.setRowCount(0)
+        for c in self.csomagok:
+            sor = self.tabla.rowCount()
+            self.tabla.insertRow(sor)
+            jelolo = QTableWidgetItem()
+            jelolo.setFlags(Qt.ItemFlag.ItemIsUserCheckable | Qt.ItemFlag.ItemIsEnabled)
+            jelolo.setCheckState(Qt.CheckState.Checked)
+            self.tabla.setItem(sor, 0, jelolo)
+            nev = cimke(
+                c["nev"]
+                + (
+                    '  <span style="color:#d9a441; font-family:\'Noto Sans Mono\'; font-size:11px">ÚJRAINDÍTÁS</span>'
+                    if c["ujrainditas"]
+                    else ""
+                )
+            )
+            nev.setContentsMargins(8, 0, 8, 0)
+            self.tabla.setCellWidget(sor, 1, nev)
+            for oszlop, ertek in ((2, FORRAS[c["forras"]]), (3, c["regi"] or "-"), (4, c["uj"]), (5, mb(c["meret"]))):
+                elem = QTableWidgetItem(ertek)
+                elem.setFlags(Qt.ItemFlag.ItemIsEnabled)
+                self.tabla.setItem(sor, oszlop, elem)
+        self.tabla.blockSignals(False)
+        ures = not self.csomagok
+        self.tabla.setVisible(not ures)
+        self.ures.setVisible(ures)
+        self.ures.setText("A rendszer naprakész, nincs elérhető frissítés.")
+        self._osszegez()
+
+    def _kijelolt(self):
+        return [
+            c
+            for i, c in enumerate(self.csomagok)
+            if self.tabla.item(i, 0) and self.tabla.item(i, 0).checkState() == Qt.CheckState.Checked
+        ]
+
+    def _valtozott(self, elem):
+        if elem.column() != 0:
+            return
+        if self.csomagok[elem.row()]["forras"] == "pacman":
+            self.tabla.blockSignals(True)
+            for i, c in enumerate(self.csomagok):
+                if c["forras"] == "pacman":
+                    self.tabla.item(i, 0).setCheckState(elem.checkState())
+            self.tabla.blockSignals(False)
+        self._osszegez()
+
+    def _osszegez(self):
+        kijelolt = self._kijelolt()
+        self.kijelolt.setText(f"{len(kijelolt)} / {len(self.csomagok)} CSOMAG")
+        meret = sum(c["meret"] or 0 for c in kijelolt)
+        self.letoltes.setText(f"{meret / 1e6:.0f} MB")
+        mind = bool(self.csomagok) and len(kijelolt) == len(self.csomagok)
+        self.mind.setText("Kijelölés törlése" if mind else "Mind kijelölése")
+        self.mind.setEnabled(bool(self.csomagok) and not self.futtato.fut())
+        tiltott = any(c["forras"] == "pacman" for c in kijelolt) and not muveletek.helper_elerheto()
+        self.inditas.setEnabled(bool(kijelolt) and not self.futtato.fut() and not tiltott)
+        self.inditas.setText(f"Frissítés indítása ({len(kijelolt)})" if kijelolt else "Nincs kijelölve")
+
+    def _mind(self):
+        mind = len(self._kijelolt()) == len(self.csomagok)
+        allapot = Qt.CheckState.Unchecked if mind else Qt.CheckState.Checked
+        self.tabla.blockSignals(True)
+        for i in range(self.tabla.rowCount()):
+            self.tabla.item(i, 0).setCheckState(allapot)
+        self.tabla.blockSignals(False)
+        self._osszegez()
+
+    def _indit(self):
+        kijelolt = self._kijelolt()
+        if not kijelolt:
+            return
+        lepesek = []
+        pacman = [c for c in kijelolt if c["forras"] == "pacman"]
+        aur = [c["nev"] for c in kijelolt if c["forras"] == "aur"]
+        flatpak = [c["nev"] for c in kijelolt if c["forras"] == "flatpak"]
+        if self.snapshot.isChecked() and self.snapshot.isEnabled():
+            lepesek.append(
+                muveletek.Lepes("Snapshot készítése", muveletek.root("snapshot", "Frissítés előtt (RaveOS Center)"))
+            )
+        if pacman:
+            lepesek.append(muveletek.Lepes("Rendszercsomagok frissítése (pacman)", muveletek.root("frissites")))
+        if aur:
+            lepesek.append(
+                muveletek.Lepes(
+                    "AUR csomagok frissítése",
+                    [
+                        "yay", "-S", "--noconfirm", "--color", "never", "--sudo", "pkexec",
+                        "--answerclean", "None", "--answerdiff", "None", "--answeredit", "None",
+                        *aur,
+                    ],
+                    kotelezo=False,
+                )
+            )
+        if flatpak:
+            lepesek.append(
+                muveletek.Lepes(
+                    "Flatpak alkalmazások frissítése",
+                    ["flatpak", "update", "-y", "--noninteractive", *flatpak],
+                    kotelezo=False,
+                )
+            )
+        self.ujrainditas_kell = any(c["ujrainditas"] for c in pacman)
+        self.figyelem.hide()
+        self.ujraindito_sav.hide()
+        self._zarol(True)
+        self._naplo("")
+        self._naplo(f":: Frissítés indul, {len(kijelolt)} csomag")
+        self.futtato.indit(lepesek)
+
+    def _zarol(self, fut):
+        for w in (self.ellenorzes, self.inditas, self.mind, self.tabla):
+            w.setEnabled(not fut)
+        self.snapshot.setEnabled(not fut and rendszerinfo.snapper_elerheto() and not snapshotok.snap_pac())
+        if fut:
+            self.inditas.setText("Frissítés folyamatban...")
+
+    def _futas_kesz(self, rendben, hibasak):
+        ervenytelenit()
+        self._zarol(False)
+        if rendben:
+            self._naplo(":: A frissítés sikeresen befejeződött.")
+            if self.ujrainditas_kell:
+                self.ujraindito_sav.show()
+        else:
+            self._naplo(f":: A frissítés hibával ért véget: {', '.join(hibasak)}")
+            self.figyelem.setText(
+                "A frissítés nem sikerült teljesen. A részleteket a lenti napló mutatja. "
+                "Ha nem érted, mi történt, küldj hibajegyet a Visszajelzés oldalon."
+            )
+            self.figyelem.show()
+        self._ellenoriz(True)
+
+    def _ujraindit(self):
+        muveletek.Futtato(self).indit([muveletek.Lepes("Újraindítás", ["systemctl", "reboot"])])
+
+
+OLDAL = Frissitesek
diff --git a/raveos-center/raveos_center/oldalak/rendszer/__init__.py b/raveos-center/raveos_center/oldalak/rendszer/__init__.py
new file mode 100644
index 0000000..60b5768
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/rendszer/__init__.py
@@ -0,0 +1,49 @@
+import importlib
+
+from raveos_center.elemek import Fulsor, Oldal, Verem
+
+AZON = "rendszer"
+MENU = "Rendszer"
+IKON = "rendszer"
+
+FULEK = ["driverek", "gaming", "karbantartas", "snapshotok", "secureboot", "mentes"]
+
+
+class Rendszer(Oldal):
+    def __init__(self, kozpont):
+        super().__init__(kozpont, "DRIVEREK · GAMING · KARBANTARTÁS · SNAPSHOTOK", "Rendszer", kitolt=True)
+        self.fulek = {}
+        modulok = [importlib.import_module(f"{__name__}.{nev}") for nev in FULEK]
+        self.fulsor = Fulsor([(m.AZON, m.CIM) for m in modulok], self.valt)
+        self.torzs.addWidget(self.fulsor)
+        self.verem = Verem()
+        for m in modulok:
+            ful = m.FUL(kozpont)
+            self.fulek[m.AZON] = ful
+            self.verem.addWidget(ful)
+        self.torzs.addWidget(self.verem, 1)
+        self.aktiv = modulok[0].AZON if modulok else None
+        if self.aktiv:
+            self.fulsor.aktiv(self.aktiv)
+
+    def valt(self, azon, *args):
+        if azon not in self.fulek:
+            return
+        self.aktiv = azon
+        self.fulsor.aktiv(azon)
+        self.verem.setCurrentWidget(self.fulek[azon])
+        self.fulek[azon].megjelenik(*args)
+
+    def elerheto(self, ful=None, *_):
+        return ful is None or ful in self.fulek
+
+    def megjelenik(self, ful=None, *args):
+        self.valt(ful if ful in self.fulek else self.aktiv, *args)
+
+    def indulaskor(self):
+        for ful in self.fulek.values():
+            if hasattr(ful, "indulaskor"):
+                ful.indulaskor()
+
+
+OLDAL = Rendszer
diff --git a/raveos-center/raveos_center/oldalak/rendszer/driverek.py b/raveos-center/raveos_center/oldalak/rendszer/driverek.py
new file mode 100644
index 0000000..499e87a
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/rendszer/driverek.py
@@ -0,0 +1,159 @@
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QHBoxLayout, QMessageBox, QVBoxLayout, QWidget
+
+from raveos_center import driverek, muveletek
+from raveos_center.elemek import Kartya, cimke, gomb
+from raveos_center.folyamat import FolyamatAblak
+from raveos_center.hatter import ervenytelenit, gyorsitott
+
+AZON = "driverek"
+CIM = "Driverek"
+
+
+class EszkozSor(QWidget):
+    def __init__(self, elem, telepit):
+        super().__init__()
+        self.setObjectName("appsor")
+        self.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+        sor = QHBoxLayout(self)
+        sor.setContentsMargins(16, 12, 16, 12)
+        sor.setSpacing(16)
+        szovegek = QVBoxLayout()
+        szovegek.setSpacing(3)
+        nev = cimke(elem["nev"], tordel=True)
+        nev.setStyleSheet("font-size: 14px; font-weight: 600;")
+        szovegek.addWidget(nev)
+        szovegek.addWidget(cimke(f"Jelenlegi driver: {elem['jelenlegi'] or 'nincs betöltve'}", "monohalvany"))
+        if elem["hianyzik"]:
+            hiany = cimke(f"Hiányzó csomagok: {' '.join(elem['hianyzik'])}", "monohalvany", True)
+            hiany.setStyleSheet("color: #d9a441;")
+            szovegek.addWidget(hiany)
+        if elem["megjegyzes"]:
+            szovegek.addWidget(cimke(elem["megjegyzes"], "halvany", True))
+        sor.addLayout(szovegek, 1)
+        if elem["hianyzik"]:
+            g = gomb("Ajánlott telepítése", fo=True, kicsi=True)
+            g.setEnabled(muveletek.helper_elerheto())
+            g.clicked.connect(lambda: telepit([elem]))
+            sor.addWidget(g, 0, Qt.AlignmentFlag.AlignVCenter)
+        else:
+            rendben = cimke("RENDBEN", "allapotcimke")
+            rendben.setProperty("szin", "zold")
+            sor.addWidget(rendben, 0, Qt.AlignmentFlag.AlignVCenter)
+
+
+class Driverek(QWidget):
+    def __init__(self, kozpont):
+        super().__init__()
+        self.kozpont = kozpont
+        self.elemek = []
+        self.kapott = None
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 20, 0, 0)
+        doboz.setSpacing(16)
+        fej = QHBoxLayout()
+        fej.addWidget(
+            cimke(
+                "A RaveOS felismeri a géped eszközeit, és megmutatja, melyikhez van ajánlott driver. "
+                "A videokártya drivere a telepítéskor is ugyanígy kerül fel.",
+                "masodlagos",
+                True,
+            ),
+            1,
+        )
+        self.ujra = gomb("Újraellenőrzés", kicsi=True)
+        self.ujra.clicked.connect(self.frissit)
+        fej.addWidget(self.ujra, 0, Qt.AlignmentFlag.AlignTop)
+        self.mind = gomb("Minden ajánlott telepítése", fo=True, kicsi=True)
+        self.mind.clicked.connect(lambda: self._telepit([e for e in self.elemek if e["hianyzik"]]))
+        self.mind.hide()
+        fej.addWidget(self.mind, 0, Qt.AlignmentFlag.AlignTop)
+        doboz.addLayout(fej)
+        self.figyelem = cimke("", "figyelem", True)
+        self.figyelem.hide()
+        doboz.addWidget(self.figyelem)
+        self.lista = QVBoxLayout()
+        self.lista.setSpacing(20)
+        doboz.addLayout(self.lista)
+        doboz.addStretch(1)
+
+    def megjelenik(self, *_):
+        gyorsitott("driverek", driverek.allapot, kesz=self._kesz, hiba=self._hiba, kor=120)
+
+    def frissit(self):
+        self.ujra.setEnabled(False)
+        ervenytelenit("driverek")
+        gyorsitott("driverek", driverek.allapot, kesz=self._kesz, hiba=self._hiba)
+
+    def _hiba(self, uzenet):
+        self.ujra.setEnabled(True)
+        self.figyelem.setText(f"A hardver felismerése nem sikerült: {uzenet}")
+        self.figyelem.show()
+
+    def _kesz(self, elemek):
+        self.ujra.setEnabled(True)
+        if elemek == self.kapott:
+            return
+        self.kapott = elemek
+        self.elemek = elemek
+        while self.lista.count():
+            w = self.lista.takeAt(0).widget()
+            if w:
+                w.deleteLater()
+        if not muveletek.helper_elerheto():
+            self.figyelem.setText("A RaveOS Center rendszerhelpere nincs telepítve, ezért driver nem telepíthető.")
+            self.figyelem.show()
+        else:
+            self.figyelem.hide()
+        if driverek.szkript() is None:
+            self.figyelem.setText("A driverfelismerő szkript nincs telepítve.")
+            self.figyelem.show()
+        for azon, nev in driverek.KATEGORIAK:
+            sajat = [e for e in elemek if e["kategoria"] == azon]
+            if not sajat:
+                continue
+            csoport = QWidget()
+            cs = QVBoxLayout(csoport)
+            cs.setContentsMargins(0, 0, 0, 0)
+            cs.setSpacing(10)
+            cs.addWidget(cimke(nev.upper(), "h2"))
+            kartya = Kartya(terkoz=0, margo=0)
+            for i, e in enumerate(sajat):
+                sor = EszkozSor(e, self._telepit)
+                sor.setProperty("utolso", i == len(sajat) - 1)
+                kartya.elrendezes.addWidget(sor)
+            cs.addWidget(kartya)
+            self.lista.addWidget(csoport)
+        if not elemek:
+            self.lista.addWidget(cimke("Nem található kezelhető eszköz.", "halvany"))
+        hianyzo = [e for e in elemek if e["hianyzik"]]
+        self.mind.setVisible(len(hianyzo) > 1)
+        self.mind.setEnabled(muveletek.helper_elerheto())
+
+    def _telepit(self, elemek):
+        if not elemek:
+            return
+        lepesek = []
+        egyeb = []
+        if any(e["gpu"] for e in elemek):
+            lepesek.append(muveletek.Lepes("Videokártya driverek", muveletek.root("driverek")))
+        for e in elemek:
+            if not e["gpu"]:
+                egyeb += [p for p in e["hianyzik"] if p not in egyeb]
+        if egyeb:
+            lepesek.append(muveletek.Lepes("További driverek", muveletek.root("telepit", *egyeb)))
+        ablak = FolyamatAblak(self, "Driverek telepítése", lepesek, "A driverek telepítve.")
+        ablak.exec()
+        if ablak.rendben and any(driverek.ujrainditas_kell(e) for e in elemek):
+            doboz = QMessageBox(self)
+            doboz.setWindowTitle("Újraindítás szükséges")
+            doboz.setText("Az új videokártya-driver az újraindítás után töltődik be.")
+            most = doboz.addButton("Újraindítás most", QMessageBox.ButtonRole.AcceptRole)
+            doboz.addButton("Később", QMessageBox.ButtonRole.RejectRole)
+            doboz.exec()
+            if doboz.clickedButton() is most:
+                muveletek.Futtato(self).indit([muveletek.Lepes("Újraindítás", ["systemctl", "reboot"])])
+        self.frissit()
+
+
+FUL = Driverek
diff --git a/raveos-center/raveos_center/oldalak/rendszer/gaming.py b/raveos-center/raveos_center/oldalak/rendszer/gaming.py
new file mode 100644
index 0000000..5d410e9
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/rendszer/gaming.py
@@ -0,0 +1,306 @@
+from PyQt6.QtCore import QObject, Qt, pyqtSignal
+from PyQt6.QtWidgets import QComboBox, QHBoxLayout, QMessageBox, QProgressBar, QVBoxLayout, QWidget
+
+from raveos_center import gaming, muveletek, proton
+from raveos_center.elemek import Kapcsolo, Kartya, cimke, gomb
+from raveos_center.folyamat import FolyamatAblak
+from raveos_center.hatter import ervenytelenit, gyorsitott, hatterben, tarolt
+
+AZON = "gaming"
+CIM = "Gaming"
+
+BEALLITASOK = [
+    ("gamemode", "GameMode", "CPU és I/O prioritás játék közben. A Lutris és a Heroic magától használja, Steamben a "
+     "játék indítási opciójába írd: gamemoderun %command%"),
+    ("mangohud", "MangoHud alapból", "FPS, hőmérséklet és terhelés kijelzése minden Vulkan és OpenGL játékban. "
+     "Játék közben a jobb Shift + F12 elrejti, a jobb Shift + F10 vált a kijelző módok között."),
+    ("utemezo", "Játékra hangolt ütemező", "Az scx_lavd ütemező gaming módban: egyenletesebb képkockaidő, amikor a "
+     "háttérben más is fut. Kikapcsolva a kernel saját BORE ütemezője dolgozik."),
+    ("gamescope", "Gamescope session", "Külön, konzolszerű Steam játékmenet, a bejelentkező képernyőn választható."),
+    ("governor", "Performance CPU governor", "Játék közben teljes órajel, a játék bezárása után visszaáll."),
+    ("ntsync", "NTSync", "Gyorsabb Windows-szinkronizáció Wine és Proton alatt."),
+]
+
+
+class _Jelzo(QObject):
+    haladas = pyqtSignal(int)
+
+
+def alkalmaz(szulo, valtozasok):
+    lepesek = []
+    helyi = []
+    for azon, be in valtozasok:
+        l, h = gaming.lepesek(azon, be)
+        lepesek += l
+        if h:
+            helyi.append(h)
+    if lepesek:
+        ablak = FolyamatAblak(szulo, "Gaming beállítások", lepesek, "A beállítás elkészült.")
+        ablak.exec()
+        if not ablak.rendben:
+            return "A beállítás nem sikerült teljesen, a részleteket a napló mutatja."
+    for h in helyi:
+        try:
+            h()
+        except OSError as e:
+            return f"A beállítás nem sikerült: {e}"
+    return None
+
+
+class Sor(QWidget):
+    def __init__(self, nev, leiras, utolso=False):
+        super().__init__()
+        self.setObjectName("appsor")
+        self.setProperty("utolso", utolso)
+        self.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+        self.sor = QHBoxLayout(self)
+        self.sor.setContentsMargins(16, 14, 16, 14)
+        self.sor.setSpacing(16)
+        self.szovegek = QVBoxLayout()
+        self.szovegek.setSpacing(3)
+        cim = cimke(nev)
+        cim.setStyleSheet("font-size: 14px; font-weight: 600;")
+        self.szovegek.addWidget(cim)
+        self.szovegek.addWidget(cimke(leiras, "halvany", True))
+        self.megjegyzes = cimke("", "monohalvany", True)
+        self.megjegyzes.hide()
+        self.szovegek.addWidget(self.megjegyzes)
+        self.sor.addLayout(self.szovegek, 1)
+
+    def jegyzet(self, szoveg):
+        self.megjegyzes.setText(szoveg)
+        self.megjegyzes.setVisible(bool(szoveg))
+
+
+class BeallitasSor(Sor):
+    def __init__(self, azon, nev, leiras, valt, utolso=False):
+        super().__init__(nev, leiras, utolso)
+        self.azon = azon
+        self.kapcsolo = Kapcsolo()
+        self.kapcsolo.setAccessibleName(nev)
+        self.kapcsolo.clicked.connect(lambda be: valt(self.azon, be))
+        self.sor.addWidget(self.kapcsolo, 0, Qt.AlignmentFlag.AlignVCenter)
+
+    def beallit(self, adat, foglalt):
+        self.kapcsolo.blockSignals(True)
+        self.kapcsolo.setChecked(adat["aktiv"])
+        self.kapcsolo.blockSignals(False)
+        helper = muveletek.helper_elerheto() or not adat["root"]
+        self.kapcsolo.setEnabled(adat["elerheto"] and helper and not foglalt)
+        self.jegyzet(adat["megjegyzes"])
+        self.kapcsolo.update()
+
+
+class ProtonGeSor(Sor):
+    def __init__(self, szulo):
+        super().__init__(
+            "Proton-GE",
+            "A GloriousEggroll Proton-változata, több játékhoz tartalmaz javítást és videokodeket. A Steam "
+            "újraindítása után a játék Tulajdonságok > Kompatibilitás menüjében választható.",
+        )
+        self.szulo = szulo
+        self.kiadas = None
+        self.fut = False
+        self.jelzo = _Jelzo()
+        self.sav = QProgressBar()
+        self.sav.setObjectName("sav")
+        self.sav.setTextVisible(False)
+        self.sav.setFixedHeight(6)
+        self.sav.hide()
+        self.jelzo.haladas.connect(self.sav.setValue)
+        self.szovegek.addWidget(self.sav)
+        gombok = QVBoxLayout()
+        gombok.setSpacing(6)
+        self.telepit_gomb = gomb("Legújabb telepítése", fo=True, kicsi=True)
+        self.telepit_gomb.clicked.connect(self._telepit)
+        self.regiek_gomb = gomb("Régiek törlése", kicsi=True)
+        self.regiek_gomb.clicked.connect(self._regiek)
+        self.torol_gomb = gomb("Mind törlése", kicsi=True)
+        self.torol_gomb.clicked.connect(self._mind)
+        for g in (self.telepit_gomb, self.regiek_gomb, self.torol_gomb):
+            gombok.addWidget(g)
+        gombok.addStretch(1)
+        self.sor.addLayout(gombok)
+
+    def frissit(self):
+        if self.fut:
+            return
+        self._mutat()
+        gyorsitott("proton_ge", proton.legujabb, kesz=self._kiadas, hiba=lambda _: self._kiadas(None), kor=3600)
+
+    def _kiadas(self, kiadas):
+        self.kiadas = kiadas or self.kiadas
+        if not self.fut:
+            self._mutat()
+
+    def _mutat(self, szoveg=None):
+        lista = proton.telepitett()
+        van_steam = bool(proton.celmappak())
+        naprakesz = bool(self.kiadas and lista and lista[0] == self.kiadas["nev"])
+        if szoveg is None:
+            szoveg = f"Telepítve: {', '.join(lista)}" if lista else "Nincs telepítve."
+            if self.kiadas and not naprakesz:
+                szoveg += f"  Legújabb: {self.kiadas['nev']}"
+            if not van_steam:
+                szoveg = "Nem található Steam. Telepítsd, és indítsd el egyszer."
+        self.jegyzet(szoveg)
+        self.telepit_gomb.setText("Naprakész" if naprakesz else "Legújabb telepítése")
+        self.telepit_gomb.setEnabled(not self.fut and not naprakesz and van_steam)
+        self.regiek_gomb.setVisible(bool(proton.regiek()))
+        self.regiek_gomb.setEnabled(not self.fut)
+        self.torol_gomb.setVisible(bool(lista))
+        self.torol_gomb.setEnabled(not self.fut)
+
+    def _telepit(self):
+        self.fut = True
+        self.sav.setValue(0)
+        self.sav.show()
+        self._mutat("Letöltés és ellenőrzés, ez néhány percig tarthat.")
+        hatterben(self._letolt, kesz=self._kesz, hiba=self._hiba)
+
+    def _letolt(self):
+        kiadas = self.kiadas or proton.legujabb()
+        proton.telepit(kiadas, self.jelzo.haladas.emit)
+        return kiadas
+
+    def _kesz(self, kiadas):
+        self.fut = False
+        self.kiadas = kiadas
+        self.sav.hide()
+        self._mutat()
+
+    def _hiba(self, uzenet):
+        self.fut = False
+        self.sav.hide()
+        self._mutat()
+        QMessageBox.warning(self.szulo, "Proton-GE", f"A telepítés nem sikerült: {uzenet}")
+
+    def _torles(self, parok, kerdes):
+        if not parok or QMessageBox.question(self.szulo, "Proton-GE", kerdes) != QMessageBox.StandardButton.Yes:
+            return
+        try:
+            for mappa, nev in parok:
+                proton.torol(nev, [mappa] if mappa else None)
+        except OSError as e:
+            QMessageBox.warning(self.szulo, "Proton-GE", f"A törlés nem sikerült: {e}")
+        self._mutat()
+
+    def _regiek(self):
+        parok = proton.regiek()
+        nevek = ", ".join(sorted({n for _, n in parok}))
+        self._torles(parok, f"Törlöd a régebbi verziókat ({nevek})? Minden Steam-telepítésben a legújabb megmarad.")
+
+    def _mind(self):
+        self._torles(
+            [(None, n) for n in proton.telepitett()],
+            "Törlöd az összes Proton-GE verziót? Az ezeket használó játékok a Steam alap Protonjára váltanak.",
+        )
+
+
+class Gaming(QWidget):
+    def __init__(self, kozpont):
+        super().__init__()
+        self.kozpont = kozpont
+        self.adat = None
+        self.foglalt = False
+        self.hibauzenet = ""
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 20, 0, 0)
+        doboz.setSpacing(16)
+        doboz.addWidget(
+            cimke(
+                "Játékhoz hasznos beállítások. Mindegyik bármikor visszakapcsolható. Az Áttekintés Gaming mód "
+                "kapcsolója a GameMode-ot, a performance governort, az NTSync-et és a játékra hangolt ütemezőt "
+                "kapcsolja egyszerre.",
+                "masodlagos",
+                True,
+            )
+        )
+        self.figyelem = cimke("", "figyelem", True)
+        self.figyelem.hide()
+        doboz.addWidget(self.figyelem)
+
+        kartya = Kartya(terkoz=0, margo=0)
+        self.sorok = {}
+        for i, (azon, nev, leiras) in enumerate(BEALLITASOK):
+            sor = BeallitasSor(azon, nev, leiras, self.valt, i == len(BEALLITASOK) - 1)
+            self.sorok[azon] = sor
+            kartya.elrendezes.addWidget(sor)
+        self.hud_mod = QComboBox()
+        for mod, nev in gaming.MANGOHUD_MODOK:
+            self.hud_mod.addItem(nev, mod)
+        self.hud_mod.activated.connect(self._hud_mod)
+        hud_sor = QHBoxLayout()
+        hud_sor.setSpacing(8)
+        hud_sor.addWidget(cimke("Kijelző:", "halvany"))
+        hud_sor.addWidget(self.hud_mod)
+        hud_sor.addStretch(1)
+        self.sorok["mangohud"].szovegek.addSpacing(6)
+        self.sorok["mangohud"].szovegek.addLayout(hud_sor)
+        doboz.addWidget(kartya)
+
+        doboz.addSpacing(8)
+        doboz.addWidget(cimke("PROTON VERZIÓK", "h2"))
+        proton_kartya = Kartya(terkoz=0, margo=0)
+        self.proton_ge = ProtonGeSor(self)
+        proton_kartya.elrendezes.addWidget(self.proton_ge)
+        self.sorok["proton_cachyos"] = BeallitasSor(
+            "proton_cachyos",
+            "Proton-CachyOS",
+            "A CachyOS Proton-változata a rendszer csomagkezelőjéből, a rendszerfrissítéssel együtt frissül. "
+            "Kb. 1,6 GB. A Steam újraindítása után választható.",
+            self.valt,
+            True,
+        )
+        proton_kartya.elrendezes.addWidget(self.sorok["proton_cachyos"])
+        doboz.addWidget(proton_kartya)
+        doboz.addStretch(1)
+
+    def megjelenik(self, *_):
+        self.frissit()
+        self.proton_ge.frissit()
+
+    def frissit(self):
+        if tarolt("gaming") is None:
+            self.foglalt = True
+            for sor in self.sorok.values():
+                sor.kapcsolo.setEnabled(False)
+        gyorsitott("gaming", gaming.allapot, kesz=self._kesz, hiba=lambda _: self._kesz(self.adat), kor=30)
+
+    def _kesz(self, adat):
+        self.foglalt = False
+        index = self.hud_mod.findData(gaming.mangohud_mod())
+        self.hud_mod.setCurrentIndex(max(0, index))
+        if adat is None:
+            self._figyelmeztet("Az állapot nem olvasható be, próbáld újra a fül újbóli megnyitásával.")
+            return
+        self.adat = adat
+        for azon, sor in self.sorok.items():
+            sor.beallit(adat[azon], self.foglalt)
+        if self.hibauzenet:
+            self._figyelmeztet(self.hibauzenet)
+        elif not muveletek.helper_elerheto():
+            self._figyelmeztet("A RaveOS Center rendszerhelpere nincs telepítve, a legtöbb beállítás nem módosítható.")
+        else:
+            self.figyelem.hide()
+
+    def _figyelmeztet(self, szoveg):
+        self.figyelem.setText(szoveg)
+        self.figyelem.show()
+
+    def _hud_mod(self):
+        try:
+            gaming.mangohud_mod_beallit(self.hud_mod.currentData())
+        except OSError as e:
+            QMessageBox.warning(self, "MangoHud", f"A beállítás nem sikerült: {e}")
+
+    def valt(self, azon, be):
+        self.alkalmaz([(azon, be)])
+
+    def alkalmaz(self, valtozasok):
+        self.hibauzenet = alkalmaz(self, valtozasok) or ""
+        ervenytelenit("gaming")
+        self.frissit()
+
+
+FUL = Gaming
diff --git a/raveos-center/raveos_center/oldalak/rendszer/karbantartas.py b/raveos-center/raveos_center/oldalak/rendszer/karbantartas.py
new file mode 100644
index 0000000..91b7113
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/rendszer/karbantartas.py
@@ -0,0 +1,177 @@
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QDialog, QHBoxLayout, QListWidget, QListWidgetItem, QVBoxLayout, QWidget
+
+from raveos_center import karbantartas, muveletek
+from raveos_center.elemek import Kartya, Racs, cimke, gomb
+from raveos_center.folyamat import FolyamatAblak
+from raveos_center.hatter import gyorsitott, tarolt
+
+AZON = "karbantartas"
+CIM = "Karbantartás"
+
+MUVELETEK = [
+    ("cache", "paccache -rk2", "Csomag cache ürítése",
+     "Minden csomagból csak az utolsó két verzió marad, az eltávolított csomagok fájljai törlődnek.", True),
+    ("arva", "pacman -Qdtq", "Árva csomagok",
+     "Már semmi által nem használt függőségek eltávolítása. Az előnézetben egyenként kiveheted, amit megtartanál.", True),
+    ("naplo", "journalctl --vacuum", "Naplók takarítása",
+     "A két hétnél régebbi rendszernaplók törlése, legfeljebb 100 MB marad.", True),
+    ("tukrok", "reflector", "Tükrök frissítése",
+     "A leggyorsabb közeli letöltési szerverek kiválasztása. A régi lista biztonsági másolatként megmarad.", False),
+    ("kulcsok", "pacman-key --populate", "Kulcsok frissítése",
+     "A csomagaláíró kulcsok újratöltése. Segít, ha a frissítés aláírási hibával áll le.", False),
+    ("flatpak", "flatpak uninstall --unused", "Flatpak takarítás",
+     "A már egyik alkalmazás által sem használt runtime-ok eltávolítása.", True),
+]
+
+
+class ElonezetAblak(QDialog):
+    def __init__(self, szulo, cim, szoveg, elemek, valaszthato, gomb_szoveg):
+        super().__init__(szulo)
+        self.setWindowTitle(cim)
+        self.resize(640, 480)
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(28, 24, 28, 20)
+        doboz.setSpacing(12)
+        doboz.addWidget(cimke("ELŐNÉZET", "eyebrow"))
+        doboz.addWidget(cimke(cim.upper(), "h2", True))
+        doboz.addWidget(cimke(szoveg, "masodlagos", True))
+        self.lista = QListWidget()
+        for elem in elemek:
+            sor = QListWidgetItem(elem)
+            if valaszthato:
+                sor.setFlags(sor.flags() | Qt.ItemFlag.ItemIsUserCheckable)
+                sor.setCheckState(Qt.CheckState.Checked)
+            self.lista.addItem(sor)
+        self.lista.setVisible(bool(elemek))
+        doboz.addWidget(self.lista, 1)
+        if not elemek:
+            doboz.addStretch(1)
+        gombok = QHBoxLayout()
+        gombok.addStretch(1)
+        megse = gomb("Mégse")
+        megse.clicked.connect(self.reject)
+        gombok.addWidget(megse)
+        self.mehet = gomb(gomb_szoveg, fo=True)
+        self.mehet.clicked.connect(self.accept)
+        gombok.addWidget(self.mehet)
+        doboz.addLayout(gombok)
+        if valaszthato:
+            self.lista.itemChanged.connect(lambda _: self.mehet.setEnabled(bool(self.kivalasztott())))
+
+    def kivalasztott(self):
+        return [
+            self.lista.item(i).text()
+            for i in range(self.lista.count())
+            if self.lista.item(i).checkState() == Qt.CheckState.Checked
+        ]
+
+
+class MuveletKartya(Kartya):
+    def __init__(self, parancs, nev, leiras, futtat):
+        super().__init__(terkoz=8, margo=20)
+        self.elrendezes.addWidget(cimke(parancs, "monohalvany"))
+        cim = cimke(nev)
+        cim.setStyleSheet("font-size: 15px; font-weight: 600;")
+        self.elrendezes.addWidget(cim)
+        self.elrendezes.addWidget(cimke(leiras, "halvany", True))
+        self.elrendezes.addStretch(1)
+        self.osszegzes = cimke("Ellenőrzés...", "monozold", True)
+        self.elrendezes.addWidget(self.osszegzes)
+        sor = QHBoxLayout()
+        self.gomb = gomb("Futtatás", kicsi=True)
+        self.gomb.clicked.connect(futtat)
+        sor.addWidget(self.gomb)
+        sor.addStretch(1)
+        self.elrendezes.addLayout(sor)
+
+
+class Karbantartas(QWidget):
+    def __init__(self, kozpont):
+        super().__init__()
+        self.kozpont = kozpont
+        self.adat = {}
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 20, 0, 0)
+        doboz.setSpacing(16)
+        doboz.addWidget(
+            cimke(
+                "Rendszeres takarítás és javítás. A törléssel járó műveletek előtt megmutatjuk, mi kerülne törlésre, "
+                "és csak a megerősítésed után futnak.",
+                "masodlagos",
+                True,
+            )
+        )
+        self.figyelem = cimke("", "figyelem", True)
+        self.figyelem.hide()
+        doboz.addWidget(self.figyelem)
+        self.racs = Racs(260, 12)
+        self.kartyak = {}
+        for azon, parancs, nev, leiras, _ in MUVELETEK:
+            kartya = MuveletKartya(parancs, nev, leiras, lambda _=False, a=azon: self._futtat(a))
+            self.kartyak[azon] = kartya
+            self.racs.hozzaad(kartya)
+        doboz.addWidget(self.racs)
+        doboz.addStretch(1)
+
+    def megjelenik(self, *_):
+        helper = muveletek.helper_elerheto()
+        self.figyelem.setText("A RaveOS Center rendszerhelpere nincs telepítve, a műveletek nem futtathatók.")
+        self.figyelem.setVisible(not helper)
+        for azon in self.kartyak:
+            self._ellenoriz(azon)
+
+    def _ellenoriz(self, azon):
+        kartya = self.kartyak[azon]
+        if tarolt(f"karbantartas_{azon}") is None:
+            kartya.gomb.setEnabled(False)
+            kartya.osszegzes.setText("Ellenőrzés...")
+        gyorsitott(
+            f"karbantartas_{azon}",
+            karbantartas.ELONEZETEK[azon],
+            kesz=lambda adat, a=azon: self._kesz(a, adat),
+            hiba=lambda uzenet, a=azon: self._kesz(a, {"elerheto": False, "osszegzes": uzenet, "elemek": []}),
+            kor=60,
+        )
+
+    def _kesz(self, azon, adat):
+        self.adat[azon] = adat
+        kartya = self.kartyak[azon]
+        kartya.osszegzes.setText(adat["osszegzes"])
+        torlo = next(m[4] for m in MUVELETEK if m[0] == azon)
+        teendo = not torlo or azon == "naplo" or bool(adat["elemek"])
+        kartya.gomb.setEnabled(adat["elerheto"] and teendo and muveletek.helper_elerheto())
+
+    def _futtat(self, azon):
+        adat = self.adat.get(azon)
+        if not adat:
+            return
+        nev = next(m[2] for m in MUVELETEK if m[0] == azon)
+        kivalasztott = None
+        if azon == "cache":
+            szoveg = f"Ezek a csomagfájlok törlődnek a cache-ből ({adat['osszegzes']}). A telepített programokat nem érinti."
+        elif azon == "arva":
+            szoveg = (
+                "Pontosan ezek a csomagok törlődnek, más nem. Vedd ki a pipát annál, amit megtartanál. "
+                "Utána újabb árva függőségek jelenhetnek meg, ezeket a kártya újra megmutatja."
+            )
+        elif azon == "naplo":
+            szoveg = f"{adat['osszegzes']}. A két hétnél régebbi naplók törlődnek, és legfeljebb 100 MB marad."
+        elif azon == "flatpak":
+            szoveg = "Ezek a runtime-ok törlődnek. Az alkalmazásaid továbbra is működnek."
+        else:
+            szoveg = ""
+        if szoveg:
+            ablak = ElonezetAblak(self, nev, szoveg, adat["elemek"], azon == "arva", "Törlés")
+            if ablak.exec() != QDialog.DialogCode.Accepted:
+                return
+            if azon == "arva":
+                kivalasztott = ablak.kivalasztott()
+        lepesek = karbantartas.lepesek(azon, adat, kivalasztott)
+        if not lepesek:
+            return
+        FolyamatAblak(self, nev, lepesek, "A művelet elkészült.").exec()
+        self._ellenoriz(azon)
+
+
+FUL = Karbantartas
diff --git a/raveos-center/raveos_center/oldalak/rendszer/mentes.py b/raveos-center/raveos_center/oldalak/rendszer/mentes.py
new file mode 100644
index 0000000..6ad5967
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/rendszer/mentes.py
@@ -0,0 +1,283 @@
+from datetime import datetime
+from pathlib import Path
+
+from PyQt6.QtCore import QObject, Qt, pyqtSignal
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QFrame,
+    QScrollArea,
+    QFileDialog,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QMessageBox,
+    QPlainTextEdit,
+    QProgressBar,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+from raveos_center import katalogus, mentesek, muveletek
+from raveos_center.elemek import Kartya, cimke, gomb
+from raveos_center.hatter import hatterben
+
+AZON = "mentes"
+CIM = "Mentés"
+
+MERET = {"small": "kicsi", "medium": "közepes", "large": "nagy", "xlarge": "nagyon nagy"}
+
+
+class RovidUt(QLabel):
+    def __init__(self, ut):
+        super().__init__(ut)
+        self.teljes = ut
+        self.setObjectName("monohalvany")
+        self.setToolTip(ut)
+        self.setMinimumWidth(60)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+
+    def resizeEvent(self, esemeny):
+        super().resizeEvent(esemeny)
+        self.setText(self.fontMetrics().elidedText(self.teljes, Qt.TextElideMode.ElideMiddle, self.width()))
+
+
+class _Jelzo(QObject):
+    naplo = pyqtSignal(str)
+    haladas = pyqtSignal(int)
+
+
+def elem_sor(elem, bejelolve):
+    sor = QWidget()
+    s = QHBoxLayout(sor)
+    s.setContentsMargins(0, 4, 0, 4)
+    s.setSpacing(12)
+    jelolo = QCheckBox()
+    jelolo.setChecked(bejelolve)
+    s.addWidget(jelolo)
+    szovegek = QVBoxLayout()
+    szovegek.setSpacing(0)
+    nev = cimke(katalogus.loc(elem.get("label")) or elem["id"])
+    nev.setStyleSheet("font-weight: 600;")
+    szovegek.addWidget(nev)
+    szovegek.addWidget(RovidUt(str(mentesek.abszolut(elem))))
+    if elem.get("note"):
+        szovegek.addWidget(cimke(katalogus.loc(elem["note"]), "halvany", True))
+    s.addLayout(szovegek, 1)
+    if elem.get("scope") == "system":
+        s.addWidget(cimke("ROOT", "allapotcimke"))
+    if elem.get("size_hint"):
+        s.addWidget(cimke(MERET.get(elem["size_hint"], elem["size_hint"]), "halvany"))
+    jelolo.nev = nev
+    return sor, jelolo
+
+
+class Mentes(QWidget):
+    def __init__(self, kozpont):
+        super().__init__()
+        self.kozpont = kozpont
+        self.fut = False
+        self.mentes_jelolok = []
+        self.visszaallitas_jelolok = []
+        self.jelzo = _Jelzo()
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 24, 0, 0)
+        doboz.setSpacing(20)
+        doboz.addWidget(
+            cimke(
+                "Mentsd el az alkalmazásaid beállításait és a fontos mappáidat egyetlen fájlba, és állítsd vissza "
+                "őket egy másik gépen vagy újratelepítés után. A ROOT jelölésű elemekhez a rendszer jelszót kér.",
+                "masodlagos",
+                True,
+            )
+        )
+
+        oszlopok = QHBoxLayout()
+        oszlopok.setSpacing(24)
+        doboz.addLayout(oszlopok, 1)
+        bal = QVBoxLayout()
+        bal.setSpacing(16)
+        jobb = QVBoxLayout()
+        jobb.setSpacing(16)
+        oszlopok.addLayout(bal, 3)
+        oszlopok.addLayout(jobb, 2)
+
+        mentes = Kartya("Mentés", terkoz=10, margo=20)
+        gorgeto = QScrollArea()
+        gorgeto.setWidgetResizable(True)
+        gorgeto.setFrameShape(QFrame.Shape.NoFrame)
+        gorgeto.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        gorgeto.setMinimumHeight(160)
+        lista_doboz = QWidget()
+        gorgeto.setWidget(lista_doboz)
+        self.mentes_lista = QVBoxLayout(lista_doboz)
+        self.mentes_lista.setContentsMargins(0, 0, 12, 0)
+        self.mentes_lista.setSpacing(2)
+        mentes.elrendezes.addWidget(gorgeto, 1)
+        cel_sor = QHBoxLayout()
+        cel_sor.setSpacing(8)
+        self.cel = QLineEdit(str(Path.home() / f"raveos-mentes-{datetime.now():%Y%m%d}.tar.gz"))
+        cel_sor.addWidget(self.cel, 1)
+        tallozas = gomb("Tallózás", kicsi=True)
+        tallozas.clicked.connect(self._cel_valaszt)
+        cel_sor.addWidget(tallozas)
+        mentes.elrendezes.addSpacing(8)
+        mentes.elrendezes.addWidget(cimke("Mentés helye", "kartyacim"))
+        mentes.elrendezes.addLayout(cel_sor)
+        gs = QHBoxLayout()
+        gs.addStretch(1)
+        self.mentes_gomb = gomb("Mentés indítása", fo=True)
+        self.mentes_gomb.clicked.connect(self._mentes)
+        gs.addWidget(self.mentes_gomb)
+        mentes.elrendezes.addLayout(gs)
+        bal.addWidget(mentes, 1)
+
+        vissza = Kartya("Visszaállítás", terkoz=10, margo=20)
+        fs = QHBoxLayout()
+        fs.setSpacing(8)
+        self.forras = QLineEdit()
+        self.forras.setPlaceholderText("Válaszd ki a mentésfájlt (.tar.gz)")
+        self.forras.setReadOnly(True)
+        fs.addWidget(self.forras, 1)
+        valaszt = gomb("Mentés kiválasztása", kicsi=True)
+        valaszt.clicked.connect(self._forras_valaszt)
+        fs.addWidget(valaszt)
+        vissza.elrendezes.addLayout(fs)
+        self.vissza_lista = QVBoxLayout()
+        self.vissza_lista.setSpacing(2)
+        vissza.elrendezes.addLayout(self.vissza_lista)
+        vissza.elrendezes.addWidget(
+            cimke("A visszaállítás felülírja a meglévő fájlokat a kiválasztott helyeken.", "halvany", True)
+        )
+        vs = QHBoxLayout()
+        vs.addStretch(1)
+        self.vissza_gomb = gomb("Visszaállítás", fo=True)
+        self.vissza_gomb.setEnabled(False)
+        self.vissza_gomb.clicked.connect(self._visszaallitas)
+        vs.addWidget(self.vissza_gomb)
+        vissza.elrendezes.addLayout(vs)
+        jobb.addWidget(vissza)
+
+        self.sav = QProgressBar()
+        self.sav.setObjectName("sav")
+        self.sav.setTextVisible(False)
+        self.sav.setFixedHeight(6)
+        jobb.addWidget(self.sav)
+        jobb.addWidget(cimke("NAPLÓ", "h2"))
+        self.naplo = QPlainTextEdit()
+        self.naplo.setObjectName("naplo")
+        self.naplo.setReadOnly(True)
+        self.naplo.setMinimumHeight(100)
+        jobb.addWidget(self.naplo, 1)
+        self.jelzo.naplo.connect(self.naplo.appendPlainText)
+        self.jelzo.haladas.connect(self.sav.setValue)
+        self._mentes_lista_epit()
+
+    def _mentes_lista_epit(self):
+        try:
+            csoportok = mentesek.csoportok()
+        except (OSError, ValueError, RuntimeError) as e:
+            self.mentes_lista.addWidget(cimke(f"A mentési lista nem tölthető be: {e}", "figyelem", True))
+            return
+        self.mentes_lista.addStretch(0)
+        for csoport in csoportok:
+            fej = cimke(katalogus.loc(csoport.get("label")).upper(), "monozold")
+            self.mentes_lista.addSpacing(8)
+            self.mentes_lista.addWidget(fej)
+            if csoport.get("description"):
+                self.mentes_lista.addWidget(cimke(katalogus.loc(csoport["description"]), "halvany", True))
+            for elem in csoport.get("items", []):
+                sor, jelolo = elem_sor(elem, elem.get("default_selected", False))
+                self.mentes_lista.addWidget(sor)
+                self.mentes_jelolok.append((jelolo, elem))
+
+    def megjelenik(self, *_):
+        self._gombok()
+
+    def _gombok(self):
+        self.mentes_gomb.setEnabled(not self.fut)
+        self.vissza_gomb.setEnabled(not self.fut and bool(self.visszaallitas_jelolok))
+
+    def _cel_valaszt(self):
+        ut, _ = QFileDialog.getSaveFileName(self, "Mentés helye", self.cel.text(), "Mentés (*.tar.gz)")
+        if ut:
+            self.cel.setText(ut if ut.endswith(".tar.gz") else ut + ".tar.gz")
+
+    def _forras_valaszt(self):
+        ut, _ = QFileDialog.getOpenFileName(self, "Mentés kiválasztása", str(Path.home()), "Mentés (*.tar.gz)")
+        if not ut:
+            return
+        self.forras.setText(ut)
+        self._tartalom([])
+        hatterben(mentesek.tartalom, ut, kesz=self._tartalom, hiba=lambda u: self._hiba(f"A fájl nem olvasható: {u}"))
+
+    def _tartalom(self, lista):
+        while self.vissza_lista.count():
+            w = self.vissza_lista.takeAt(0).widget()
+            if w:
+                w.deleteLater()
+        self.visszaallitas_jelolok = []
+        if not lista:
+            self.vissza_lista.addWidget(cimke("Ebben a fájlban nincs visszaállítható elem.", "halvany"))
+        for elem in lista:
+            sor, jelolo = elem_sor(elem, True)
+            self.vissza_lista.addWidget(sor)
+            self.visszaallitas_jelolok.append((jelolo, elem))
+        if any(e.get("regi") for e in lista):
+            self.vissza_lista.addWidget(
+                cimke("Régi (App Installer) formátumú mentés: a rendszerelemek ebből nem állíthatók vissza.", "halvany", True)
+            )
+        self._gombok()
+
+    def _hiba(self, szoveg):
+        self.naplo.appendPlainText(f"[HIBA] {szoveg}")
+
+    def _rootot_kell(self, elemek):
+        if any(e.get("scope") == "system" for e in elemek) and not muveletek.helper_elerheto():
+            QMessageBox.warning(self, "Mentés", "A rendszerelemekhez a RaveOS Center rendszerhelpere szükséges, de nincs telepítve.")
+            return False
+        return True
+
+    def _mentes(self):
+        elemek = [e for j, e in self.mentes_jelolok if j.isChecked()]
+        cel = self.cel.text().strip()
+        if not elemek or not cel or not self._rootot_kell(elemek):
+            return
+        if Path(cel).exists():
+            if QMessageBox.question(self, "Mentés", f"A fájl már létezik, felülírod?\n{cel}") != QMessageBox.StandardButton.Yes:
+                return
+        self._indul(f"Mentés indul: {cel}")
+        hatterben(
+            mentesek.mentes, cel, elemek, self.jelzo.naplo.emit, self.jelzo.haladas.emit,
+            kesz=lambda n: self._vege(f"Mentés kész: {n} elem, {cel}"),
+            hiba=lambda u: self._vege(f"A mentés nem sikerült: {u}", False),
+        )
+
+    def _visszaallitas(self):
+        elemek = [e for j, e in self.visszaallitas_jelolok if j.isChecked()]
+        if not elemek or not self._rootot_kell(elemek):
+            return
+        if QMessageBox.question(
+            self, "Visszaállítás", f"{len(elemek)} elem visszaállítása felülírja a meglévő fájlokat. Folytatod?"
+        ) != QMessageBox.StandardButton.Yes:
+            return
+        self._indul(f"Visszaállítás indul: {self.forras.text()}")
+        hatterben(
+            mentesek.visszaallitas, self.forras.text(), elemek, self.jelzo.naplo.emit, self.jelzo.haladas.emit,
+            kesz=lambda n: self._vege(f"Visszaállítás kész: {n} elem."),
+            hiba=lambda u: self._vege(f"A visszaállítás nem sikerült: {u}", False),
+        )
+
+    def _indul(self, szoveg):
+        self.fut = True
+        self._gombok()
+        self.sav.setValue(0)
+        self.naplo.appendPlainText(szoveg)
+
+    def _vege(self, szoveg, rendben=True):
+        self.fut = False
+        self._gombok()
+        self.naplo.appendPlainText(szoveg if rendben else f"[HIBA] {szoveg}")
+
+
+FUL = Mentes
diff --git a/raveos-center/raveos_center/oldalak/rendszer/secureboot.py b/raveos-center/raveos_center/oldalak/rendszer/secureboot.py
new file mode 100644
index 0000000..00ca444
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/rendszer/secureboot.py
@@ -0,0 +1,256 @@
+import shutil
+import subprocess
+
+from PyQt6.QtWidgets import QHBoxLayout, QMessageBox, QPlainTextEdit, QVBoxLayout, QWidget
+
+from raveos_center import muveletek
+from raveos_center.elemek import Kartya, Racs, cimke, gomb
+from raveos_center.hatter import ervenytelenit, gyorsitott, tarolt
+
+AZON = "secureboot"
+CIM = "Secure Boot"
+
+SZKRIPT = "raveos-secureboot-setup"
+UJRAINDITAS_KELL = 10
+
+LEPESEK_SZOVEG = [
+    "telepíti a szükséges eszközöket (sbsigntools, efitools),",
+    "létrehoz egy saját, csak ehhez a géphez tartozó aláíró kulcsot,",
+    "aláírja a rendszerbetöltőt, a kernelt és a külső kernelmodulokat (pl. NVIDIA),",
+    "beírja a firmware-be a RaveOS, a Microsoft és a saját géped kulcsát, így a Windows is tovább indul,",
+    "beállít egy automatikus aláírást, ami minden kernelfrissítés után újra aláír.",
+]
+
+
+def allapot_lekerdez():
+    if not shutil.which(SZKRIPT):
+        return None
+    kimenet = subprocess.run([SZKRIPT, "--status"], capture_output=True, text=True, timeout=30)
+    adat = {}
+    for sor in kimenet.stdout.splitlines():
+        if "=" in sor and not sor.startswith("["):
+            k, _, v = sor.partition("=")
+            adat[k.strip()] = v.strip()
+    if not adat and "Nem UEFI" in kimenet.stdout:
+        adat["uefi"] = "0"
+    return adat
+
+
+class SecureBoot(QWidget):
+    def __init__(self, kozpont):
+        super().__init__()
+        self.kozpont = kozpont
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 20, 0, 0)
+        doboz.setSpacing(16)
+        doboz.addWidget(
+            cimke(
+                "A Secure Boot csak aláírt rendszerbetöltőt és kernelt enged elindulni. Akkor hasznos, ha a gépen "
+                "Windows is van, és ott olyan játék vagy program fut, ami bekapcsolt Secure Bootot kér (például egyes "
+                "csalásvédelmek vagy a Windows 11). A beállítás után a RaveOS és a Windows is elindul.",
+                "masodlagos",
+                True,
+            )
+        )
+        oszlopok = QHBoxLayout()
+        oszlopok.setSpacing(24)
+        bal = QVBoxLayout()
+        bal.setSpacing(12)
+        oszlopok.addLayout(bal, 3)
+        doboz.addLayout(oszlopok, 1)
+        self.racs = Racs(110, 10)
+        self.ertekek = {}
+        for kulcs, nev in (
+            ("secureboot", "Secure Boot"),
+            ("setupmode", "Setup Mode"),
+            ("keys", "Gépkulcs"),
+            ("signed", "Aláírások"),
+        ):
+            k = Kartya(nev, terkoz=6, margo=14)
+            ertek = cimke("...", "nagyszam")
+            k.elrendezes.addWidget(ertek)
+            self.ertekek[kulcs] = ertek
+            self.racs.hozzaad(k)
+        bal.addWidget(self.racs)
+        self.figyelem = cimke("", "figyelem", True)
+        self.figyelem.hide()
+        bal.addWidget(self.figyelem)
+        bal.addWidget(
+            cimke(
+                "FIGYELEM, BITLOCKER: ha a gépen Windows is van BitLockerrel, a beállítás előtt a Windowsban függeszd "
+                "fel a BitLockert (manage-bde -protectors -disable C: -rebootcount 2), vagy legyen kéznél a 48 jegyű "
+                "helyreállítási kulcs. Enélkül a Windows a következő indításkor ezt a kulcsot fogja kérni.",
+                "figyelem",
+                True,
+            )
+        )
+
+        leiras = Kartya("A beállítás lépései", terkoz=6)
+        leiras.elrendezes.addWidget(cimke("A Beállítás gomb egymás után:", "masodlagos"))
+        for i, szoveg in enumerate(LEPESEK_SZOVEG, 1):
+            sor = QHBoxLayout()
+            sor.setSpacing(10)
+            jel = cimke(f"{i}.", "monozold")
+            jel.setFixedWidth(22)
+            sor.addWidget(jel)
+            sor.addWidget(cimke(szoveg, "masodlagos", True), 1)
+            leiras.elrendezes.addLayout(sor)
+        leiras.elrendezes.addSpacing(6)
+        leiras.elrendezes.addWidget(
+            cimke(
+                "Ehhez a firmware-nek Setup Mode-ban kell lennie: a BIOS/UEFI beállításokban töröld a Secure Boot "
+                "kulcsokat (Clear Secure Boot keys / Reset to Setup Mode). Ha nincs Setup Mode-ban, a Center szól, "
+                "és újraindítás után a beállítás magától folytatódik.",
+                "halvany",
+                True,
+            )
+        )
+
+        leiras.setMinimumWidth(300)
+        leiras.setMaximumWidth(420)
+        jobb = QVBoxLayout()
+        jobb.addWidget(leiras)
+        jobb.addStretch(1)
+        oszlopok.addLayout(jobb, 2)
+
+        gombok = QHBoxLayout()
+        gombok.setSpacing(8)
+        self.frissit_gomb = gomb("Állapot frissítése")
+        self.frissit_gomb.clicked.connect(self.frissit)
+        self.ujra_gomb = gomb("Újra aláírás")
+        self.ujra_gomb.setToolTip("Ha a gépkulcs már megvan, csak újra aláírja a rendszerbetöltőt, a kernelt és a modulokat.")
+        self.ujra_gomb.clicked.connect(lambda: self._futtat("resign", "Újra aláírás"))
+        self.beallit_gomb = gomb("Beállítás", fo=True)
+        self.beallit_gomb.clicked.connect(self._beallit)
+        gombok.addWidget(self.frissit_gomb)
+        gombok.addStretch(1)
+        gombok.addWidget(self.ujra_gomb)
+        gombok.addWidget(self.beallit_gomb)
+        bal.addLayout(gombok)
+
+        bal.addWidget(cimke("NAPLÓ", "h2"))
+        self.naplo = QPlainTextEdit()
+        self.naplo.setObjectName("naplo")
+        self.naplo.setReadOnly(True)
+        self.naplo.setMinimumHeight(80)
+        bal.addWidget(self.naplo, 1)
+
+        self.futtato = muveletek.Futtato(self)
+        self.futtato.sor.connect(self.naplo.appendPlainText)
+        self.futtato.kesz.connect(self._kesz)
+        self.adat = {}
+
+    def megjelenik(self, *_):
+        self._betolt()
+
+    def frissit(self):
+        ervenytelenit("secureboot")
+        self._betolt()
+
+    def _betolt(self):
+        if tarolt("secureboot") is None:
+            for e in self.ertekek.values():
+                e.setText("...")
+        gyorsitott(
+            "secureboot", allapot_lekerdez, kesz=self._allapot,
+            hiba=lambda u: self._hiba(f"Az állapot nem olvasható: {u}"), kor=60,
+        )
+
+    def _hiba(self, szoveg):
+        self.figyelem.setText(szoveg)
+        self.figyelem.show()
+
+    def _allapot(self, adat):
+        self.adat = adat or {}
+        self.figyelem.hide()
+        if adat is None:
+            for e in self.ertekek.values():
+                e.setText("-")
+            self._hiba("A Secure Boot beállító (raveos-secureboot-setup) nincs telepítve.")
+            self._gombok(False)
+            return
+        if adat.get("uefi") == "0":
+            for e in self.ertekek.values():
+                e.setText("-")
+            self._hiba("Ez a gép nem UEFI módban indult, ezért a Secure Boot nem érhető el.")
+            self._gombok(False)
+            return
+        def ki(ertek, igen, nem):
+            return igen if ertek == "1" else nem if ertek == "0" else "?"
+        self._beir("secureboot", ki(adat.get("secureboot"), "BE", "KI"), adat.get("secureboot") == "1")
+        self._beir("setupmode", ki(adat.get("setupmode"), "IGEN", "NEM"), adat.get("setupmode") == "1")
+        self._beir("keys", ki(adat.get("keys"), "MEGVAN", "NINCS"), adat.get("keys") == "1")
+        self._beir("signed", ki(adat.get("signed"), "RENDBEN", "HIÁNYZIK"), adat.get("signed") == "1")
+        if adat.get("pending") == "1":
+            self._hiba("A beállítás félbemaradt, és a következő újraindításkor magától folytatódik.")
+        self._gombok(True)
+
+    def _beir(self, kulcs, szoveg, zold):
+        e = self.ertekek[kulcs]
+        e.setText(szoveg)
+        e.setProperty("zold", zold)
+        e.style().unpolish(e)
+        e.style().polish(e)
+
+    def _gombok(self, elerheto):
+        fut = self.futtato.fut()
+        helper = muveletek.helper_elerheto()
+        self.beallit_gomb.setEnabled(elerheto and helper and not fut)
+        self.ujra_gomb.setEnabled(elerheto and helper and not fut and self.adat.get("keys") == "1")
+        self.frissit_gomb.setEnabled(not fut)
+
+    def _beallit(self):
+        valasz = QMessageBox.question(
+            self,
+            "Secure Boot beállítása",
+            "A beállítás kulcsokat ír a firmware-be, és aláírja a rendszerbetöltőt és a kernelt. "
+            "Ha Windows is van a gépen BitLockerrel, előtte függeszd fel a BitLockert.\n\nFolytatod?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            QMessageBox.StandardButton.No,
+        )
+        if valasz == QMessageBox.StandardButton.Yes:
+            self._futtat("setup", "Secure Boot beállítása")
+
+    def _futtat(self, mod, cimke_szoveg):
+        self.naplo.clear()
+        self._gombok(False)
+        self.futtato.indit([muveletek.Lepes(cimke_szoveg, muveletek.root("secureboot", mod))])
+
+    def _bios_ujrainditas(self, cim, szoveg):
+        doboz = QMessageBox(self)
+        doboz.setWindowTitle(cim)
+        doboz.setText(szoveg)
+        most = doboz.addButton("Újraindítás a BIOS-ba", QMessageBox.ButtonRole.AcceptRole)
+        doboz.addButton("Később", QMessageBox.ButtonRole.RejectRole)
+        doboz.exec()
+        if doboz.clickedButton() is most:
+            muveletek.Futtato(self).indit(
+                [
+                    muveletek.Lepes(
+                        "Újraindítás a firmware beállításaiba",
+                        ["bash", "-c", "systemctl reboot --firmware-setup || systemctl reboot"],
+                    )
+                ]
+            )
+
+    def _kesz(self, rendben, _hibasak):
+        kod = self.futtato.utolso_kod
+        if rendben:
+            self._bios_ujrainditas(
+                "Secure Boot",
+                "Az aláírások és a kulcsok készen vannak.\n\nA BIOS-ban állítsd a Secure Bootot Enabled-re, "
+                "majd mentsd el a beállítást és indítsd újra a gépet.",
+            )
+        elif kod == UJRAINDITAS_KELL:
+            self._bios_ujrainditas(
+                "Újraindítás szükséges",
+                "A firmware nincs Setup Mode-ban.\n\nA BIOS-ban a Secure Boot menüben töröld a kulcsokat "
+                "(Key Management, Clear Secure Boot keys), így a gép Setup Mode-ba kerül. Mentés után indítsd újra "
+                "a gépet: a beállítás indítás után magától befejeződik.",
+            )
+        else:
+            QMessageBox.warning(self, "Secure Boot", "A művelet nem sikerült. A részleteket a napló mutatja.")
+        self.frissit()
+
+
+FUL = SecureBoot
diff --git a/raveos-center/raveos_center/oldalak/rendszer/snapshotok.py b/raveos-center/raveos_center/oldalak/rendszer/snapshotok.py
new file mode 100644
index 0000000..8d9b08c
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/rendszer/snapshotok.py
@@ -0,0 +1,247 @@
+from PyQt6.QtCore import QProcess, Qt
+from PyQt6.QtWidgets import QHBoxLayout, QInputDialog, QLineEdit, QMessageBox, QVBoxLayout, QWidget
+
+from raveos_center import muveletek, snapshotok
+from raveos_center.elemek import Kartya, cimke, gomb
+from raveos_center.folyamat import FolyamatAblak
+from raveos_center.hatter import ervenytelenit, gyorsitott, tarolt
+
+AZON = "snapshotok"
+CIM = "Snapshotok"
+
+
+class SnapshotSor(QWidget):
+    def __init__(self, elem, utolso, visszaallit, torol):
+        super().__init__()
+        self.setObjectName("appsor")
+        self.setProperty("utolso", utolso)
+        self.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+        sor = QHBoxLayout(self)
+        sor.setContentsMargins(16, 12, 16, 12)
+        sor.setSpacing(16)
+        datum = cimke(elem["datum"], "mono")
+        datum.setFixedWidth(150)
+        sor.addWidget(datum)
+        szovegek = QVBoxLayout()
+        szovegek.setSpacing(2)
+        szovegek.addWidget(cimke(elem["leiras"] or "-", None, True))
+        szovegek.addWidget(cimke(f"#{elem['szam']}  {elem['tipus_nev']}", "monohalvany"))
+        sor.addLayout(szovegek, 1)
+        helper = muveletek.helper_elerheto()
+        vissza = gomb("Visszaállítás", kicsi=True)
+        vissza.setEnabled(helper)
+        vissza.clicked.connect(lambda: visszaallit(elem))
+        sor.addWidget(vissza, 0, Qt.AlignmentFlag.AlignVCenter)
+        torles = gomb("Törlés", kicsi=True)
+        torles.setEnabled(helper)
+        torles.clicked.connect(lambda: torol(elem))
+        sor.addWidget(torles, 0, Qt.AlignmentFlag.AlignVCenter)
+
+
+class Snapshotok(QWidget):
+    def __init__(self, kozpont):
+        super().__init__()
+        self.kozpont = kozpont
+        self.adat = None
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 20, 0, 0)
+        doboz.setSpacing(16)
+        fej = QHBoxLayout()
+        fej.setSpacing(16)
+        self.leiras = cimke(
+            "A btrfs snapshot a rendszer egy pillanatnyi állapota. Ha egy frissítés után gond van, egy korábbi "
+            "állapotra vissza tudsz állni. A saját fájljaidat (/home) a visszaállítás nem érinti.",
+            "masodlagos",
+            True,
+        )
+        fej.addWidget(self.leiras, 1)
+        self.uj_gomb = gomb("Új snapshot", fo=True)
+        self.uj_gomb.clicked.connect(self.uj)
+        fej.addWidget(self.uj_gomb, 0, Qt.AlignmentFlag.AlignTop)
+        doboz.addLayout(fej)
+        self.info = cimke("", "monozold", True)
+        self.info.hide()
+        doboz.addWidget(self.info)
+        self.figyelem = cimke("", "figyelem", True)
+        self.figyelem.hide()
+        doboz.addWidget(self.figyelem)
+        self.beallitas_gomb = gomb("Snapper beállítása", fo=True)
+        self.beallitas_gomb.clicked.connect(self._beallitas)
+        self.beallitas_gomb.hide()
+        gs = QHBoxLayout()
+        gs.addWidget(self.beallitas_gomb)
+        gs.addStretch(1)
+        doboz.addLayout(gs)
+        self.kartya = Kartya(terkoz=0, margo=0)
+        doboz.addWidget(self.kartya)
+        doboz.addStretch(1)
+
+    def megjelenik(self, *args):
+        if tarolt("snapshotok") is None:
+            self.uj_gomb.setEnabled(False)
+            self._info("Betöltés...")
+        gyorsitott("snapshotok", snapshotok.allapot, kesz=self._kesz, hiba=self._hiba, kor=30)
+        if args and args[0] == "uj":
+            self.uj()
+
+    def frissit(self):
+        ervenytelenit("snapshotok", "snapshot")
+        gyorsitott("snapshotok", snapshotok.allapot, kesz=self._kesz, hiba=self._hiba)
+
+    def _hiba(self, uzenet):
+        self._figyelmeztet(f"A snapshotok nem olvashatók: {uzenet}")
+
+    def _info(self, szoveg):
+        self.info.setText(szoveg)
+        self.info.setVisible(bool(szoveg))
+
+    def _figyelmeztet(self, szoveg):
+        self.figyelem.setText(szoveg)
+        self.figyelem.setVisible(bool(szoveg))
+
+    def _kesz(self, adat):
+        self.adat = adat
+        helper = muveletek.helper_elerheto()
+        kesz = adat["fajlrendszer"] == "btrfs" and adat["snapper"]
+        self.uj_gomb.setVisible(kesz)
+        self.uj_gomb.setEnabled(kesz and helper)
+        self.beallitas_gomb.setVisible(snapshotok.snapper_telepitheto(adat))
+        self.beallitas_gomb.setEnabled(helper)
+        self.kartya.setVisible(kesz)
+        if adat["fajlrendszer"] != "btrfs":
+            self._info("")
+            self._figyelmeztet(
+                f"Snapshothoz btrfs fájlrendszer kell. Ez a gép {adat['fajlrendszer'] or 'ismeretlen'} fájlrendszert "
+                "használ, ezért itt nem érhető el. A RaveOS telepítésekor a lemez partícionálásánál ext4 és btrfs "
+                "közül lehet választani: ha snapshotot szeretnél, a btrfs-t válaszd."
+            )
+            return
+        if not adat["snapper"]:
+            self._info("")
+            if snapshotok.snapper_telepitheto(adat):
+                self._figyelmeztet(
+                    "A gép btrfs-t használ, de a snapper még nincs beállítva. Egy kattintással beállítható: "
+                    "utána minden csomagművelet előtt automatikusan snapshot készül."
+                )
+            else:
+                self._figyelmeztet(
+                    "A gép btrfs-t használ, de az alvolumen-elrendezése eltér a RaveOS-étól (@ és @snapshots), "
+                    "ezért a snapper itt nem állítható be automatikusan."
+                )
+            return
+        if adat["alvolumen"] != "/@":
+            self._figyelmeztet("A rendszer most nem a fő alvolumenről (@) fut, ezért visszaállítás nem indítható.")
+        elif adat["hiba"]:
+            self._figyelmeztet(adat["hiba"])
+        elif not helper:
+            self._figyelmeztet("A RaveOS Center rendszerhelpere nincs telepítve, ezért snapshot nem kezelhető.")
+        else:
+            self._figyelmeztet("")
+        self._info(
+            ("Automatikus snapshot minden csomagművelet előtt és után (snap-pac). " if adat["snap_pac"] else "")
+            + f"{len(adat['lista'])} snapshot, a régiek automatikusan törlődnek."
+        )
+        self._lista(adat)
+
+    def _lista(self, adat):
+        elrendezes = self.kartya.elrendezes
+        while elrendezes.count():
+            w = elrendezes.takeAt(0).widget()
+            if w:
+                w.deleteLater()
+        if not adat["lista"]:
+            ures = cimke("Még nincs snapshot.", "halvany")
+            ures.setContentsMargins(16, 16, 16, 16)
+            elrendezes.addWidget(ures)
+            return
+        for i, elem in enumerate(adat["lista"]):
+            elrendezes.addWidget(SnapshotSor(elem, i == len(adat["lista"]) - 1, self.visszaallit, self.torol))
+
+    def _futtat(self, cim, lepes, siker):
+        ablak = FolyamatAblak(self, cim, [lepes], siker)
+        ablak.exec()
+        self.frissit()
+        return ablak.rendben
+
+    def uj(self):
+        if not self.adat or not self.uj_gomb.isEnabled():
+            return
+        leiras, ok = QInputDialog.getText(
+            self, "Új snapshot", "Leírás (például: Driver csere előtt):", QLineEdit.EchoMode.Normal, "Kézi snapshot"
+        )
+        leiras = leiras.strip()
+        if not ok:
+            return
+        if not snapshotok.ervenyes_leiras(leiras):
+            QMessageBox.warning(self, "Új snapshot", "A leírás 1-80 karakter lehet: betűk, számok, szóköz és . _ : , ( ) -")
+            return
+        self._futtat("Új snapshot", muveletek.Lepes("Snapshot készítése", muveletek.root("snapshot", leiras)), "A snapshot elkészült.")
+
+    def torol(self, elem):
+        if QMessageBox.question(
+            self, "Snapshot törlése", f"Törlöd a(z) #{elem['szam']} snapshotot?\n{elem['datum']}  {elem['leiras']}"
+        ) != QMessageBox.StandardButton.Yes:
+            return
+        self._futtat(
+            "Snapshot törlése",
+            muveletek.Lepes("Snapshot törlése", muveletek.root("snapshot-torles", str(elem["szam"]))),
+            "A snapshot törölve.",
+        )
+
+    def visszaallit(self, elem):
+        kernelek = snapshotok.kernel_valtozas(elem["szam"])
+        ellenorizheto = kernelek is not None
+        kernelek = kernelek or []
+        hianyzo = [k for k in kernelek if not k["cache"]]
+        if hianyzo:
+            QMessageBox.warning(
+                self,
+                "Visszaállítás",
+                "Ennek a snapshotnak a kernelcsomagja már nincs meg a csomag-cache-ben "
+                f"({', '.join(k['nev'] + ' ' + k['regi'] for k in hianyzo)}), ezért a visszaállított rendszer nem "
+                "indulna el. Válassz újabb snapshotot.",
+            )
+            return
+        kernel_szoveg = "".join(f"\n- {k['nev']}: {k['most'] or 'nincs'} -> {k['regi']}" for k in kernelek)
+        szoveg = (
+            f"A rendszer visszaáll erre az állapotra:\n#{elem['szam']}  {elem['datum']}  {elem['leiras']}\n\n"
+            "A saját fájljaid (/home) nem változnak. A mostani rendszer a következő visszaállításig megmarad "
+            "tartalékként. A változás újraindítás után lép életbe."
+            + (f"\n\nA kernel is visszaáll:{kernel_szoveg}" if kernelek else "")
+            + ("" if ellenorizheto else "\n\nA snapshot kernelverziója innen nem olvasható, a visszaállítás előtt a rendszer "
+               "ellenőrzi, és ha a kernelcsomag hiányzik, nem végzi el.")
+            + "\n\nFolytatod?"
+        )
+        if QMessageBox.question(self, "Visszaállítás", szoveg) != QMessageBox.StandardButton.Yes:
+            return
+        rendben = self._futtat(
+            "Visszaállítás",
+            muveletek.Lepes("Snapshot visszaállítása", muveletek.root("snapshot-visszaallit", str(elem["szam"]))),
+            "A visszaállítás elkészült. Indítsd újra a gépet.",
+        )
+        if not rendben:
+            return
+        doboz = QMessageBox(self)
+        doboz.setWindowTitle("Visszaállítás")
+        doboz.setIcon(QMessageBox.Icon.Warning)
+        doboz.setText(
+            "A visszaállítás újraindítás után lép életbe. Amit addig a gépen változtatsz (telepítés, beállítás, "
+            "rendszerfájlok), az a tartalék rendszerbe kerül, és elvész. A /home-ban lévő fájljaid megmaradnak.\n\n"
+            "Javasolt most újraindítani."
+        )
+        most = doboz.addButton("Újraindítás most", QMessageBox.ButtonRole.AcceptRole)
+        doboz.addButton("Később", QMessageBox.ButtonRole.RejectRole)
+        doboz.setDefaultButton(most)
+        doboz.exec()
+        if doboz.clickedButton() is most:
+            QProcess.startDetached("systemctl", ["reboot"])
+
+    def _beallitas(self):
+        self._futtat(
+            "Snapper beállítása",
+            muveletek.Lepes("Snapper beállítása", muveletek.root("snapper-beallitas")),
+            "A snapper beállítva, az első snapshot elkészült.",
+        )
+
+
+FUL = Snapshotok
diff --git a/raveos-center/raveos_center/oldalak/visszajelzes.py b/raveos-center/raveos_center/oldalak/visszajelzes.py
new file mode 100644
index 0000000..56664ab
--- /dev/null
+++ b/raveos-center/raveos_center/oldalak/visszajelzes.py
@@ -0,0 +1,887 @@
+from datetime import datetime
+
+from PyQt6.QtCore import Qt, QTimer
+from PyQt6.QtGui import QTextCursor
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QDialog,
+    QHBoxLayout,
+    QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QPlainTextEdit,
+    QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+)
+
+from raveos_center import beallitasok, diagnosztika, jegyek_api
+from raveos_center.elemek import Csillagok, Fulsor, Kartya, Oldal, Verem, cimke, gomb
+from raveos_center.hatter import gyorsitott, hatterben
+
+AZON = "visszajelzes"
+MENU = "Visszajelzés"
+IKON = "visszajelzes"
+
+ALLAPOT = {
+    "uj": ("Beküldve", ""),
+    "folyamatban": ("Folyamatban", "sarga"),
+    "tervezett": ("Tervezett", "sarga"),
+    "megoldva": ("Megoldva", "zold"),
+    "kesz": ("Elkészült", "zold"),
+    "lezarva": ("Lezárva", ""),
+    "elutasitva": ("Elutasítva", ""),
+}
+
+
+def ido(t):
+    return datetime.fromtimestamp(t).strftime("%Y.%m.%d %H:%M")
+
+
+def allapotcimke(allapot):
+    szoveg, szin = ALLAPOT.get(allapot, (allapot, ""))
+    c = cimke(szoveg.upper(), "allapotcimke")
+    if szin:
+        c.setProperty("szin", szin)
+    return c
+
+
+def uzenetsav(uzenet):
+    sav = cimke(uzenet, "figyelem", True)
+    sav.hide()
+    return sav
+
+
+class JegySor(QWidget):
+    def __init__(self, jegy):
+        super().__init__()
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(14, 12, 14, 12)
+        doboz.setSpacing(6)
+        felso = QHBoxLayout()
+        felso.setSpacing(8)
+        tipus = "HIBA" if jegy["tipus"] == "hiba" else "ÖTLET"
+        felso.addWidget(cimke(tipus, "monozold"))
+        felso.addStretch(1)
+        if jegy["uj_valasz"]:
+            felso.addWidget(cimke("ÚJ VÁLASZ", "jelveny"))
+        felso.addWidget(allapotcimke(jegy["allapot"]))
+        doboz.addLayout(felso)
+        cim = cimke(jegy["cim"])
+        cim.setStyleSheet("font-weight: 600;")
+        cim.setText(cim.fontMetrics().elidedText(jegy["cim"], Qt.TextElideMode.ElideRight, 300))
+        cim.setToolTip(jegy["cim"])
+        doboz.addWidget(cim)
+        doboz.addWidget(cimke(ido(jegy["frissitve"]), "halvany"))
+        for w in self.findChildren(QWidget):
+            w.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents)
+
+
+class Uzenet(QWidget):
+    def __init__(self, uzenet):
+        super().__init__()
+        self.setObjectName("uzenet")
+        self.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+        csapat = uzenet["szerzo"] == "admin"
+        self.setProperty("csapat", csapat)
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(14, 12, 14, 12)
+        doboz.setSpacing(6)
+        ki = "RaveOS csapat" if csapat else "Te"
+        doboz.addWidget(cimke(f"{ki} · {ido(uzenet['ido'])}", "halvany"))
+        szoveg = cimke(uzenet["szoveg"], tordel=True)
+        szoveg.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        doboz.addWidget(szoveg)
+
+
+class JelentesAblak(QDialog):
+    def __init__(self, szulo, szoveg):
+        super().__init__(szulo)
+        self.setWindowTitle("A csatolt diagnosztika tartalma")
+        self.resize(820, 600)
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(20, 20, 20, 20)
+        doboz.setSpacing(12)
+        doboz.addWidget(cimke("Pontosan ez kerül feltöltésre, ha bejelölöd a csatolást:", "masodlagos"))
+        mezo = QPlainTextEdit(szoveg)
+        mezo.setReadOnly(True)
+        mezo.setObjectName("mono")
+        doboz.addWidget(mezo, 1)
+        bezar = gomb("Bezárás", fo=True)
+        bezar.clicked.connect(self.accept)
+        doboz.addWidget(bezar, 0, Qt.AlignmentFlag.AlignRight)
+
+
+class Urlap(QWidget):
+    def __init__(self, oldal):
+        super().__init__()
+        self.oldal = oldal
+        self.tipus = "hiba"
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 0, 0, 0)
+        doboz.setSpacing(12)
+        self.cim = cimke("", "h2")
+        doboz.addWidget(self.cim)
+        self.leiras = cimke("", "masodlagos", True)
+        doboz.addWidget(self.leiras)
+        doboz.addWidget(cimke("Cím", "kartyacim"))
+        self.cim_mezo = QLineEdit()
+        self.cim_mezo.setMaxLength(120)
+        doboz.addWidget(self.cim_mezo)
+        doboz.addWidget(cimke("Leírás", "kartyacim"))
+        self.szoveg_mezo = QPlainTextEdit()
+        self.szoveg_mezo.setMinimumHeight(160)
+        doboz.addWidget(self.szoveg_mezo)
+
+        self.diag = Kartya(terkoz=8, margo=16)
+        self.diag_jelolo = QCheckBox("Diagnosztika csatolása (ajánlott, segít megtalálni a hibát)")
+        self.diag.elrendezes.addWidget(self.diag_jelolo)
+        lista = "\n".join(f"  - {t}" for t in diagnosztika.TARTALOM)
+        self.diag.elrendezes.addWidget(
+            cimke(
+                f"Ha bejelölöd, egy jelentést is csatolunk a gépedről:\n{lista}\n\n"
+                f"Feltöltés előtt kitakarjuk: {diagnosztika.KITAKARAS}. Jelszó nem kerül bele. "
+                "Titkosított kapcsolaton megy el, csak a RaveOS fejlesztői látják, és 30 nap után törlődik.",
+                "halvany",
+                True,
+            )
+        )
+        self.megnez = gomb("Megnézem, mi kerül bele", kicsi=True)
+        self.megnez.clicked.connect(self._megnez)
+        self.diag.elrendezes.addWidget(self.megnez, 0, Qt.AlignmentFlag.AlignLeft)
+        doboz.addWidget(self.diag)
+
+        doboz.addWidget(
+            cimke(
+                "A jegyhez mindig csatoljuk a RaveOS-verziót, a kernelt, az asztali környezetet és a videokártya nevét.",
+                "halvany",
+                True,
+            )
+        )
+        self.hiba = uzenetsav("")
+        doboz.addWidget(self.hiba)
+        gombok = QHBoxLayout()
+        gombok.addStretch(1)
+        self.megse = gomb("Mégse")
+        self.megse.clicked.connect(self.oldal.urlap_bezar)
+        self.kuld = gomb("Beküldés", fo=True)
+        self.kuld.clicked.connect(self._kuld)
+        gombok.addWidget(self.megse)
+        gombok.addWidget(self.kuld)
+        doboz.addLayout(gombok)
+        doboz.addStretch(1)
+
+    def nyit(self, tipus):
+        self.tipus = tipus
+        self.cim_mezo.clear()
+        self.szoveg_mezo.clear()
+        self.diag_jelolo.setChecked(False)
+        self.hiba.hide()
+        self.kuld.setEnabled(True)
+        if tipus == "hiba":
+            self.cim.setText("ÚJ HIBAJEGY")
+            self.leiras.setText("Írd le, mi történt, és mit csináltál előtte. Ha válaszolunk, itt fogod látni.")
+            self.cim_mezo.setPlaceholderText("Például: Nem indul a Steam a frissítés után")
+            self.szoveg_mezo.setPlaceholderText("Mi a hiba, mikor jelentkezik, mit próbáltál már?")
+            self.diag.show()
+        else:
+            self.cim.setText("ÚJ ÖTLET")
+            self.leiras.setText(
+                "Mi hiányzik a RaveOS-ből? Az ötleted a jóváhagyásunk után jelenik meg a közös listában, "
+                "ahol mások is támogathatják."
+            )
+            self.cim_mezo.setPlaceholderText("Például: Sötét és világos téma váltó")
+            self.szoveg_mezo.setPlaceholderText("Mit szeretnél, és miért lenne hasznos?")
+            self.diag.hide()
+        self.cim_mezo.setFocus()
+
+    def _megnez(self):
+        self.megnez.setEnabled(False)
+        self.megnez.setText("Összeállítás...")
+
+        def kesz(szoveg):
+            self.megnez.setEnabled(True)
+            self.megnez.setText("Megnézem, mi kerül bele")
+            JelentesAblak(self, szoveg).exec()
+
+        hatterben(diagnosztika.jelentes, kesz=kesz)
+
+    def _kuld(self):
+        cim = self.cim_mezo.text().strip()
+        szoveg = self.szoveg_mezo.toPlainText().strip()
+        if len(cim) < 3 or len(szoveg) < 10:
+            self.hiba.setText("Adj meg egy legalább 3 karakteres címet és egy legalább 10 karakteres leírást.")
+            self.hiba.show()
+            return
+        self.hiba.hide()
+        self.kuld.setEnabled(False)
+        self.kuld.setText("Küldés...")
+        csatol = self.tipus == "hiba" and self.diag_jelolo.isChecked()
+        tipus = self.tipus
+
+        def munka():
+            naplo = jegyek_api.naplo_feltolt(diagnosztika.jelentes()) if csatol else None
+            return jegyek_api.uj_jegy(tipus, cim, szoveg, diagnosztika.rendszer_osszegzes(), naplo)
+
+        hatterben(munka, kesz=self._kuldve, hiba=self._kuldes_hiba)
+
+    def _kuldve(self, jegy):
+        self.kuld.setText("Beküldés")
+        self.oldal.bekuldve(jegy)
+
+    def _kuldes_hiba(self, uzenet):
+        self.kuld.setEnabled(True)
+        self.kuld.setText("Beküldés")
+        self.hiba.setText(jegyek_api.HIBAUZENETEK.get(uzenet, f"A beküldés nem sikerült: {uzenet}"))
+        self.hiba.show()
+
+
+class Reszletek(QWidget):
+    def __init__(self, oldal):
+        super().__init__()
+        self.oldal = oldal
+        self.jegy_id = None
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 0, 0, 0)
+        doboz.setSpacing(12)
+        self.cim = cimke("", "h2", True)
+        doboz.addWidget(self.cim)
+        self.meta = QHBoxLayout()
+        self.meta.setSpacing(10)
+        doboz.addLayout(self.meta)
+        self.lezart = uzenetsav("")
+        doboz.addWidget(self.lezart)
+        gorgeto = QScrollArea()
+        gorgeto.setWidgetResizable(True)
+        self.szal_doboz = QWidget()
+        self.szal = QVBoxLayout(self.szal_doboz)
+        self.szal.setContentsMargins(0, 0, 8, 0)
+        self.szal.setSpacing(10)
+        gorgeto.setWidget(self.szal_doboz)
+        self.gorgeto = gorgeto
+        doboz.addWidget(gorgeto, 1)
+        self.valasz_doboz = QWidget()
+        vd = QVBoxLayout(self.valasz_doboz)
+        vd.setContentsMargins(0, 0, 0, 0)
+        vd.setSpacing(8)
+        self.valasz_mezo = QPlainTextEdit()
+        self.valasz_mezo.setPlaceholderText("Válasz a RaveOS csapatnak")
+        self.valasz_mezo.setFixedHeight(96)
+        vd.addWidget(self.valasz_mezo)
+        self.hiba = uzenetsav("")
+        vd.addWidget(self.hiba)
+        sor = QHBoxLayout()
+        sor.addStretch(1)
+        self.kuld = gomb("Válasz küldése", fo=True)
+        self.kuld.clicked.connect(self._kuld)
+        sor.addWidget(self.kuld)
+        vd.addLayout(sor)
+        doboz.addWidget(self.valasz_doboz)
+
+    def betolt(self, jegy):
+        self.jegy_id = jegy["id"]
+        self.cim.setText(jegy["cim"])
+        while self.meta.count():
+            w = self.meta.takeAt(0).widget()
+            if w:
+                w.deleteLater()
+        self.meta.addWidget(cimke("HIBAJEGY" if jegy["tipus"] == "hiba" else "ÖTLET", "monozold"))
+        self.meta.addWidget(allapotcimke(jegy["allapot"]))
+        self.meta.addWidget(cimke(f"#{jegy['id']} · {ido(jegy['letrehozva'])}", "halvany"))
+        if jegy["tipus"] == "otlet":
+            self.meta.addWidget(cimke("nyilvános" if jegy["nyilvanos"] else "jóváhagyásra vár", "halvany"))
+        self.meta.addStretch(1)
+        if jegy.get("torles"):
+            self.lezart.setText(
+                f"Ez a jegy le van zárva, és {ido(jegy['torles'])} után automatikusan törlődik. "
+                "Ha a hiba újra jelentkezik, nyiss új jegyet."
+            )
+            self.lezart.show()
+            self.valasz_doboz.hide()
+        else:
+            self.lezart.hide()
+            self.valasz_doboz.show()
+        while self.szal.count():
+            w = self.szal.takeAt(0).widget()
+            if w:
+                w.deleteLater()
+        for u in jegy.get("uzenetek", []):
+            self.szal.addWidget(Uzenet(u))
+        self.szal.addStretch(1)
+        self.hiba.hide()
+        self.valasz_mezo.clear()
+
+    def _kuld(self):
+        szoveg = self.valasz_mezo.toPlainText().strip()
+        if not szoveg:
+            return
+        self.kuld.setEnabled(False)
+        jegy_id = self.jegy_id
+
+        def munka():
+            jegyek_api.valasz(jegy_id, szoveg)
+            return jegyek_api.jegy(jegy_id)
+
+        def kesz(jegy):
+            self.kuld.setEnabled(True)
+            self.betolt(jegy)
+            self.oldal.lista_frissit()
+
+        def hiba(uzenet):
+            self.kuld.setEnabled(True)
+            if uzenet == "nincs_jegy":
+                self.oldal.jegy_eltunt()
+                return
+            self.hiba.setText(jegyek_api.HIBAUZENETEK.get(uzenet, f"A küldés nem sikerült: {uzenet}"))
+            self.hiba.show()
+
+        hatterben(munka, kesz=kesz, hiba=hiba)
+
+
+class ErtekelesLap(QWidget):
+    SZINTEK = {1: "Nagyon rossz", 2: "Rossz", 3: "Elmegy", 4: "Jó", 5: "Kiváló"}
+    MAX = 500
+
+    def __init__(self, oldal):
+        super().__init__()
+        self.oldal = oldal
+        self.mentett = None
+        self.szerkesztve = False
+        self.kuldes = False
+        doboz = QVBoxLayout(self)
+        doboz.setContentsMargins(0, 0, 12, 0)
+        doboz.setSpacing(16)
+
+        osszesito = Kartya("A RaveOS értékelése", terkoz=8, margo=20)
+        sor = QHBoxLayout()
+        sor.setSpacing(16)
+        self.atlag = cimke("-", "nagyszam")
+        sor.addWidget(self.atlag)
+        jobb = QVBoxLayout()
+        jobb.setSpacing(4)
+        self.atlag_csillag = Csillagok(24)
+        jobb.addWidget(self.atlag_csillag)
+        self.darab = cimke("", "halvany")
+        jobb.addWidget(self.darab)
+        sor.addLayout(jobb)
+        sor.addStretch(1)
+        osszesito.elrendezes.addLayout(sor)
+        doboz.addWidget(osszesito)
+
+        sajat = Kartya("A te értékelésed", terkoz=10, margo=20)
+        valaszto = QHBoxLayout()
+        valaszto.setSpacing(14)
+        self.csillagok = Csillagok(34, valaszthato=True)
+        self.csillagok.valasztva.connect(self._valasztva)
+        valaszto.addWidget(self.csillagok)
+        self.szint = cimke("Kattints a csillagokra", "masodlagos")
+        valaszto.addWidget(self.szint)
+        valaszto.addStretch(1)
+        sajat.elrendezes.addLayout(valaszto)
+        self.szoveg = QPlainTextEdit()
+        self.szoveg.setPlaceholderText("Röviden: mi tetszik, mi nem? (nem kötelező)")
+        self.szoveg.setFixedHeight(96)
+        self.szoveg.textChanged.connect(self._szoveg_valtozott)
+        sajat.elrendezes.addWidget(self.szoveg)
+        self.szamlalo = cimke(f"0 / {self.MAX}", "monohalvany")
+        sajat.elrendezes.addWidget(self.szamlalo, 0, Qt.AlignmentFlag.AlignRight)
+        sajat.elrendezes.addWidget(
+            cimke(
+                "A szöveges véleményt csak a RaveOS fejlesztői látják, nyilvánosan csak a csillagok átlaga jelenik meg. "
+                "Gépenként egy értékelés számít, bármikor módosíthatod.",
+                "halvany",
+                True,
+            )
+        )
+        self.hiba = uzenetsav("")
+        sajat.elrendezes.addWidget(self.hiba)
+        gombok = QHBoxLayout()
+        self.allapot = cimke("", "monozold")
+        gombok.addWidget(self.allapot)
+        gombok.addStretch(1)
+        self.kuld = gomb("Értékelés küldése", fo=True)
+        self.kuld.setEnabled(False)
+        self.kuld.clicked.connect(self._kuld)
+        gombok.addWidget(self.kuld)
+        sajat.elrendezes.addLayout(gombok)
+        doboz.addWidget(sajat)
+        doboz.addStretch(1)
+
+    def betolt(self, adat):
+        self.atlag.setText(f"{adat['atlag']:.1f}".replace(".", ",") if adat["darab"] else "-")
+        self.atlag_csillag.beallit(adat["atlag"])
+        self.darab.setText(
+            f"{adat['darab']} értékelés alapján" if adat["darab"] else "Még nincs értékelés. Legyél te az első!"
+        )
+        sajat = adat.get("sajat")
+        if sajat == self.mentett:
+            return
+        self.mentett = sajat
+        self.allapot.setText(f"ELKÜLDVE: {ido(sajat['ido'])}" if sajat else "")
+        if not self.szerkesztve:
+            self.csillagok.beallit(sajat["csillag"] if sajat else 0)
+            self.szint.setText(self.SZINTEK[sajat["csillag"]] if sajat else "Kattints a csillagokra")
+            self.szoveg.blockSignals(True)
+            self.szoveg.setPlainText(sajat["szoveg"] if sajat else "")
+            self.szoveg.blockSignals(False)
+            self.szamlalo.setText(f"{len(self.szoveg.toPlainText())} / {self.MAX}")
+        self._gomb_frissit()
+
+    def _valasztva(self, csillag):
+        self.szerkesztve = True
+        self.szint.setText(self.SZINTEK[csillag])
+        self._gomb_frissit()
+
+    def _szoveg_valtozott(self):
+        self.szerkesztve = True
+        szoveg = self.szoveg.toPlainText()
+        if len(szoveg) > self.MAX:
+            self.szoveg.blockSignals(True)
+            self.szoveg.setPlainText(szoveg[: self.MAX])
+            self.szoveg.moveCursor(QTextCursor.MoveOperation.End)
+            self.szoveg.blockSignals(False)
+            szoveg = szoveg[: self.MAX]
+        self.szamlalo.setText(f"{len(szoveg)} / {self.MAX}")
+        self._gomb_frissit()
+
+    def _valtozott(self):
+        if not self.mentett:
+            return True
+        return int(self.csillagok.ertek) != self.mentett["csillag"] or (
+            self.szoveg.toPlainText().strip() != self.mentett["szoveg"]
+        )
+
+    def _gomb_frissit(self):
+        self.kuld.setText("Értékelés módosítása" if self.mentett else "Értékelés küldése")
+        szabad = self.oldal.szabad() and not self.kuldes
+        self.csillagok.setEnabled(szabad)
+        self.szoveg.setEnabled(szabad)
+        self.kuld.setEnabled(szabad and self.csillagok.ertek >= 1 and self._valtozott())
+
+    def _kuld(self):
+        csillag = int(self.csillagok.ertek)
+        szoveg = self.szoveg.toPlainText().strip()
+        self.hiba.hide()
+        self.kuldes = True
+        self._gomb_frissit()
+        self.kuld.setText("Küldés...")
+
+        def kesz(adat):
+            self.kuldes = False
+            self.szerkesztve = False
+            self.mentett = None
+            self.betolt(adat)
+            self.allapot.setText("KÖSZÖNJÜK, ELMENTETTÜK")
+
+        def hiba(uzenet):
+            self.kuldes = False
+            self.hiba.setText(jegyek_api.HIBAUZENETEK.get(uzenet, f"A küldés nem sikerült: {uzenet}"))
+            self.hiba.show()
+            self._gomb_frissit()
+
+        hatterben(jegyek_api.ertekel, csillag, szoveg, kesz=kesz, hiba=hiba)
+
+
+ELFOGADAS_VERZIO = 3
+
+ISMERTETO = [
+    ("Mire jó?", "", [
+        "Itt közvetlenül a RaveOS fejlesztőinek jelezhetsz hibát, és küldhetsz ötletet. "
+        "Minden jegyet elolvasunk, és itt, a Centerben válaszolunk.",
+    ]),
+    ("Hogyan működik?", "szam", [
+        "Hibajegy: írd le, mi történt. Ha bejelölöd, a géped diagnosztikáját is csatoljuk, ami sokat segít; "
+        "előtte megnézheted, mi kerül bele.",
+        "Válasz: ha válaszolunk, a Visszajelzés menüpont mellett szám jelenik meg, és a jegyben vissza is írhatsz.",
+        "Ötlet: a jóváhagyott ötletek felkerülnek a közös listára, ahol mások is támogathatják. "
+        "A legtöbbet támogatottakkal foglalkozunk először.",
+        "Értékelés: 1-5 csillaggal értékelheted a RaveOS-t, és röviden leírhatod a véleményed. A szöveget csak "
+        "a fejlesztők látják, a többiek csak a csillagok átlagát. Gépenként egy értékelés számít, bármikor "
+        "módosíthatod.",
+    ]),
+    ("Miért így?", "szam", [
+        "Nem kell fiók: a géped egy névtelen azonosítót kap, ezzel látod a saját jegyeidet. "
+        "Újratelepítés után a régi jegyeid nem látszanak.",
+        "Csak azt küldjük el, amit beírsz, vagy amihez hozzájárulsz. A diagnosztikából kitakarjuk a személyes "
+        "adatokat, és 30 nap után törlődik.",
+        "A lezárt jegyek 7 nap után maguktól törlődnek.",
+    ]),
+    ("Szabályok", "szam", [
+        "A Visszajelzés csak hibák jelzésére és ötletek beküldésére való.",
+        "Egy hibáról egy jegyet nyiss. Ha már van róla jegyed, abba írj, ne nyiss újat.",
+        "Ötlet beküldése előtt nézd meg az Ötletek listát. Ha van hasonló, támogasd azt, ne küldj újat.",
+        "Ne írj a jegybe vagy az értékelésbe személyes vagy titkos adatot: jelszót, e-mail-címet, telefonszámot vagy más emberek "
+        "adatait. A diagnosztikát kitakarjuk, a beírt szöveget nem.",
+        "Kulturált hangnemet kérünk. Sértő, fenyegető vagy trágár üzenet tiltással jár.",
+        "Reklámot és nem ide illő linkeket ne küldj.",
+        "A jegyekre nem azonnal válaszolunk, ezért kérünk, légy türelmes, és ne küldd el többször ugyanazt.",
+        "Visszaélés, spam, sértő vagy nem ide illő tartalom esetén a géped kitiltható a Visszajelzésből, "
+        "ideiglenesen vagy véglegesen. A Center minden más része ettől ugyanúgy működik.",
+        "Két óránként legfeljebb 4 jegyet küldhetsz. Ennél több beküldés automatikusan 24 órás tiltással jár.",
+    ]),
+]
+
+HOZZAJARULAS = (
+    "Az Elfogadom gombbal elfogadod a fenti szabályokat, és hozzájárulsz, hogy a beírt szöveget, a géped "
+    "alapadatait (RaveOS-verzió, kernel, asztali környezet, videokártya) és, ha bejelölöd, a diagnosztikát "
+    "elküldjük a RaveOS fejlesztőinek."
+)
+
+
+class IsmertetoAblak(QDialog):
+    def __init__(self, szulo, elfogadva):
+        super().__init__(szulo)
+        self.setWindowTitle("Visszajelzés")
+        kepernyo = szulo.screen().availableGeometry() if szulo and szulo.screen() else None
+        magassag = min(860, kepernyo.height() - 80) if kepernyo else 760
+        self.resize(700, magassag)
+        kulso = QVBoxLayout(self)
+        kulso.setContentsMargins(0, 0, 0, 20)
+        kulso.setSpacing(12)
+        gorgeto = QScrollArea()
+        gorgeto.setWidgetResizable(True)
+        tartalom = QWidget()
+        gorgeto.setWidget(tartalom)
+        kulso.addWidget(gorgeto, 1)
+        doboz = QVBoxLayout(tartalom)
+        doboz.setContentsMargins(32, 28, 32, 8)
+        doboz.setSpacing(12)
+        doboz.addWidget(cimke("ISMERTETŐ ÉS SZABÁLYOK", "eyebrow"))
+        doboz.addWidget(cimke("HOGYAN MŰKÖDIK A VISSZAJELZÉS?", "h2", True))
+        sorszam = 0
+        for cim, jeloles, pontok in ISMERTETO:
+            doboz.addSpacing(4)
+            fejlec = cimke(cim)
+            fejlec.setStyleSheet("font-size: 15px; font-weight: 600;")
+            doboz.addWidget(fejlec)
+            for pont in pontok:
+                if not jeloles:
+                    doboz.addWidget(cimke(pont, "masodlagos", True))
+                    continue
+                sorszam += 1
+                sor = QHBoxLayout()
+                sor.setSpacing(10)
+                jel = cimke(f"{sorszam}.", "monozold")
+                jel.setFixedWidth(26)
+                sor.addWidget(jel, 0, Qt.AlignmentFlag.AlignTop)
+                sor.addWidget(cimke(pont, "masodlagos", True), 1)
+                doboz.addLayout(sor)
+        doboz.addStretch(1)
+        also = QVBoxLayout()
+        also.setContentsMargins(32, 0, 32, 0)
+        also.setSpacing(12)
+        kulso.addLayout(also)
+        gombok = QHBoxLayout()
+        gombok.addStretch(1)
+        if elfogadva:
+            also.addWidget(cimke("A szabályokat már elfogadtad.", "halvany"))
+            ok = gomb("Bezárás", fo=True)
+            ok.clicked.connect(self.accept)
+            gombok.addWidget(ok)
+        else:
+            also.addWidget(cimke(HOZZAJARULAS, "figyelem", True))
+            nem = gomb("Most nem")
+            nem.clicked.connect(self.reject)
+            igen = gomb("Elfogadom", fo=True)
+            igen.clicked.connect(self.accept)
+            gombok.addWidget(nem)
+            gombok.addWidget(igen)
+        also.addLayout(gombok)
+
+
+class OtletKartya(Kartya):
+    def __init__(self, otlet, szavaz):
+        super().__init__(terkoz=8, margo=18)
+        felso = QHBoxLayout()
+        cim = cimke(otlet["cim"], tordel=True)
+        cim.setStyleSheet("font-size: 15px; font-weight: 600;")
+        felso.addWidget(cim, 1)
+        felso.addWidget(allapotcimke(otlet["allapot"]), 0, Qt.AlignmentFlag.AlignTop)
+        self.elrendezes.addLayout(felso)
+        self.elrendezes.addWidget(cimke(otlet.get("leiras") or "", "masodlagos", True))
+        also = QHBoxLayout()
+        also.addWidget(cimke(f"{otlet['szavazat']} támogató", "monohalvany"))
+        if otlet.get("sajat"):
+            also.addWidget(cimke("· a te ötleted", "monohalvany"))
+        also.addStretch(1)
+        tamogatva = otlet["sajat_szavazat"]
+        g = gomb("Támogatva" if tamogatva else "Támogatom", fo=not tamogatva, kicsi=True)
+        g.clicked.connect(lambda: szavaz(otlet["id"], not tamogatva, g))
+        also.addWidget(g)
+        self.elrendezes.addLayout(also)
+
+
+class Visszajelzes(Oldal):
+    def __init__(self, kozpont):
+        super().__init__(kozpont, "HIBÁK ÉS ÖTLETEK", "Visszajelzés", kitolt=True)
+        self.uj_hiba = self.fejlec_gomb(gomb("Új hibajegy", fo=True))
+        self.uj_hiba.clicked.connect(lambda: self.urlap_nyit("hiba"))
+        self.uj_otlet = self.fejlec_gomb(gomb("Új ötlet"))
+        self.uj_otlet.clicked.connect(lambda: self.urlap_nyit("otlet"))
+        sugo = self.fejlec_gomb(gomb("Hogyan működik?"))
+        sugo.clicked.connect(self.ismerteto)
+
+        self.elfogadas_sav = QWidget()
+        es = QHBoxLayout(self.elfogadas_sav)
+        es.setContentsMargins(0, 0, 0, 0)
+        es.setSpacing(12)
+        es.addWidget(cimke("A Visszajelzés használatához el kell fogadnod a szabályokat.", "figyelem", True), 1)
+        elolvas = gomb("Szabályok elolvasása", fo=True)
+        elolvas.clicked.connect(self.ismerteto)
+        es.addWidget(elolvas)
+        self.elfogadas_sav.hide()
+        self.torzs.addWidget(self.elfogadas_sav)
+        self.tiltas_sav = cimke("", "figyelem", True)
+        self.tiltas_sav.hide()
+        self.torzs.addWidget(self.tiltas_sav)
+        self.kitiltva = False
+        self.fulsor = Fulsor([("jegyeim", "Jegyeim"), ("otletek", "Ötletek"), ("ertekeles", "Értékelés")], self.ful)
+        self.torzs.addWidget(self.fulsor)
+        self.hiba = uzenetsav("")
+        self.torzs.addWidget(self.hiba)
+        self.fulek = Verem()
+        self.torzs.addWidget(self.fulek, 1)
+        self.tolto = QWidget()
+        self.tolto.hide()
+        self.torzs.addWidget(self.tolto, 1)
+
+        jegyeim = QWidget()
+        sor = QHBoxLayout(jegyeim)
+        sor.setContentsMargins(0, 0, 0, 0)
+        sor.setSpacing(24)
+        bal = QVBoxLayout()
+        bal.setSpacing(8)
+        self.lista = QListWidget()
+        self.lista.setFixedWidth(340)
+        self.lista.setMinimumHeight(160)
+        self.lista.setVerticalScrollMode(QListWidget.ScrollMode.ScrollPerPixel)
+        self.lista.currentItemChanged.connect(self._kivalaszt)
+        bal.addWidget(self.lista, 1)
+        sor.addLayout(bal)
+        self.jobb = Verem()
+        self.ures = QWidget()
+        ud = QVBoxLayout(self.ures)
+        ud.setContentsMargins(0, 0, 0, 0)
+        self.ures_szoveg = cimke("", "masodlagos", True)
+        ud.addWidget(self.ures_szoveg)
+        ud.addStretch(1)
+        self.reszletek = Reszletek(self)
+        self.urlap = Urlap(self)
+        self.urlap_gorgeto = QScrollArea()
+        self.urlap_gorgeto.setWidgetResizable(True)
+        self.urlap_gorgeto.setWidget(self.urlap)
+        self.urlap.setContentsMargins(0, 0, 12, 0)
+        for w in (self.ures, self.reszletek, self.urlap_gorgeto):
+            self.jobb.addWidget(w)
+        sor.addWidget(self.jobb, 1)
+        self.fulek.addWidget(jegyeim)
+
+        otletek_gorgeto = QScrollArea()
+        otletek_gorgeto.setWidgetResizable(True)
+        otletek = QWidget()
+        otletek_gorgeto.setWidget(otletek)
+        od = QVBoxLayout(otletek)
+        od.setContentsMargins(0, 0, 12, 0)
+        od.setSpacing(12)
+        od.addWidget(
+            cimke(
+                "Mások ötletei, amelyeket jóváhagytunk. Támogasd, amit te is szeretnél, így látjuk, mi a legfontosabb.",
+                "masodlagos",
+                True,
+            )
+        )
+        self.otlet_doboz = QVBoxLayout()
+        self.otlet_doboz.setSpacing(12)
+        od.addLayout(self.otlet_doboz)
+        od.addStretch(1)
+        self.fulek.addWidget(otletek_gorgeto)
+        ertekeles_gorgeto = QScrollArea()
+        ertekeles_gorgeto.setWidgetResizable(True)
+        self.ertekeles_lap = ErtekelesLap(self)
+        ertekeles_gorgeto.setWidget(self.ertekeles_lap)
+        self.fulek.addWidget(ertekeles_gorgeto)
+        self.jegyek = []
+        self.lista_betoltve = False
+        self.ful("jegyeim")
+
+    def indulaskor(self):
+        hatterben(jegyek_api.jegyeim, kesz=self._jelveny_frissit)
+
+    def elfogadva(self):
+        return (beallitasok.ertek("visszajelzes_elfogadva", 0) or 0) >= ELFOGADAS_VERZIO
+
+    def szabad(self):
+        return self.elfogadva() and not self.kitiltva
+
+    def ismerteto(self):
+        if IsmertetoAblak(self, self.elfogadva()).exec() and not self.elfogadva():
+            beallitasok.beallit("visszajelzes_elfogadva", ELFOGADAS_VERZIO)
+        self._allapot_frissit()
+
+    def _allapot_frissit(self):
+        self.elfogadas_sav.setVisible(not self.elfogadva() and not self.kitiltva)
+        self.tiltas_sav.setVisible(self.kitiltva)
+        self.fulsor.setVisible(not self.kitiltva)
+        self.fulek.setVisible(not self.kitiltva)
+        self.tolto.setVisible(self.kitiltva)
+        for g in (self.uj_hiba, self.uj_otlet):
+            g.setEnabled(self.szabad())
+        self.reszletek.valasz_doboz.setEnabled(self.szabad())
+        for g in self.fulek.widget(1).findChildren(QPushButton):
+            g.setEnabled(self.szabad())
+        self.ertekeles_lap._gomb_frissit()
+
+    def _tiltas_kesz(self, adat):
+        self.kitiltva = bool(adat.get("kitiltva"))
+        if self.kitiltva:
+            meddig = f"eddig: {ido(adat['lejar'])}" if adat.get("lejar") else "véglegesen"
+            self.tiltas_sav.setText(
+                f"Ez a gép {meddig} ki van tiltva a Visszajelzés használatából a szabályok megsértése miatt. "
+                f"Ok: {adat.get('ok') or '-'}\n\nA RaveOS Center minden más része ugyanúgy működik."
+            )
+        self._allapot_frissit()
+        if not self.kitiltva:
+            self.lista_frissit()
+            if self.fulek.currentIndex() == 1:
+                self._otletek_frissit()
+            elif self.fulek.currentIndex() == 2:
+                self._ertekeles_frissit()
+
+    def megjelenik(self, *_):
+        self._allapot_frissit()
+        if not self.elfogadva():
+            QTimer.singleShot(200, self.ismerteto)
+        gyorsitott("jegy_allapot", jegyek_api.allapot, kesz=self._tiltas_kesz, hiba=self._hibat_mutat, kor=60)
+
+    def ful(self, azon):
+        self.fulsor.aktiv(azon)
+        self.fulek.setCurrentIndex({"jegyeim": 0, "otletek": 1, "ertekeles": 2}[azon])
+        if azon == "otletek":
+            self._otletek_frissit()
+        elif azon == "ertekeles":
+            self._ertekeles_frissit()
+
+    def _ertekeles_frissit(self):
+        def kesz(adat):
+            self.hiba.hide()
+            self.ertekeles_lap.betolt(adat)
+
+        hatterben(jegyek_api.ertekeles, kesz=kesz, hiba=self._hibat_mutat)
+
+    def jegy_eltunt(self):
+        self.reszletek.jegy_id = None
+        self.lista.setCurrentRow(-1)
+        self.jobb.setCurrentWidget(self.ures)
+        self.lista_frissit()
+
+    def _jegy_hiba(self, uzenet):
+        if uzenet == "nincs_jegy":
+            self.jegy_eltunt()
+        else:
+            self._hibat_mutat(uzenet)
+
+    def _hibat_mutat(self, uzenet):
+        self.hiba.setText(jegyek_api.HIBAUZENETEK.get(uzenet, f"Hiba történt: {uzenet}"))
+        self.hiba.show()
+
+    def _jelveny_frissit(self, jegyek):
+        self.kozpont.jelveny(AZON, sum(1 for j in jegyek if j["uj_valasz"]))
+
+    def lista_frissit(self, kivalaszt=None):
+        def kesz(jegyek):
+            self.hiba.hide()
+            self._jelveny_frissit(jegyek)
+            aktualis = kivalaszt or self.reszletek.jegy_id
+            if jegyek == self.jegyek and self.lista_betoltve and not kivalaszt:
+                return
+            self.jegyek = jegyek
+            self.lista_betoltve = True
+            self.lista.blockSignals(True)
+            self.lista.clear()
+            for j in jegyek:
+                elem = QListWidgetItem()
+                elem.setData(Qt.ItemDataRole.UserRole, j["id"])
+                sor = JegySor(j)
+                elem.setSizeHint(sor.sizeHint())
+                self.lista.addItem(elem)
+                self.lista.setItemWidget(elem, sor)
+                if j["id"] == aktualis:
+                    self.lista.setCurrentItem(elem)
+            self.lista.blockSignals(False)
+            if self.jobb.currentWidget() is not self.urlap_gorgeto and not self.lista.currentItem():
+                self.ures_szoveg.setText(
+                    "Még nincs jegyed. Ha hibát találtál, vagy ötleted van, írj nekünk a fenti gombokkal."
+                    if not jegyek
+                    else "Válassz egy jegyet a listából."
+                )
+                self.jobb.setCurrentWidget(self.ures)
+
+        hatterben(jegyek_api.jegyeim, kesz=kesz, hiba=self._hibat_mutat)
+
+    def _kivalaszt(self, elem, _elozo=None):
+        if not elem:
+            return
+        jegy_id = elem.data(Qt.ItemDataRole.UserRole)
+
+        def kesz(jegy):
+            aktualis = self.lista.currentItem()
+            if not aktualis or aktualis.data(Qt.ItemDataRole.UserRole) != jegy_id:
+                return
+            self.reszletek.betolt(jegy)
+            self.jobb.setCurrentWidget(self.reszletek)
+            self.lista_frissit_csendben(jegy_id)
+
+        hatterben(jegyek_api.jegy, jegy_id, kesz=kesz, hiba=self._jegy_hiba)
+
+    def lista_frissit_csendben(self, jegy_id):
+        for j in self.jegyek:
+            if j["id"] == jegy_id and j["uj_valasz"]:
+                self.lista_frissit(jegy_id)
+                return
+
+    def urlap_nyit(self, tipus):
+        self.ful("jegyeim")
+        self.lista.setCurrentRow(-1)
+        self.urlap.nyit(tipus)
+        self.jobb.setCurrentWidget(self.urlap_gorgeto)
+
+    def urlap_bezar(self):
+        self.jobb.setCurrentWidget(self.ures)
+        self.lista_frissit()
+
+    def bekuldve(self, jegy):
+        self.lista_frissit(jegy["id"])
+        self._kivalaszt_id(jegy["id"])
+
+    def _kivalaszt_id(self, jegy_id):
+        hatterben(
+            jegyek_api.jegy,
+            jegy_id,
+            kesz=lambda j: (self.reszletek.betolt(j), self.jobb.setCurrentWidget(self.reszletek)),
+            hiba=self._jegy_hiba,
+        )
+
+    def _otletek_frissit(self):
+        def kesz(otletek):
+            self.hiba.hide()
+            while self.otlet_doboz.count():
+                w = self.otlet_doboz.takeAt(0).widget()
+                if w:
+                    w.deleteLater()
+            if not otletek:
+                self.otlet_doboz.addWidget(cimke("Még nincs közzétett ötlet.", "halvany"))
+            for o in otletek:
+                kartya = OtletKartya(o, self._szavaz)
+                for g in kartya.findChildren(QPushButton):
+                    g.setEnabled(self.szabad())
+                self.otlet_doboz.addWidget(kartya)
+
+        hatterben(jegyek_api.otletek, kesz=kesz, hiba=self._hibat_mutat)
+
+    def _szavaz(self, jegy_id, tamogat, g):
+        g.setEnabled(False)
+        hatterben(jegyek_api.szavaz, jegy_id, tamogat, kesz=lambda _: self._otletek_frissit(), hiba=self._hibat_mutat)
+
+
+OLDAL = Visszajelzes