217 lines
7.1 KiB
Python
Executable File
217 lines
7.1 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
"""
|
|
This uses the currently supported WebKit GTK, which is more up to date but also fatter.
|
|
|
|
WebKit is a huge mess and leaks all over the place. I'm not even sure about anything that's going on. Resources are taken up but only loosely released. You can start with as low as a 50MB memory load, but you will never go back to that. There's no apparent way to run JavaScript garbage collection, and I doubt it would help. -- Par of the course for JavaScript supporting browsers.
|
|
|
|
Good: This is a little less fat than Chrome, probably.. maybe.. at least at first
|
|
Bad: It still sucks
|
|
|
|
Prerequisites (Debian and cousins):
|
|
sudo apt install python3-gi python3-gi-cairo gir1.2-gtk-3.0 gir1.2-webkit2-4.0
|
|
|
|
Below "# Script start" you can find a setting for software mode, which you should comment out if you use a modern PC. I don't use the software rendering that comes included with WebKit, as it's unstable in my experience.
|
|
"""
|
|
|
|
import sys
|
|
|
|
oldexcepthook = sys.excepthook
|
|
def newexcepthook(type,value,traceback):
|
|
oldexcepthook(type,value,traceback)
|
|
#input("Press ENTER to quit.")
|
|
sys.excepthook = newexcepthook
|
|
|
|
import os
|
|
p = os.path.join
|
|
pUp = os.path.dirname
|
|
s = False
|
|
if getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'):
|
|
s = os.path.realpath(sys.executable)
|
|
else:
|
|
s = os.path.realpath(__file__)
|
|
sp = pUp(s)
|
|
|
|
# Script start
|
|
os.environ["LIBGL_ALWAYS_SOFTWARE"] = "1"
|
|
import gi
|
|
gi.require_version("Gtk","3.0")
|
|
gi.require_version("WebKit2","4.0")
|
|
from gi.repository import Gtk, WebKit2
|
|
import time
|
|
|
|
defaultProtocol = "https"
|
|
browserWindows = []
|
|
|
|
class emptyClass(): pass;
|
|
measure = emptyClass()
|
|
measure.toolbar = 22
|
|
|
|
def parseUrl(url):
|
|
if url.startswith("data:"): return "data",[],"",""
|
|
if url.startswith("blob:"): return "blob",[],"",""
|
|
urlSplit = url.split(":",1)
|
|
protocol = urlSplit[0]
|
|
urlSplit = urlSplit[1].lstrip("/").split("/",1)
|
|
if len(urlSplit) < 2: urlSplit.append("")
|
|
domain = urlSplit[0].split(".")
|
|
urlSplit = urlSplit[1].split("?",1)
|
|
if len(urlSplit) < 2: urlSplit.append("")
|
|
path = urlSplit[0]
|
|
arguments = urlSplit[1]
|
|
return protocol,domain,path,arguments
|
|
|
|
birdyWebContext = WebKit2.WebContext()
|
|
birdyWebContext.set_cache_model(WebKit2.CacheModel.DOCUMENT_VIEWER) # Does this even do anything at all?
|
|
birdyWebContext.set_spell_checking_enabled(False)
|
|
birdyWebContext.set_use_system_appearance_for_scrollbars(True)
|
|
|
|
birdyWebSettings = WebKit2.Settings.new()
|
|
#birdyWebSettings.set_auto_load_images(False)
|
|
birdyWebSettings.set_enable_developer_extras(False)
|
|
birdyWebSettings.set_enable_page_cache(False)
|
|
birdyWebSettings.set_hardware_acceleration_policy(WebKit2.HardwareAccelerationPolicy.NEVER)
|
|
defaultUserAgent = birdyWebSettings.get_user_agent()
|
|
singleProcessMode = False
|
|
remakeViewOnNavigation = False # Always entirely remake view on navigation, could break some websites - use for super low memory situations
|
|
|
|
def birdyWebViewConstructor(webView):
|
|
if webView and singleProcessMode:
|
|
return WebKit2.WebView.new_with_related_view(webView)
|
|
|
|
self = WebKit2.WebView.new_with_context(birdyWebContext)
|
|
self.set_settings(birdyWebSettings)
|
|
return self
|
|
|
|
class birdyBrowserWindow(Gtk.Window):
|
|
def __init__(self,webView,*args,**kwargs):
|
|
super().__init__(*args,**kwargs)
|
|
self.cTitle = "webkit-inabox-gtk"
|
|
self.set_title(self.cTitle)
|
|
self.cWidth = 640
|
|
self.cHeight = 480
|
|
self.resize(self.cWidth,self.cHeight)
|
|
self.connect("destroy",self.cCloseEvent)
|
|
self.connect("configure-event",self.cConfigureEvent)
|
|
self.cCreateElements(webView)
|
|
|
|
def cCreateElements(self,webView):
|
|
self.cMainBoxWrapper = Gtk.ScrolledWindow()
|
|
self.add(self.cMainBoxWrapper)
|
|
self.cMainBox = Gtk.Fixed()
|
|
self.cMainBoxWrapper.add(self.cMainBox)
|
|
self.cMenuBar = Gtk.MenuBar()
|
|
self.cMainBox.add(self.cMenuBar)
|
|
|
|
# Menu - File
|
|
self.cFileMenuButton = Gtk.MenuItem.new_with_label("File")
|
|
self.cFileMenu = Gtk.Menu()
|
|
self.cFileMenuNewWindow = Gtk.MenuItem.new_with_label("New window")
|
|
self.cFileMenuNewWindow.connect("activate",self.cOpenWindow)
|
|
self.cFileMenu.add(self.cFileMenuNewWindow)
|
|
self.cFileMenuButton.set_submenu(self.cFileMenu)
|
|
self.cMenuBar.add(self.cFileMenuButton)
|
|
|
|
# Menu - Loading indication
|
|
self.cMenuLoadingIndication = Gtk.MenuItem.new_with_label("Loading...")
|
|
self.cMenuBar.add(self.cMenuLoadingIndication)
|
|
|
|
homepage = "about:blank"
|
|
self.cLastUrl = "about:blank"
|
|
self.cUrlEntry = Gtk.Entry()
|
|
self.cUrlEntry.set_text(homepage)
|
|
#self.cUrlEntry.props.enable_emoji_completion = True # lol
|
|
self.cUrlEntry.connect("activate",self.cUrlEntryNavigate)
|
|
self.cMainBox.add(self.cUrlEntry)
|
|
self.cCreateWebView(webView)
|
|
self.cWebView.load_uri(homepage)
|
|
self.cResizeElements()
|
|
self.set_focus(self.cUrlEntry)
|
|
self.cUrlEntry.select_region(0,2)
|
|
self.show_all()
|
|
self.cMenuLoadingIndication.hide()
|
|
|
|
def cCreateWebView(self,webView):
|
|
self.cWebView = birdyWebViewConstructor(webView)
|
|
self.cWebView.connect("load-changed",self.cWebViewLoadChanged)
|
|
self.cWebView.connect("notify::uri",self.cUrlChanged)
|
|
self.cWebView.connect("notify::title",self.cTitleChanged)
|
|
self.cMainBox.add(self.cWebView)
|
|
|
|
def cResizeElements(self):
|
|
# cMenuBar
|
|
self.cMainBox.move(self.cMenuBar,0,0)
|
|
self.cMenuBar.set_size_request(self.cWidth,measure.toolbar)
|
|
|
|
# cUrlEntry
|
|
self.cMainBox.move(self.cUrlEntry,0,measure.toolbar)
|
|
self.cUrlEntry.set_size_request(self.cWidth,measure.toolbar)
|
|
|
|
# cWebView
|
|
self.cMainBox.move(self.cWebView,0,measure.toolbar * 2)
|
|
self.cWebView.set_size_request(self.cWidth,self.cHeight - (measure.toolbar * 2))
|
|
|
|
def cConfigureEvent(self,widget,event):
|
|
if event.width == self.cWidth and event.height == self.cHeight: return
|
|
self.cWidth = event.width
|
|
self.cHeight = event.height
|
|
self.cResizeElements()
|
|
|
|
def cCloseEvent(self,*args,**kwargs):
|
|
browserWindows.remove(self)
|
|
self.cWebView.destroy()
|
|
self.destroy()
|
|
if len(browserWindows) > 0: return
|
|
Gtk.main_quit()
|
|
|
|
def cUrlChanged(self,widget,prop):
|
|
url = widget.get_uri()
|
|
|
|
if url != "" and url != self.cLastUrl and remakeViewOnNavigation and not singleProcessMode:
|
|
time.sleep(1)
|
|
self.cLastUrl = url
|
|
self.cWebView.destroy()
|
|
self.cCreateWebView(False)
|
|
self.cResizeElements()
|
|
self.show_all()
|
|
self.cWebView.load_uri(url)
|
|
|
|
self.cLastUrl = url
|
|
if url == "about:blank": return
|
|
if url == "": return
|
|
if self.cUrlEntry.get_text() != url: self.cUrlEntry.set_text(url)
|
|
|
|
def cTitleChanged(self,widget,prop):
|
|
title = widget.get_title()
|
|
if title == "":
|
|
title = self.cWebView.get_uri()
|
|
if title == "": title = self.cLastUrl
|
|
self.set_title(title + " - " +self.cTitle)
|
|
|
|
def cWebViewLoadChanged(self,widget,event):
|
|
if event == WebKit2.LoadEvent.STARTED:
|
|
self.cMenuLoadingIndication.show()
|
|
|
|
if event == WebKit2.LoadEvent.FINISHED:
|
|
self.cMenuLoadingIndication.hide()
|
|
|
|
def cOpenWindow(self,*args,**kwargs):
|
|
browserWindows.append(birdyBrowserWindow(self.cWebView))
|
|
|
|
def cUrlEntryNavigate(self,*args,**kwargs):
|
|
url = self.cUrlEntry.get_text()
|
|
if len(url.split(":",1)) < 2:
|
|
url = defaultProtocol + "://" + url
|
|
|
|
self.set_focus(self.cWebView)
|
|
|
|
if not singleProcessMode:
|
|
self.cWebView.destroy()
|
|
self.cCreateWebView(False)
|
|
self.cResizeElements()
|
|
self.show_all()
|
|
|
|
self.cWebView.load_uri(url)
|
|
|
|
browserWindows.append(birdyBrowserWindow(False))
|
|
Gtk.main() |