Beta 0.9.0

Oazis

Przeglądarka, która wygląda inaczej niż wszystkie. Rozmycie, spokój i własny styl – zamiast kolejnej szarej wersji tego samego.

Poznaj Oazis

🪟

Efekt blur

Własny pasek tytułowy z kartami i okna dialogowe. Gdy otwierasz okno, strona w tle się rozmywa – siłę rozmycia ustawisz suwakiem w ustawieniach.

🎨

Motywy

Systemowy, jasny, szary albo czarny. Wersja „systemowa” sama przełącza się za Windowsem, a strony dostają informację o preferowanym trybie.

🗂️

Karty z podglądem

Najedź na kartę, a zobaczysz miniaturę strony. Karty przesuwasz myszką, zamykasz środkowym przyciskiem, a skróty jak Ctrl+T czy Ctrl+Tab działają od razu.

🔐

Hasła

Oazis zapyta, czy zapisać dane logowania, i uzupełni je później sam. Wszystko jest szyfrowane przez Windows (DPAPI), a funkcję wyłączysz w ustawieniach.

⬇️

Pobieranie

Wygodne powiadomienie z paskiem postępu i osobny menedżer pobranych plików – otwierasz plik albo folder jednym kliknięciem.

⚡

Silnik Chromium

Pod spodem działa Qt WebEngine, więc strony ładują się tak, jak w znanych przeglądarkach. Ciasteczka i cache zostają zapisane między uruchomieniami.

Wersja beta 0.9.0 · Windows · OazisInstaller.exe

Kto to zrobił?

Oazis stworzył 13-latek z Wąbrzeźna. To pierwsza przeglądarka, która wygląda inaczej niż wszystkie – wyjątkowa, własna i zrobiona z pasji. Jeśli ją polubisz, to najlepsza nagroda.

Licencja

GNU General Public License v3.0

Oazis jest wolnym oprogramowaniem. Możesz go uruchamiać, badać, kopiować, modyfikować i rozpowszechniać na warunkach licencji GNU GPL v3, opublikowanej przez Free Software Foundation.

Co to oznacza w praktyce

  • Możesz używać programu do dowolnych celów, także komercyjnych.
  • Możesz zmieniać kod i dzielić się własnymi wersjami.
  • Rozpowszechniane wersje (także zmienione) muszą pozostać na licencji GPL v3 i mieć dostępny kod źródłowy.
  • Program jest udostępniany bez gwarancji – autor nie odpowiada za szkody wynikające z jego użycia.

Informacja o autorze (obowiązkowa przy rozpowszechnianiu)

Jeśli rozpowszechniasz Oazis albo jego kod źródłowy – w oryginalnej lub zmienionej wersji – musisz w widocznym miejscu (np. w opisie projektu, pliku README lub na stronie programu) napisać, że kod pochodzi od Mateusza Mecha (projekt Oazis) i zachować informacje o prawach autorskich z pliku źródłowego.

Pełny tekst

Oficjalny tekst licencji: gnu.org/licenses/gpl-3.0

Kod źródłowy

Oazis – oazis.py

Poniżej znajduje się cały kod źródłowy przeglądarki (Python, PyQt6 + Qt WebEngine). Kod pochodzi od Mateusza Mecha. Jeśli rozpowszechniasz go lub jego zmodyfikowaną wersję, musisz napisać, że pochodzi od niego – zobacz Licencja.

import os
import sys
import json
import base64
import ctypes
import subprocess
from pathlib import Path
from urllib.parse import quote_plus, urlparse

# ============================================================
# OAZIS BROWSER
# PyQt6 + Qt WebEngine
#
# Instalacja:
# py -m pip install PyQt6 PyQt6-WebEngine pyinstaller
#
# Budowanie EXE:
# py -m PyInstaller --noconfirm --clean --windowed --onedir ^
#   --name Oazis --add-data "oazis_logo.png;." oazis.py
#
# Do drugiego komputera kopiuj cały folder dist\Oazis.
# ============================================================


# ------------------------------------------------------------
# URUCHAMIANIE BEZ WIDOCZNEJ KONSOLI
# ------------------------------------------------------------

def relaunch_without_console():
    if os.name != "nt" or getattr(sys, "frozen", False):
        return

    if os.environ.get("OAZIS_NO_CONSOLE") == "1":
        return

    executable = Path(sys.executable)

    if executable.name.lower() not in ("python.exe", "python3.exe"):
        return

    pythonw = executable.with_name("pythonw.exe")

    if not pythonw.exists():
        return

    environment = os.environ.copy()
    environment["OAZIS_NO_CONSOLE"] = "1"

    flags = (
        getattr(subprocess, "DETACHED_PROCESS", 0x00000008)
        | getattr(subprocess, "CREATE_NO_WINDOW", 0x08000000)
    )

    try:
        subprocess.Popen(
            [str(pythonw), str(Path(__file__).resolve()), *sys.argv[1:]],
            cwd=str(Path(__file__).resolve().parent),
            env=environment,
            creationflags=flags,
            close_fds=True
        )
        os._exit(0)
    except Exception:
        pass


relaunch_without_console()

if os.name == "nt":
    try:
        ctypes.windll.kernel32.FreeConsole()
    except Exception:
        pass


# ------------------------------------------------------------
# PYQT
# ------------------------------------------------------------

from PyQt6.QtCore import (
    Qt, QUrl, QTimer, QPoint, QStandardPaths,
    pyqtSignal, QSize
)

from PyQt6.QtGui import (
    QAction, QIcon, QKeySequence, QColor,
    QDesktopServices, QPalette
)

from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget,
    QVBoxLayout, QHBoxLayout, QFormLayout,
    QLineEdit, QPushButton, QTabBar,
    QMenu, QMessageBox, QDialog,
    QListWidget, QListWidgetItem, QLabel,
    QProgressBar, QToolButton, QStyle,
    QFrame, QSlider, QCheckBox,
    QGraphicsBlurEffect, QStackedWidget,
    QSizePolicy, QToolTip
)

from PyQt6.QtWebEngineCore import (
    QWebEngineProfile,
    QWebEnginePage,
    QWebEngineSettings,
    QWebEngineDownloadRequest
)

from PyQt6.QtWebEngineWidgets import QWebEngineView


# ------------------------------------------------------------
# ŚCIEŻKI
# ------------------------------------------------------------

APP_NAME = "Oazis"

HOME_URL = "https://www.google.com"

APP_DATA = Path(
    QStandardPaths.writableLocation(
        QStandardPaths.StandardLocation.AppDataLocation
    )
) / APP_NAME

PROFILE_DIR = APP_DATA / "Chromium"

DOWNLOAD_DIR = Path(
    QStandardPaths.writableLocation(
        QStandardPaths.StandardLocation.DownloadLocation
    )
)

PASSWORD_FILE = APP_DATA / "passwords.dat"
SETTINGS_FILE = APP_DATA / "settings.json"

LOGO_FILE = "oazis_logo.png"

PASSWORD_PREFIX = "OAZIS_PASSWORD:"


def resource_path(filename):
    base = Path(
        getattr(
            sys,
            "_MEIPASS",
            Path(__file__).resolve().parent
        )
    )

    return base / filename


# ------------------------------------------------------------
# WINDOWS APP ID
# ------------------------------------------------------------

def set_windows_app_id():
    if os.name == "nt":
        try:
            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
                "Oazis.Browser"
            )
        except Exception:
            pass


# ------------------------------------------------------------
# WINDOWS DPAPI - SZYFROWANIE HASEŁ
# ------------------------------------------------------------

class DataBlob(ctypes.Structure):
    _fields_ = [
        ("cbData", ctypes.c_uint32),
        ("pbData", ctypes.POINTER(ctypes.c_ubyte))
    ]


def encrypt_data(data):
    if os.name != "nt":
        raise RuntimeError(
            "Magazyn haseł wymaga Windows DPAPI."
        )

    crypt = ctypes.windll.crypt32
    kernel = ctypes.windll.kernel32

    buffer = ctypes.create_string_buffer(data)

    source = DataBlob(
        len(data),
        ctypes.cast(
            buffer,
            ctypes.POINTER(ctypes.c_ubyte)
        )
    )

    output = DataBlob()

    result = crypt.CryptProtectData(
        ctypes.byref(source),
        "Oazis Password Vault",
        None,
        None,
        None,
        0,
        ctypes.byref(output)
    )

    if not result:
        raise OSError("Nie udało się zaszyfrować haseł.")

    try:
        return ctypes.string_at(
            output.pbData,
            output.cbData
        )
    finally:
        kernel.LocalFree(output.pbData)


def decrypt_data(data):
    if os.name != "nt":
        raise RuntimeError(
            "Magazyn haseł wymaga Windows DPAPI."
        )

    crypt = ctypes.windll.crypt32
    kernel = ctypes.windll.kernel32

    buffer = ctypes.create_string_buffer(data)

    source = DataBlob(
        len(data),
        ctypes.cast(
            buffer,
            ctypes.POINTER(ctypes.c_ubyte)
        )
    )

    output = DataBlob()

    result = crypt.CryptUnprotectData(
        ctypes.byref(source),
        None,
        None,
        None,
        None,
        0,
        ctypes.byref(output)
    )

    if not result:
        raise OSError("Nie udało się odszyfrować haseł.")

    try:
        return ctypes.string_at(
            output.pbData,
            output.cbData
        )
    finally:
        kernel.LocalFree(output.pbData)


class PasswordVault:

    def __init__(self):
        self.entries = {}
        APP_DATA.mkdir(parents=True, exist_ok=True)
        self.load()

    def load(self):
        if not PASSWORD_FILE.exists():
            return

        try:
            encrypted = PASSWORD_FILE.read_bytes()
            raw = decrypt_data(encrypted)

            data = json.loads(
                raw.decode("utf-8")
            )

            if isinstance(data, dict):
                self.entries = data

        except Exception:
            self.entries = {}

    def save(self):
        raw = json.dumps(
            self.entries,
            ensure_ascii=False
        ).encode("utf-8")

        encrypted = encrypt_data(raw)

        PASSWORD_FILE.write_bytes(encrypted)

    def get(self, origin):
        return self.entries.get(origin)

    def put(self, origin, username, password):
        self.entries[origin] = {
            "username": username,
            "password": password
        }

        self.save()

    def remove(self, origin):
        self.entries.pop(origin, None)
        self.save()


# ------------------------------------------------------------
# WYKRYWANIE FORMULARZY LOGOWANIA
# ------------------------------------------------------------

PASSWORD_SCRIPT = r"""
(function () {

    if (window.__oazisPasswordWatcher) return;

    window.__oazisPasswordWatcher = true;

    function findUsername(form, passwordInput) {

        const inputs = Array.from(
            form.querySelectorAll("input")
        );

        const candidates = inputs.filter(input => {

            if (input === passwordInput) return false;
            if (input.disabled) return false;

            const type = (
                input.type || ""
            ).toLowerCase();

            return (
                ["text", "email", "tel"].includes(type)
                ||
                /user|login|email|account|name/i.test(
                    (input.name || "") + " " +
                    (input.id || "") + " " +
                    (input.autocomplete || "")
                )
            );
        });

        return candidates.find(
            el => /username|email/i.test(
                el.autocomplete || ""
            )
        ) || candidates[0] || null;
    }

    function capture(form) {

        const passwordInput = form.querySelector(
            'input[type="password"]'
        );

        if (!passwordInput) return;

        const usernameInput = findUsername(
            form,
            passwordInput
        );

        const payload = {
            origin: location.origin,
            username: usernameInput
                ? usernameInput.value
                : "",
            password: passwordInput.value
        };

        if (!payload.password) return;

        try {

            const encoded = btoa(
                unescape(
                    encodeURIComponent(
                        JSON.stringify(payload)
                    )
                )
            );

            console.log(
                "OAZIS_PASSWORD:" + encoded
            );

        } catch (error) {}
    }

    document.addEventListener(
        "submit",
        function (event) {

            const form = event.target;

            if (!form || !form.querySelector) return;

            capture(form);

        },
        true
    );

    document.addEventListener(
        "click",
        function (event) {

            const button = event.target.closest(
                'button, input[type="submit"]'
            );

            if (!button) return;

            const form = button.form ||
                button.closest("form");

            if (form) capture(form);

        },
        true
    );

})();
"""


def create_autofill_script(credentials):

    payload = json.dumps(credentials)

    return """
    (() => {

        const saved = %s;

        function fill() {

            const password = document.querySelector(
                'input[type="password"]'
            );

            if (!password) return;

            const inputs = Array.from(
                document.querySelectorAll("input")
            );

            const username = inputs.find(
                el => el !== password &&
                /username|email/i.test(
                    el.autocomplete || ""
                )
            ) || inputs.find(
                el => el !== password &&
                ["text", "email"].includes(el.type)
            );

            if (
                username &&
                saved.username &&
                !username.value
            ) {

                username.value = saved.username;

                username.dispatchEvent(
                    new Event("input", {bubbles:true})
                );

                username.dispatchEvent(
                    new Event("change", {bubbles:true})
                );
            }

            if (!password.value && saved.password) {

                password.value = saved.password;

                password.dispatchEvent(
                    new Event("input", {bubbles:true})
                );

                password.dispatchEvent(
                    new Event("change", {bubbles:true})
                );
            }
        }

        if (document.readyState === "loading") {

            document.addEventListener(
                "DOMContentLoaded",
                fill,
                {once:true}
            );

        } else {

            fill();

        }

        setTimeout(fill, 1000);

    })();
    """ % payload


# ------------------------------------------------------------
# PASEK KART
# ------------------------------------------------------------

class OazisTabBar(QTabBar):

    middleClicked = pyqtSignal(int)
    hoverChanged = pyqtSignal(int)
    hoverLeft = pyqtSignal()

    def __init__(self):
        super().__init__()

        self.setMovable(True)
        self.setUsesScrollButtons(True)
        self.setExpanding(False)
        self.setElideMode(
            Qt.TextElideMode.ElideRight
        )

        self.setMouseTracking(True)
        self.setDrawBase(False)

    def mouseReleaseEvent(self, event):

        if event.button() == Qt.MouseButton.MiddleButton:

            index = self.tabAt(
                event.position().toPoint()
            )

            if index >= 0:
                self.middleClicked.emit(index)
                event.accept()
                return

        super().mouseReleaseEvent(event)

    def mouseMoveEvent(self, event):

        index = self.tabAt(
            event.position().toPoint()
        )

        if index >= 0:
            self.hoverChanged.emit(index)
        else:
            self.hoverLeft.emit()

        super().mouseMoveEvent(event)

    def leaveEvent(self, event):
        self.hoverLeft.emit()
        super().leaveEvent(event)


# ------------------------------------------------------------
# STRONA PRZEGLĄDARKI
# ------------------------------------------------------------

class BrowserPage(QWebEnginePage):

    def __init__(self, profile, browser, parent=None):
        super().__init__(profile, parent)
        self.browser = browser

    def createWindow(self, window_type):

        tab = self.browser.add_tab(
            "about:blank",
            switch=True
        )

        return tab.page

    def javaScriptConsoleMessage(
        self,
        level,
        message,
        line_number,
        source_id
    ):

        if message.startswith(PASSWORD_PREFIX):

            self.browser.receive_password(
                message[len(PASSWORD_PREFIX):]
            )

            return

        super().javaScriptConsoleMessage(
            level,
            message,
            line_number,
            source_id
        )


class BrowserView(QWebEngineView):

    def __init__(self, browser, parent=None):
        super().__init__(parent)
        self.browser = browser


class BrowserTab(QWidget):

    def __init__(self, browser):
        super().__init__()

        self.browser = browser

        self.view = BrowserView(
            browser,
            self
        )

        self.page = BrowserPage(
            browser.profile,
            browser,
            self
        )

        self.view.setPage(self.page)

        settings = self.page.settings()

        settings.setAttribute(
            QWebEngineSettings.WebAttribute.JavascriptEnabled,
            True
        )

        settings.setAttribute(
            QWebEngineSettings.WebAttribute.LocalStorageEnabled,
            True
        )

        settings.setAttribute(
            QWebEngineSettings.WebAttribute.FullScreenSupportEnabled,
            True
        )

        settings.setAttribute(
            QWebEngineSettings.WebAttribute.JavascriptCanOpenWindows,
            True
        )

        settings.setAttribute(
            QWebEngineSettings.WebAttribute.ErrorPageEnabled,
            True
        )

        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        layout.addWidget(self.view)

        self.page.titleChanged.connect(
            lambda _: browser.refresh_tab(self)
        )

        self.page.iconChanged.connect(
            lambda _: browser.refresh_tab(self)
        )

        self.page.urlChanged.connect(
            lambda url: browser.address_changed(self, url)
        )

        self.page.loadFinished.connect(
            lambda ok: browser.page_loaded(self, ok)
        )

        self.page.loadProgress.connect(
            lambda value: browser.page_progress(self, value)
        )

        self.page.fullScreenRequested.connect(
            self.fullscreen_request
        )

    def fullscreen_request(self, request):

        request.accept()

        self.browser.set_web_fullscreen(
            request.toggleOn()
        )


# ------------------------------------------------------------
# OKNA GLASS / BLUR
# ------------------------------------------------------------

class GlassDialog(QDialog):

    def __init__(self, browser, title):
        super().__init__(browser)

        self.browser = browser

        self.setWindowTitle(title)

        self.setWindowFlags(
            Qt.WindowType.Dialog |
            Qt.WindowType.FramelessWindowHint
        )

        self.setAttribute(
            Qt.WidgetAttribute.WA_TranslucentBackground,
            True
        )

        self.setModal(True)

        self.surface = QFrame()
        self.surface.setObjectName("glassSurface")

        self.surface.setStyleSheet("""
            QFrame#glassSurface {
                background: rgba(30, 33, 42, 235);
                border: 1px solid rgba(255,255,255,45);
                border-radius: 20px;
            }
        """)

        self.surface_layout = QVBoxLayout(
            self.surface
        )

        self.surface_layout.setContentsMargins(
            22, 18, 22, 20
        )

        self.surface_layout.setSpacing(14)

        root = QVBoxLayout(self)
        root.setContentsMargins(0, 0, 0, 0)
        root.addWidget(self.surface)

        title_label = QLabel(title)

        title_label.setStyleSheet("""
            color: white;
            font-size: 19px;
            font-weight: 650;
        """)

        self.surface_layout.addWidget(title_label)

        self.browser.apply_blur(True)

    def done(self, result):

        self.browser.apply_blur(False)

        super().done(result)

    def closeEvent(self, event):

        self.browser.apply_blur(False)

        super().closeEvent(event)


# ------------------------------------------------------------
# USTAWIENIA
# ------------------------------------------------------------

class SettingsDialog(GlassDialog):

    def __init__(self, browser):
        super().__init__(
            browser,
            "Ustawienia Oazis"
        )

        self.setFixedWidth(440)

        form = QFormLayout()
        form.setSpacing(14)

        self.theme_button = QPushButton(
            browser.theme_label()
        )

        self.theme_button.clicked.connect(
            self.choose_theme
        )

        form.addRow(
            "Motyw",
            self.theme_button
        )

        self.blur_slider = QSlider(
            Qt.Orientation.Horizontal
        )

        self.blur_slider.setRange(0, 30)
        self.blur_slider.setValue(
            browser.blur_strength
        )

        self.blur_value = QLabel(
            f"{browser.blur_strength}px"
        )

        self.blur_slider.valueChanged.connect(
            self.change_blur
        )

        blur_layout = QHBoxLayout()
        blur_layout.addWidget(
            self.blur_slider,
            1
        )
        blur_layout.addWidget(
            self.blur_value
        )

        form.addRow(
            "Siła rozmycia",
            blur_layout
        )

        self.password_checkbox = QCheckBox(
            "Zapisywanie i uzupełnianie haseł"
        )

        self.password_checkbox.setChecked(
            browser.password_saving
        )

        self.password_checkbox.toggled.connect(
            browser.set_password_saving
        )

        form.addRow(
            self.password_checkbox
        )

        self.surface_layout.addLayout(form)

        buttons = QHBoxLayout()
        buttons.addStretch()

        close = QPushButton("Gotowe")
        close.clicked.connect(self.accept)

        buttons.addWidget(close)

        self.surface_layout.addLayout(buttons)

    def choose_theme(self):

        menu = QMenu(self)

        themes = [
            ("Domyślny (systemowy)", "system"),
            ("Jasny", "light"),
            ("Szary", "gray"),
            ("Czarny", "black")
        ]

        for label, value in themes:

            menu.addAction(
                label,
                lambda v=value, l=label:
                    self.change_theme(v, l)
            )

        menu.exec(
            self.theme_button.mapToGlobal(
                self.theme_button.rect().bottomLeft()
            )
        )

    def change_theme(self, value, label):

        self.browser.apply_theme(value)

        self.theme_button.setText(label)

    def change_blur(self, value):

        self.browser.blur_strength = value

        self.blur_value.setText(
            f"{value}px"
        )

        self.browser.save_settings()


# ------------------------------------------------------------
# OKNO ZAPISYWANIA HASŁA
# ------------------------------------------------------------

class PasswordDialog(GlassDialog):

    def __init__(
        self,
        browser,
        origin,
        username,
        password
    ):

        super().__init__(
            browser,
            "Zapisać hasło?"
        )

        self.origin = origin
        self.username = username
        self.password = password

        self.setFixedWidth(420)

        label = QLabel(
            f"Czy zapisać dane logowania dla:\n{origin}"
        )

        label.setWordWrap(True)
        label.setStyleSheet("color:white;")

        self.surface_layout.addWidget(label)

        user_label = QLabel(
            f"Użytkownik: {username or 'Nie wykryto'}"
        )

        user_label.setStyleSheet(
            "color:#d4d8e0;"
        )

        self.surface_layout.addWidget(user_label)

        row = QHBoxLayout()

        cancel = QPushButton("Nie teraz")
        save = QPushButton("Zapisz hasło")

        cancel.clicked.connect(self.reject)
        save.clicked.connect(self.accept)

        row.addWidget(cancel)
        row.addWidget(save)

        self.surface_layout.addLayout(row)


# ------------------------------------------------------------
# POWIADOMIENIE O POBIERANIU
# ------------------------------------------------------------

class DownloadToast(QFrame):

    def __init__(self, browser):
        super().__init__(browser)

        self.browser = browser

        self.setObjectName("downloadToast")

        self.setStyleSheet("""
            QFrame#downloadToast {
                background: rgba(25, 28, 36, 235);
                border: 1px solid rgba(255,255,255,50);
                border-radius: 16px;
            }

            QLabel {
                color: white;
            }

            QProgressBar {
                background: rgba(255,255,255,30);
                border: none;
                border-radius: 4px;
                height: 7px;
                text-visible: false;
            }

            QProgressBar::chunk {
                background: #76a8ff;
                border-radius: 4px;
            }
        """)

        self.setFixedWidth(360)

        layout = QVBoxLayout(self)

        layout.setContentsMargins(
            15, 12, 15, 12
        )

        layout.setSpacing(8)

        top = QHBoxLayout()

        self.filename = QLabel("Pobieranie")
        self.percent = QLabel("0%")

        self.filename.setStyleSheet(
            "font-weight:600;"
        )

        top.addWidget(self.filename, 1)
        top.addWidget(self.percent)

        layout.addLayout(top)

        self.progress = QProgressBar()
        self.progress.setRange(0, 100)

        layout.addWidget(self.progress)

        bottom = QHBoxLayout()

        self.state = QLabel("Przygotowywanie...")
        self.state.setStyleSheet(
            "color:#c3c8d2;font-size:11px;"
        )

        open_button = QPushButton("Pobrane")
        open_button.setFixedHeight(27)

        open_button.clicked.connect(
            browser.show_downloads
        )

        bottom.addWidget(self.state, 1)
        bottom.addWidget(open_button)

        layout.addLayout(bottom)

        self.hide()

    def update_record(self, record):

        self.filename.setText(
            record.get("name", "Pobieranie")
        )

        progress = max(
            0,
            min(100, int(record.get("progress", 0)))
        )

        self.progress.setValue(progress)

        self.percent.setText(
            f"{progress}%"
        )

        self.state.setText(
            record.get("state", "Pobieranie...")
        )

        self.adjustSize()

        self.move(
            self.browser.width() - self.width() - 20,
            self.browser.height() - self.height() - 38
        )

        self.show()
        self.raise_()


# ------------------------------------------------------------
# MENEDŻER POBIERANIA
# ------------------------------------------------------------

class DownloadDialog(GlassDialog):

    def __init__(self, browser):

        super().__init__(
            browser,
            "Pobrane pliki"
        )

        self.resize(620, 440)

        self.files = QListWidget()

        self.files.setStyleSheet("""
            QListWidget {
                background: rgba(255,255,255,12);
                color: white;
                border: 1px solid rgba(255,255,255,40);
                border-radius: 12px;
                padding: 5px;
            }

            QListWidget::item {
                padding: 9px;
                border-radius: 7px;
            }

            QListWidget::item:selected {
                background: rgba(100,150,230,140);
            }
        """)

        self.surface_layout.addWidget(
            self.files,
            1
        )

        buttons = QHBoxLayout()

        folder = QPushButton(
            "Otwórz folder"
        )

        open_file = QPushButton(
            "Otwórz plik"
        )

        close = QPushButton(
            "Zamknij"
        )

        folder.clicked.connect(
            self.open_folder
        )

        open_file.clicked.connect(
            self.open_file
        )

        close.clicked.connect(
            self.accept
        )

        buttons.addWidget(folder)
        buttons.addWidget(open_file)
        buttons.addStretch()
        buttons.addWidget(close)

        self.surface_layout.addLayout(buttons)

        self.refresh()

    def refresh(self):

        self.files.clear()

        DOWNLOAD_DIR.mkdir(
            parents=True,
            exist_ok=True
        )

        try:
            paths = sorted(
                DOWNLOAD_DIR.iterdir(),
                key=lambda path: path.stat().st_mtime,
                reverse=True
            )
        except Exception:
            paths = []

        for path in paths:

            if not path.is_file():
                continue

            size = path.stat().st_size

            item = QListWidgetItem(
                f"{path.name}  ·  {self.format_size(size)}"
            )

            item.setData(
                Qt.ItemDataRole.UserRole,
                str(path)
            )

            self.files.addItem(item)

    @staticmethod
    def format_size(size):

        size = float(size)

        for unit in ("B", "KB", "MB", "GB"):

            if size < 1024 or unit == "GB":
                return f"{size:.1f} {unit}"

            size /= 1024

    def open_folder(self):

        QDesktopServices.openUrl(
            QUrl.fromLocalFile(
                str(DOWNLOAD_DIR)
            )
        )

    def open_file(self):

        item = self.files.currentItem()

        if not item:
            return

        path = item.data(
            Qt.ItemDataRole.UserRole
        )

        if path and Path(path).exists():

            QDesktopServices.openUrl(
                QUrl.fromLocalFile(path)
            )


# ------------------------------------------------------------
# WŁASNY PASEK TYTUŁOWY
# ------------------------------------------------------------

class TitleBar(QWidget):

    def __init__(self, browser):

        super().__init__(browser)

        self.browser = browser
        self.drag_position = None

        self.setFixedHeight(44)

        layout = QHBoxLayout(self)

        layout.setContentsMargins(
            9, 3, 7, 3
        )

        layout.setSpacing(5)

        self.tabs = OazisTabBar()

        self.tabs.setSizePolicy(
            QSizePolicy.Policy.Expanding,
            QSizePolicy.Policy.Expanding
        )

        self.tabs.tabCloseRequested.connect(
            browser.close_tab
        )

        self.tabs.currentChanged.connect(
            browser.tab_selection_changed
        )

        self.tabs.middleClicked.connect(
            browser.close_tab
        )

        self.tabs.hoverChanged.connect(
            browser.show_tab_preview
        )

        self.tabs.hoverLeft.connect(
            browser.hide_tab_preview
        )

        layout.addWidget(
            self.tabs,
            1
        )

        self.new_tab = QToolButton()

        self.new_tab.setText("+")
        self.new_tab.setFixedSize(31, 30)
        self.new_tab.setToolTip("Nowa karta")

        self.new_tab.clicked.connect(
            lambda: browser.add_tab(HOME_URL, True)
        )

        layout.addWidget(self.new_tab)

        self.minimize = self.window_button(
            "—",
            browser.showMinimized,
            "Minimalizuj"
        )

        self.maximize = self.window_button(
            "□",
            browser.toggle_maximize,
            "Maksymalizuj"
        )

        self.close_button = self.window_button(
            "×",
            browser.close,
            "Zamknij"
        )

        layout.addWidget(self.minimize)
        layout.addWidget(self.maximize)
        layout.addWidget(self.close_button)

    def window_button(
        self,
        text,
        callback,
        tooltip
    ):

        button = QToolButton()

        button.setText(text)
        button.setToolTip(tooltip)
        button.setFixedSize(34, 30)

        button.clicked.connect(callback)

        return button

    def mousePressEvent(self, event):

        if event.button() == Qt.MouseButton.LeftButton:

            self.drag_position = (
                event.globalPosition().toPoint()
                -
                self.browser.frameGeometry().topLeft()
            )

            event.accept()

    def mouseMoveEvent(self, event):

        if (
            self.drag_position is not None
            and event.buttons() & Qt.MouseButton.LeftButton
        ):

            if not self.browser.isMaximized():

                self.browser.move(
                    event.globalPosition().toPoint()
                    -
                    self.drag_position
                )

            event.accept()

    def mouseReleaseEvent(self, event):
        self.drag_position = None

    def mouseDoubleClickEvent(self, event):

        if event.button() == Qt.MouseButton.LeftButton:
            self.browser.toggle_maximize()


# ------------------------------------------------------------
# GŁÓWNA PRZEGLĄDARKA
# ------------------------------------------------------------

class OazisBrowser(QMainWindow):

    def __init__(self):

        super().__init__()

        self.setWindowTitle(APP_NAME)

        self.setWindowFlags(
            Qt.WindowType.FramelessWindowHint |
            Qt.WindowType.Window
        )

        self.resize(1370, 870)
        self.setMinimumSize(850, 560)

        APP_DATA.mkdir(
            parents=True,
            exist_ok=True
        )

        PROFILE_DIR.mkdir(
            parents=True,
            exist_ok=True
        )

        DOWNLOAD_DIR.mkdir(
            parents=True,
            exist_ok=True
        )

        logo = resource_path(LOGO_FILE)

        if logo.exists():

            icon = QIcon(str(logo))

            self.setWindowIcon(icon)
            QApplication.setWindowIcon(icon)

        self.password_vault = PasswordVault()

        self.password_saving = True

        self.theme = "system"
        self.blur_strength = 16

        self.blur_effect = None

        self.download_dialog = None
        self.preview_popup = None
        self.preview_image = None
        self.preview_title = None

        self.load_settings()

        # TRWAŁY PROFIL CHROMIUM
        self.profile = QWebEngineProfile(
            "OazisPersistentProfile",
            self
        )

        self.profile.setPersistentStoragePath(
            str(PROFILE_DIR / "storage")
        )

        self.profile.setCachePath(
            str(PROFILE_DIR / "cache")
        )

        self.profile.setPersistentCookiesPolicy(
            QWebEngineProfile.PersistentCookiesPolicy.ForcePersistentCookies
        )

        self.profile.setHttpCacheType(
            QWebEngineProfile.HttpCacheType.DiskHttpCache
        )

        self.profile.setHttpCacheMaximumSize(
            512 * 1024 * 1024
        )

        self.profile.downloadRequested.connect(
            self.handle_download
        )

        self.build_interface()
        self.create_shortcuts()

        self.apply_theme(self.theme)

        self.add_tab(HOME_URL, True)

        self.toast = DownloadToast(self)

        self.theme_timer = QTimer(self)

        self.theme_timer.setInterval(2000)

        self.theme_timer.timeout.connect(
            self.check_system_theme
        )

        self.theme_timer.start()

    # --------------------------------------------------------
    # USTAWIENIA
    # --------------------------------------------------------

    def load_settings(self):

        try:

            data = json.loads(
                SETTINGS_FILE.read_text(
                    encoding="utf-8"
                )
            )

            self.theme = data.get(
                "theme",
                "system"
            )

            self.blur_strength = int(
                data.get("blur_strength", 16)
            )

            self.password_saving = bool(
                data.get("password_saving", True)
            )

        except Exception:
            pass

        self.blur_strength = max(
            0,
            min(30, self.blur_strength)
        )

    def save_settings(self):

        APP_DATA.mkdir(
            parents=True,
            exist_ok=True
        )

        data = {
            "theme": self.theme,
            "blur_strength": self.blur_strength,
            "password_saving": self.password_saving
        }

        SETTINGS_FILE.write_text(
            json.dumps(
                data,
                ensure_ascii=False,
                indent=2
            ),
            encoding="utf-8"
        )

    # --------------------------------------------------------
    # INTERFEJS
    # --------------------------------------------------------

    def build_interface(self):

        root = QWidget()
        root.setObjectName("root")

        vertical = QVBoxLayout(root)

        vertical.setContentsMargins(
            0, 0, 0, 0
        )

        vertical.setSpacing(0)

        # KARTY I PRZYCISKI OKNA
        self.titlebar = TitleBar(self)

        vertical.addWidget(
            self.titlebar
        )

        # PASEK ADRESU
        toolbar = QWidget()
        toolbar.setObjectName("toolbar")

        row = QHBoxLayout(toolbar)

        row.setContentsMargins(
            12, 8, 12, 8
        )

        row.setSpacing(7)

        self.back = self.tool_button(
            "‹",
            "Wstecz",
            self.go_back
        )

        self.forward = self.tool_button(
            "›",
            "Dalej",
            self.go_forward
        )

        self.reload = self.tool_button(
            "⟳",
            "Odśwież",
            self.reload_page
        )

        self.home = self.tool_button(
            "⌂",
            "Strona startowa",
            self.go_home
        )

        row.addWidget(self.back)
        row.addWidget(self.forward)
        row.addWidget(self.reload)
        row.addWidget(self.home)

        self.address = QLineEdit()

        self.address.setPlaceholderText(
            "Wyszukaj lub wpisz adres"
        )

        self.address.setClearButtonEnabled(True)
        self.address.setMinimumHeight(42)

        self.address.returnPressed.connect(
            self.navigate
        )

        row.addWidget(
            self.address,
            1
        )

        self.download_button = self.tool_button(
            "↓",
            "Pobrane pliki",
            self.show_downloads
        )

        self.settings_button = self.tool_button(
            "⚙",
            "Ustawienia",
            self.show_settings
        )

        row.addWidget(self.download_button)
        row.addWidget(self.settings_button)

        vertical.addWidget(toolbar)

        # ZAWARTOŚĆ STRONY
        self.content = QWidget()
        self.content.setObjectName("content")

        self.content_layout = QVBoxLayout(
            self.content
        )

        self.content_layout.setContentsMargins(
            0, 0, 0, 0
        )

        self.stack = QStackedWidget()

        self.content_layout.addWidget(
            self.stack
        )

        vertical.addWidget(
            self.content,
            1
        )

        self.status = QLabel("Gotowy")
        self.status.setObjectName("status")
        self.status.setFixedHeight(22)
        self.status.setContentsMargins(
            12, 0, 12, 0
        )

        vertical.addWidget(
            self.status
        )

        self.setCentralWidget(root)

        self.tabs = self.titlebar.tabs

    def tool_button(
        self,
        text,
        tooltip,
        callback
    ):

        button = QToolButton()

        button.setText(text)
        button.setToolTip(tooltip)

        button.setFixedSize(38, 38)

        button.setCursor(
            Qt.CursorShape.PointingHandCursor
        )

        button.clicked.connect(callback)

        return button

    # --------------------------------------------------------
    # SKRÓTY KLAWIATUROWE
    # --------------------------------------------------------

    def create_shortcuts(self):

        shortcuts = [
            ("Ctrl+T", lambda: self.add_tab(HOME_URL, True)),
            ("Ctrl+W", lambda: self.close_tab(self.tabs.currentIndex())),
            ("Ctrl+Tab", self.next_tab),
            ("Ctrl+Shift+Tab", self.previous_tab),
            ("Ctrl+L", lambda: self.address.setFocus()),
            ("Ctrl+J", self.show_downloads),
            ("Ctrl+,", self.show_settings),
            ("Alt+Home", self.go_home),
            ("F11", self.toggle_fullscreen)
        ]

        for sequence, callback in shortcuts:

            action = QAction(self)

            action.setShortcut(
                QKeySequence(sequence)
            )

            action.triggered.connect(callback)

            self.addAction(action)

    # --------------------------------------------------------
    # KARTY
    # --------------------------------------------------------

    def add_tab(
        self,
        url=HOME_URL,
        switch=True
    ):

        tab = BrowserTab(self)

        index = self.tabs.addTab(
            "Nowa karta"
        )

        self.stack.addWidget(tab)

        self.tabs.setTabToolTip(
            index,
            "Nowa karta"
        )

        self.tabs.setTabIcon(
            index,
            self.style().standardIcon(
                QStyle.StandardPixmap.SP_FileIcon
            )
        )

        if switch:

            self.tabs.setCurrentIndex(index)
            self.stack.setCurrentWidget(tab)

        if url:
            tab.view.setUrl(QUrl(url))

        return tab

    def current_tab(self):

        widget = self.stack.currentWidget()

        if isinstance(widget, BrowserTab):
            return widget

        return None

    def tab_index(self, tab):

        return self.stack.indexOf(tab)

    def tab_selection_changed(self, index):

        if 0 <= index < self.stack.count():

            self.stack.setCurrentIndex(index)

        tab = self.current_tab()

        if tab:

            self.address.setText(
                tab.view.url().toString()
            )

            self.update_navigation_buttons(tab)

    def close_tab(self, index):

        if index < 0 or index >= self.tabs.count():
            return

        if self.tabs.count() == 1:

            tab = self.stack.widget(index)

            tab.view.setUrl(
                QUrl(HOME_URL)
            )

            return

        widget = self.stack.widget(index)

        self.tabs.removeTab(index)

        self.stack.removeWidget(widget)

        widget.deleteLater()

    def refresh_tab(self, tab):

        index = self.tab_index(tab)

        if index < 0:
            return

        title = (
            tab.page.title().strip()
            or tab.view.url().host()
            or "Nowa karta"
        )

        self.tabs.setTabText(
            index,
            title[:26]
        )

        self.tabs.setTabToolTip(
            index,
            tab.page.title()
            or tab.view.url().toString()
        )

        icon = tab.page.icon()

        if not icon.isNull():

            self.tabs.setTabIcon(
                index,
                icon
            )

    def address_changed(self, tab, url):

        self.refresh_tab(tab)

        if tab is self.current_tab():

            self.address.setText(
                url.toString()
            )

            self.update_navigation_buttons(tab)

    def update_navigation_buttons(self, tab):

        self.back.setEnabled(
            tab.view.history().canGoBack()
        )

        self.forward.setEnabled(
            tab.view.history().canGoForward()
        )

    # --------------------------------------------------------
    # ŁADOWANIE STRON
    # --------------------------------------------------------

    def page_progress(self, tab, value):

        if tab is self.current_tab():

            self.status.setText(
                f"Ładowanie strony... {value}%"
            )

    def page_loaded(self, tab, success):

        if tab is self.current_tab():

            self.status.setText(
                "Gotowy"
                if success
                else "Nie udało się załadować strony"
            )

        url = tab.view.url()

        if (
            url.scheme() == "https"
            and self.password_saving
        ):

            origin = (
                f"{url.scheme()}://{url.host()}"
            )

            saved = self.password_vault.get(origin)

            if saved:

                tab.page.runJavaScript(
                    create_autofill_script(saved)
                )

        tab.page.runJavaScript(
            PASSWORD_SCRIPT
        )

        self.update_page_theme(tab)

    # --------------------------------------------------------
    # ADRESY I WYSZUKIWANIE
    # --------------------------------------------------------

    def navigate(self):

        tab = self.current_tab()

        if not tab:
            return

        text = self.address.text().strip()

        if not text:
            return

        if text.startswith(
            ("https://", "http://", "file://")
        ):

            url = QUrl.fromUserInput(text)

        elif (
            " " not in text
            and (
                "." in text
                or text.startswith("localhost")
            )
        ):

            url = QUrl.fromUserInput(text)

        else:

            url = QUrl(
                "https://www.google.com/search?q="
                + quote_plus(text)
            )

        tab.view.setUrl(url)

    def go_back(self):

        tab = self.current_tab()

        if tab:
            tab.view.back()

    def go_forward(self):

        tab = self.current_tab()

        if tab:
            tab.view.forward()

    def reload_page(self):

        tab = self.current_tab()

        if tab:
            tab.view.reload()

    def go_home(self):

        tab = self.current_tab()

        if tab:
            tab.view.setUrl(
                QUrl(HOME_URL)
            )

    def next_tab(self):

        if self.tabs.count():

            self.tabs.setCurrentIndex(
                (self.tabs.currentIndex() + 1)
                % self.tabs.count()
            )

    def previous_tab(self):

        if self.tabs.count():

            self.tabs.setCurrentIndex(
                (self.tabs.currentIndex() - 1)
                % self.tabs.count()
            )

    # --------------------------------------------------------
    # ZAPISYWANIE HASEŁ
    # --------------------------------------------------------

    def receive_password(self, encoded):

        if not self.password_saving:
            return

        try:

            payload = json.loads(
                base64.b64decode(encoded).decode("utf-8")
            )

            origin = payload.get("origin", "")

            parsed = urlparse(origin)

            if (
                parsed.scheme != "https"
                or not parsed.netloc
            ):
                return

            username = str(
                payload.get("username", "")
            )[:300]

            password = str(
                payload.get("password", "")
            )[:2000]

            if not password:
                return

            existing = self.password_vault.get(origin)

            if (
                existing
                and existing.get("username") == username
                and existing.get("password") == password
            ):
                return

            # Nie wyświetlamy okna modalnego bezpośrednio
            # podczas obsługi komunikatu JavaScript.
            QTimer.singleShot(
                0,
                lambda: self.ask_save_password(
                    origin,
                    username,
                    password
                )
            )

        except Exception:
            return

    def ask_save_password(
        self,
        origin,
        username,
        password
    ):

        if not self.password_saving:
            return

        dialog = PasswordDialog(
            self,
            origin,
            username,
            password
        )

        if dialog.exec() == QDialog.DialogCode.Accepted:

            try:

                self.password_vault.put(
                    origin,
                    username,
                    password
                )

                self.status.setText(
                    "Hasło zapisano"
                )

            except Exception as error:

                QMessageBox.warning(
                    self,
                    "Oazis",
                    f"Nie udało się zapisać hasła:\n{error}"
                )

    def set_password_saving(self, enabled):

        self.password_saving = bool(enabled)

        self.save_settings()

    # --------------------------------------------------------
    # POBIERANIE
    # --------------------------------------------------------

    def handle_download(self, download):

        filename = (
            download.downloadFileName()
            or "download"
        )

        # Bez dodatkowego folderu Oazis.
        DOWNLOAD_DIR.mkdir(
            parents=True,
            exist_ok=True
        )

        download.setDownloadDirectory(
            str(DOWNLOAD_DIR)
        )

        download.setDownloadFileName(
            filename
        )

        record = {
            "name": filename,
            "progress": 0,
            "state": "Rozpoczynanie..."
        }

        def update_progress():

            total = download.totalBytes()
            received = download.receivedBytes()

            if total > 0:

                progress = int(
                    received * 100 / total
                )

            else:

                progress = 0

            record["progress"] = progress

            record["state"] = (
                f"{self.format_bytes(received)} "
                f"z {self.format_bytes(total)}"
            )

            self.toast.update_record(record)

        def state_changed(state):

            if state == QWebEngineDownloadRequest.DownloadState.DownloadCompleted:

                record["progress"] = 100

                record["state"] = "Pobieranie zakończone"

                self.toast.update_record(record)

                QTimer.singleShot(
                    4500,
                    self.toast.hide
                )

                if (
                    self.download_dialog
                    and self.download_dialog.isVisible()
                ):

                    self.download_dialog.refresh()

            elif state in (
                QWebEngineDownloadRequest.DownloadState.DownloadInterrupted,
                QWebEngineDownloadRequest.DownloadState.DownloadCancelled
            ):

                record["state"] = "Pobieranie przerwane"

                self.toast.update_record(record)

        download.receivedBytesChanged.connect(
            update_progress
        )

        download.totalBytesChanged.connect(
            update_progress
        )

        download.stateChanged.connect(
            state_changed
        )

        download.accept()

        QTimer.singleShot(
            0,
            update_progress
        )

    @staticmethod
    def format_bytes(value):

        value = float(max(0, value))

        for unit in ("B", "KB", "MB", "GB"):

            if value < 1024 or unit == "GB":
                return f"{value:.1f} {unit}"

            value /= 1024

    def show_downloads(self):

        dialog = DownloadDialog(self)

        self.download_dialog = dialog

        dialog.exec()

        self.download_dialog = None

    # --------------------------------------------------------
    # USTAWIENIA I BLUR
    # --------------------------------------------------------

    def show_settings(self):

        dialog = SettingsDialog(self)

        dialog.exec()

    def apply_blur(self, enabled):

        if not hasattr(self, "stack"):
            return

        if enabled and self.blur_strength > 0:

            if self.blur_effect is None:

                self.blur_effect = QGraphicsBlurEffect()

                self.stack.setGraphicsEffect(
                    self.blur_effect
                )

            self.blur_effect.setBlurRadius(
                self.blur_strength
            )

        else:

            self.stack.setGraphicsEffect(None)

            self.blur_effect = None

    # --------------------------------------------------------
    # MOTYWY
    # --------------------------------------------------------

    def theme_label(self):

        return {
            "system": "Domyślny (systemowy)",
            "light": "Jasny",
            "gray": "Szary",
            "black": "Czarny"
        }.get(
            self.theme,
            "Domyślny (systemowy)"
        )

    def windows_dark(self):

        if os.name != "nt":

            return (
                QApplication.palette()
                .color(QPalette.ColorRole.Window)
                .lightness() < 128
            )

        try:

            import winreg

            key = winreg.OpenKey(
                winreg.HKEY_CURRENT_USER,
                r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize"
            )

            value, _ = winreg.QueryValueEx(
                key,
                "AppsUseLightTheme"
            )

            return int(value) == 0

        except Exception:

            return False

    def apply_theme(self, theme):

        self.theme = theme

        self.save_settings()

        if theme == "system":

            effective = (
                "black"
                if self.windows_dark()
                else "light"
            )

        else:

            effective = theme

        palettes = {

            "light": (
                "#f7f8fa",
                "#ffffff",
                "#e8ebf0",
                "#20232a",
                "#d9dee7",
                "#e9edf3"
            ),

            "gray": (
                "#d9dde3",
                "#e8ebef",
                "#c5cbd4",
                "#20242b",
                "#b6bdc8",
                "#d0d5dd"
            ),

            "black": (
                "#090a0c",
                "#111318",
                "#20242b",
                "#f4f5f7",
                "#303640",
                "#292e37"
            )
        }

        bg, panel, address_bg, fg, border, hover = palettes[effective]

        self.setStyleSheet(f"""

            QWidget#root {{
                background:{bg};
                color:{fg};
            }}

            QWidget#toolbar {{
                background:{panel};
                border-bottom:1px solid {border};
            }}

            QWidget#content {{
                background:{bg};
            }}

            QWidget#status {{
                background:{panel};
                color:{fg};
            }}

            QTabBar::tab {{
                background:{panel};
                color:{fg};
                border:1px solid {border};
                border-bottom:0;
                padding:8px 13px;
                margin-right:3px;
                border-top-left-radius:9px;
                border-top-right-radius:9px;
                min-width:75px;
                max-width:210px;
            }}

            QTabBar::tab:selected {{
                background:{bg};
            }}

            QTabBar::tab:hover {{
                background:{hover};
            }}

            QLineEdit {{
                background:{address_bg};
                color:{fg};
                border:1px solid {border};
                border-radius:14px;
                padding:8px 14px;
                selection-background-color:#477edb;
            }}

            QToolButton, QPushButton {{
                background:{panel};
                color:{fg};
                border:1px solid {border};
                border-radius:10px;
                padding:5px;
                font-size:16px;
            }}

            QToolButton:hover, QPushButton:hover {{
                background:{hover};
            }}

            QMenu {{
                background:{panel};
                color:{fg};
                border:1px solid {border};
                padding:5px;
            }}

            QMenu::item {{
                padding:7px 22px;
                border-radius:5px;
            }}

            QMenu::item:selected {{
                background:{hover};
            }}

        """)

        # Powiadomienie wszystkich aktualnie otwartych stron
        # o zmianie preferowanego schematu kolorystycznego.
        for index in range(self.stack.count()):

            tab = self.stack.widget(index)

            if isinstance(tab, BrowserTab):

                self.update_page_theme(tab)

    def update_page_theme(self, tab):

        if self.theme == "system":

            scheme = (
                "dark"
                if self.windows_dark()
                else "light"
            )

        else:

            scheme = (
                "dark"
                if self.theme == "black"
                else "light"
            )

        script = """

        (() => {

            const scheme = "%s";

            let meta = document.querySelector(
                'meta[name="color-scheme"]'
            );

            if (!meta) {

                meta = document.createElement("meta");

                meta.name = "color-scheme";

                document.head.appendChild(meta);
            }

            meta.content = scheme;

            document.documentElement.style.colorScheme = scheme;

            document.documentElement.dataset.oazisTheme = scheme;

            window.dispatchEvent(
                new Event("oazis-theme-change")
            );

        })();

        """ % scheme

        tab.page.runJavaScript(script)

    def check_system_theme(self):

        if self.theme == "system":

            self.apply_theme("system")

    # --------------------------------------------------------
    # MINIATURY KART
    # --------------------------------------------------------

    def show_tab_preview(self, index):

        if index < 0 or index >= self.stack.count():
            return

        tab = self.stack.widget(index)

        if not isinstance(tab, BrowserTab):
            return

        if self.preview_popup is None:

            self.preview_popup = QFrame(
                self,
                Qt.WindowType.ToolTip
            )

            self.preview_popup.setStyleSheet("""
                QFrame {
                    background:rgba(30,33,41,245);
                    border:1px solid rgba(255,255,255,45);
                    border-radius:13px;
                }

                QLabel {
                    color:white;
                    border:0;
                }
            """)

            layout = QVBoxLayout(
                self.preview_popup
            )

            layout.setContentsMargins(
                8, 8, 8, 8
            )

            self.preview_image = QLabel()

            self.preview_image.setFixedSize(
                310, 175
            )

            self.preview_title = QLabel()
            self.preview_title.setWordWrap(True)

            layout.addWidget(
                self.preview_image
            )

            layout.addWidget(
                self.preview_title
            )

        pixmap = tab.view.grab().scaled(
            310,
            175,
            Qt.AspectRatioMode.KeepAspectRatio,
            Qt.TransformationMode.SmoothTransformation
        )

        self.preview_image.setPixmap(pixmap)

        self.preview_title.setText(
            tab.page.title()
            or tab.view.url().toString()
        )

        rect = self.tabs.tabRect(index)

        point = self.tabs.mapToGlobal(
            rect.bottomLeft()
        )

        self.preview_popup.move(
            point.x(),
            point.y() + 4
        )

        self.preview_popup.show()

    def hide_tab_preview(self):

        if self.preview_popup:
            self.preview_popup.hide()

    # --------------------------------------------------------
    # PEŁNY EKRAN
    # --------------------------------------------------------

    def set_web_fullscreen(self, enabled):

        if enabled:

            self.showFullScreen()

            self.titlebar.hide()
            self.status.hide()

            self.centralWidget().layout().itemAt(1).widget().hide()

        else:

            self.showNormal()

            self.titlebar.show()
            self.status.show()

            self.centralWidget().layout().itemAt(1).widget().show()

    def toggle_fullscreen(self):

        if self.isFullScreen():

            self.showNormal()

            self.titlebar.show()
            self.status.show()

        else:

            self.showFullScreen()

            self.titlebar.hide()
            self.status.hide()

    def toggle_maximize(self):

        if self.isMaximized():

            self.showNormal()

        else:

            self.showMaximized()

    # --------------------------------------------------------
    # ZAMYKANIE
    # --------------------------------------------------------

    def resizeEvent(self, event):

        super().resizeEvent(event)

        if hasattr(self, "toast") and self.toast.isVisible():

            self.toast.move(
                self.width() - self.toast.width() - 20,
                self.height() - self.toast.height() - 38
            )

    def closeEvent(self, event):

        self.save_settings()

        event.accept()


# ------------------------------------------------------------
# START
# ------------------------------------------------------------

def main():

    set_windows_app_id()

    app = QApplication(sys.argv)

    app.setApplicationName(APP_NAME)
    app.setOrganizationName(APP_NAME)

    app.setQuitOnLastWindowClosed(True)

    window = OazisBrowser()

    window.show()

    sys.exit(app.exec())


if __name__ == "__main__":

    main()