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
Notka prawna
Oazis jest programem w wersji beta, udostępnianym bez jakiejkolwiek gwarancji, w stanie „takim, jaki jest”. Korzystasz z niego na własną odpowiedzialność. Program jest wolnym oprogramowaniem na licencji GNU GPL v3 – pełne informacje znajdziesz na stronie Licencja. Jeśli rozpowszechniasz Oazis lub jego kod (także zmieniony), musisz wyraźnie napisać, że kod pochodzi od Mateusza Mecha (Oazis).
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()