path: root/raveos-center/raveos_center/oldalak/rendszer/gaming.py

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