save pc

Author: leopollini

config_files/browser_with_tabs.json

@@ -71,6 +71,16 @@
 			"enabled": true,
 			"actions":
 			{
+				"webpage_filter":
+				{
+					"enabled": true,
+					"hosts_whitelist": ["google"],
+					"hosts_blacklist": [],
+					"webpages_whitelist": [],
+					"webpages_blacklist": [],
+					"allow_navigation": true,
+					"extension": "webpage-filter"
+				},
 				"toolbar":
 				{
 					"enabled": true,

extensions/loader.js

@@ -80,6 +80,7 @@ class Loader2
 	{
 		try
 		{
+			if (!ext || !modules[ext]) return console.log(kleur.red("Error:"), ext, "is not a module!!");
 			const ModuleClass = require(modules[ext]);
 			if (typeof(ModuleClass) !== typeof(function () {}) || Object.getPrototypeOf(ModuleClass) !== BaseModule) { console.log(kleur.grey("Not loading " + ext + ": not a module")); return } ;
 			const t = new ModuleClass()

extensions/splashscreen/main.js

@@ -44,9 +44,9 @@ class Splashscreen extends require('../../lib/BaseModule')
         // setTimeout(TabsManager.setTab, 5000, mainTab);
     }
 
-    onNewTabCreated()
+    onNewTabCreated(newTab)
     {
-        this.tab.webContents.on('input-event', (e, input) => {
+        newTab.webContents.on('input-event', (e, input) => {
             this.inputed = true;
         });
         this.log('listener set');

extensions/tab_browser/new_page.html

@@ -6,18 +6,19 @@ const fs = require('fs');
 const icpChannel = require('../../lib/icpChannel');
 const Env = require('../../env');
 const { getPageTitle } = require('../../lib/utils');
+const BaseModule = require('../../lib/BaseModule');
+const kleur = require('kleur');
+const ipcChannel = require('../../lib/icpChannel');
 
 // Sample Module. Plase copy-paste this file into new module's main folder
-class Toolbar extends require('../../lib/BaseModule')
+class Toolbar extends BaseModule
 {
 	MODULE_NAME = "toolbar";    // MUST be the same as the 'extension' field in config.json
 	static toolbar_tab;
 	tabs_count = 0;
 	track_active_tab = false;
 	first_avoided = false;
 
-	// required_modules = ['window-events'];
-
 	onNewTabCreated(new_tab, old_tab)
 	{
 		new_tab.webContents.setWindowOpenHandler((details) => {
@@ -33,48 +34,67 @@ class Toolbar extends require('../../lib/BaseModule')
 	{
 		if (this.__conf.hidden != true)
 		{
-			Toolbar.toolbar_tab = new WebContentsView({
+			this.tab = new WebContentsView({
 			webPreferences: {
 				preload: path.join(__dirname, '../single_preload.js'),
 				additionalArguments: ['--load-only=' + path.join(__dirname, 'toolbar_preload.js')],
 				...Env.WEBVIEW_DEFAULT_PREFERENCES
 			}});
+			Toolbar.toolbar_tab = this.tab;
+			this.tab.tab_id = 'toolbar';
 
-			this.tab = Toolbar.toolbar_tab;
-
-			Toolbar.toolbar_tab.webContents.loadURL(url.format({
+			this.tab.webContents.loadURL(url.format({
 				pathname: path.join(__dirname, this.__conf.toolbar_html),
 				protocol: 'file'
 			}));
 
 			this.warn({height: this.__conf.toolbar_width});
 			if (this.__conf.default_url.protocol == 'file') this.__conf.default_url.pathname = path.join(__dirname, this.__conf.default_url.pathname);
-			TabsManager.newSideTab(Toolbar.toolbar_tab, 'toolbar', {height: this.__conf.toolbar_width});
+			TabsManager.newSideTab(this.tab, 'toolbar', {height: this.__conf.toolbar_width});
 			TabsManager.newDefaultBounds({y: this.__conf.toolbar_width});
 
-
-			this.newCtrlShortcut('r', () => { Toolbar.toolbar_tab.webContents.reload(); });
+			this.newCtrlShortcut('r', () => { this.tab.webContents.reload(); });
 
-			fs.watch(__dirname, (event) => {if (event == "change") {Toolbar.toolbar_tab.webContents.reload(); this.log(this.__conf.toolbar_html, "has been modified! Reloading toolbar.")}});
+			fs.watch(__dirname, (event) => {if (event == "change") {this.tab.webContents.reload(); this.log(this.__conf.toolbar_html, "has been modified! Reloading toolbar.")}});
 
 			icpChannel.newMainHandler('created-tab', (_, tab_url) => this.createNewTab(url.format(this.__conf.default_url)));
 			icpChannel.newMainHandler('switch-tab', (_, index) => this.setActiveTab(index));
-			icpChannel.newMainHandler('close-tab', (_, index) => this.closeTab(index));
+			icpChannel.newMainHandler('closed-tab', (_, index) => this.closeTab(TabsManager.idToName(index)));
 
-			Toolbar.toolbar_tab.webContents.openDevTools({mode: 'detach'});
+			this.tab.webContents.openDevTools({mode: 'detach'});
 		}
 	}
-
+	
 	late_setup()
 	{
+        this.tab.webContents.on('before-input-event', (event, input) => {
+			if (input.key)
+			{
+				this.warn("forwarding event to active tab");
+				TabsManager.getActiveTab().webContents.send('before-input-event', input);
+				event.preventDefault();
+			}
+		});
 		if (this.__conf.create_on_open == true)
 			this.requestNewTab();
 	}
 
 	// this method can be called from ANYWHERE (after initialization), thanks to the singleton behaviour of the modules.
 	async requestNewTab(req_url = this.__conf.default_url)
 	{
-		icpChannel.sendSignalToRender('create-tab', Toolbar.toolbar_tab, await this.createNewTab(typeof(req_url) == 'string' ? req_url : url.format(req_url), true));
+		icpChannel.sendSignalToRender('create-tab', this.tab, await this.createNewTab(typeof(req_url) == 'string' ? req_url : url.format(req_url), true));
+	}
+
+	static requestCloseTabId(tab_id)
+	{
+		Toolbar.requestCloseTab(TabsManager.getNameTab(tab_id));
+	}
+
+	static requestCloseTab(tab)
+	{
+		if (!tab || !tab.tab_id) return console.log('[', kleur.green("toolbar") , '] cannot close', tab && tab.tab_id);
+		console.log('[', kleur.green("toolbar") , '] closing', tab.tab_id);
+		icpChannel.sendSignalToRender('close-tab', Toolbar.toolbar_tab, tab.tab_id.substring(4));
 	}
 
 	// force_url can be set to true ONLY from this extension's context, NOT from the browser's new tab request
@@ -85,11 +105,10 @@ class Toolbar extends require('../../lib/BaseModule')
 			preload: path.join(__dirname, '../preload.js'), // Secure bridge
 			...Env.WEBVIEW_DEFAULT_PREFERENCES
 		}});
-		TabsManager.setNewTab(newTab, "tab_" + this.tabs_count++);
 		const tab_url = force_url ? requested_url : url.format(this.__conf.default_url);
 		newTab.webContents.loadURL(tab_url);
 		this.log("Created new tab at url:", tab_url);
-		return getPageTitle(newTab.webContents);
+		return {success: await TabsManager.newTab(newTab, "tab_" + this.tabs_count++), title: await getPageTitle(newTab.webContents)};
 	}
 
 	setActiveTab(index) {
@@ -98,9 +117,10 @@ class Toolbar extends require('../../lib/BaseModule')
 		// mainWindow.webContents.send("tab-switched", { index });
 	}
 
-	closeTab(tabId)
+	closeTab(tab_name)
 	{
-		TabsManager.closeTab(tabId);
+		this.log('renderer requested tab close')
+		TabsManager.closeTabName(tab_name);
 	}
 } 
 

extensions/tab_browser/main.js renamed to extensions/toolbar/main.js

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<body>
+
+<h1>The a target attribute</h1>
+
+<p>Open this very illegal webseit!: <a href="https://www.w3schools.com" target="_blank">Visit W3Schools!</a></p>
+<p>Or just the usual page example: <a href="https://www.google.com" target="_blank">Example!</a></p>
+
+</body>
+</html>

extensions/toolbar/new_page.html

@@ -62,6 +62,7 @@
 	<script>
 
 window.manage_tabs.onDoCreateTab(createTab);
+window.manage_tabs.onDoCloseTab(closeTabId);
 
 const tabBar = document.getElementById('tabBar');
 const viewContainer = document.getElementById('viewContainer');
@@ -71,19 +72,26 @@
 let activeTab = null;
 let tabCount = 0;
 
-newTabBtn.addEventListener('click', async () => {
+newTabBtn.addEventListener('click', request_tab, {once: true});
+
+function request_tab()
+{
 	console.log("new tab requested");
-	requestNewTab('asdasdasdasd');
-});
+	newTab('asdasdasdasd');
+}
 
-async function requestNewTab(title)
+async function newTab(content)
 {
 	activeTab = null;
-	createTab(await window.manage_tabs.createdTab(title));
+	createTab(await window.manage_tabs.createdTab(content));
+	
+	newTabBtn.removeEventListener('click', request_tab);
+	newTabBtn.addEventListener('click', request_tab, {once: true});
 }
 
-async function createTab(title) {
+async function createTab({title, success}) {
 	// create tab element
+	if (success != true) return console.log('page creation not succesful');
 	const tabEl = document.createElement('div');
 	tabEl.classList.add('tab');
 	tabEl.id = tabCount;
@@ -98,7 +106,6 @@
 
 	// event handlers
 	tabEl.addEventListener("click", () => {
-		window.manage_tabs.switchTab(parseInt(tabEl.dataset.index));
 		activateTab(tabEl);
 	});
 	closeBtn.addEventListener('click', (e) => {
@@ -111,21 +118,38 @@
 }
 
 function activateTab(tabEl) {
+	console.log('switching to', parseInt(tabEl.dataset.index));
+	window.manage_tabs.switchTab(parseInt(tabEl.dataset.index));
 	tabs.forEach(t => t.classList.remove("active"));
 	tabEl.classList.add("active");
 	activeTab = tabEl;
 }
 
-function closeTab(tabEl) {
-    tabs.pop(tabEl.dataset.index);
+function closeTabId(tabId)
+{
+    console.log("requested to close tab", tabId);
+	tabs.forEach(tab => {
+		if (tab.dataset.index === tabId)
+			removeTab(tab);
+	});
+}
+
+function removeTab(tabEl)
+{
+	console.log("ALL TABS:", tabs);
+	tabs = tabs.filter(tab => tab.dataset.index !== tabEl.dataset.index);
+	console.log("ALL TABS:", tabs);
+	tabEl.remove();
+	window.manage_tabs.closeTab(tabEl.dataset.index);
     if (tabs.length != 0)
-        activateTab(tabs[0]);
-    else
-        requestNewTab('asdasdasdasd');
-    console.log("closing tab");
-    tabEl.remove();
-    window.manage_tabs.closeTab(tabEl.dataset.index);
-    delete tabEl;
+		activateTab(tabs[0]);
+	else
+		newTab({title: 'asdasdasd', success: 'true'});
+}
+
+function closeTab(tabEl) {
+    console.log("closing tab", tabEl.dataset.index);
+	removeTab(tabEl);
 }
 	</script>
 </body>

extensions/tab_browser/toolbar.html renamed to extensions/toolbar/toolbar.html

@@ -1,14 +1,16 @@
 const { ipcRenderer } = require('electron');
+const BasePreload = require('../../lib/BasePreload.js');
 
-class Toolbar_preload extends require('../../lib/BasePreload.js')
+class Toolbar_preload extends BasePreload
 {
     MODULE_NAME = "toolbar";
 	contextbridge_expose = {
 		'manage_tabs': {
 			createdTab: (url) => ipcRenderer.invoke("created-tab", url),
 			switchTab: (index) => ipcRenderer.invoke("switch-tab", index),
-			closeTab: (index) => ipcRenderer.invoke("close-tab", index),
-			onDoCreateTab: (cb) => ipcRenderer.on("create-tab", (_, data) => cb(data))
+			closeTab: (index) => ipcRenderer.invoke("closed-tab", index),
+			onDoCreateTab: (cb) => ipcRenderer.on("create-tab", (_, data) => cb(data)),
+			onDoCloseTab: (cb) => ipcRenderer.on("close-tab", (_, data) => cb(data))
 		}
 	}
 

extensions/tab_browser/toolbar_preload.js renamed to extensions/toolbar/toolbar_preload.js

@@ -20,9 +20,9 @@ class DoubleClick extends require('../../lib/BaseModule')
 
     setup() {}
 
-    onNewTabCreated()
+    onNewTabCreated(newTab)
     {
-        this.tab.webContents.on('input-event', (event, input) => {
+        newTab.webContents.on('input-event', (event, input) => {
             if (input.type != 'mouseMove' && Env.VERBOSE)
                 this.log("sending an", input.type);
             switch(input.type)
@@ -67,12 +67,12 @@ class DoubleClick extends require('../../lib/BaseModule')
         if (this.__conf.disable_physical_keyboard == true && this.__conf.disable_virtual_keyboard == true)
         {
             this.warn("disabling keyboard");
-            this.tab.webContents.on("before-input-event", (event, input) => {if (input.type === 'keyDown' || input.type === 'keyUp') event.preventDefault();});
+            newTab.webContents.on("before-input-event", (event, input) => {if (input.type === 'keyDown' || input.type === 'keyUp') event.preventDefault();});
         }
         else if (this.__conf.disable_physical_keyboard == true)
         {
             this.warn("disabling physical keyboard");
-            this.tab.webContents.on("before-input-event", (event, input) => {
+            newTab.webContents.on("before-input-event", (event, input) => {
                 if (!this.mouseHasLeft && input.type === 'keyDown' || input.type === 'keyUp')
                 {   
                     event.preventDefault();
@@ -83,7 +83,7 @@ class DoubleClick extends require('../../lib/BaseModule')
         else if (this.__conf.disable_virtual_keyboard == true)
         {
             this.warn("disabling virtual keyboard");
-            this.tab.webContents.on("before-input-event", (event, input) => {
+            newTab.webContents.on("before-input-event", (event, input) => {
                 if (this.mouseHasLeft && input.type === 'keyDown' || input.type === 'keyUp')
                 {
                     event.preventDefault();

extensions/touch-utils/main.js

@@ -0,0 +1,45 @@
+const url = require('url');
+const Toolbar = require('../toolbar/main');
+const BaseModule = require('../../lib/BaseModule');
+
+class WebpageFilter extends BaseModule
+{
+	MODULE_NAME = 'webpage-filter';
+
+	setup()
+	{
+		if (this.__conf.hosts_blacklist)
+			this.log('Host blacklist:', this.__conf.hosts_blacklist);
+		if (this.__conf.hosts_whitelist)
+		this.log('Host whitelist:', this.__conf.hosts_whitelist);
+	}
+
+	onNewTabCreated(newTab)
+	{
+		newTab.webContents.once('did-start-navigation', (event, req_url) => {
+			this.warn('Checking url:', req_url);
+			if (this.isBadPage(url.parse(req_url)))
+				Toolbar.requestCloseTab(newTab);
+		});
+	}
+
+	// false -> page OK. true -> page NOT OK.
+	isBadPage(page_info)
+	{
+		this.warn('page info:', page_info);
+		let host = page_info.host;
+		const host_split = host.split('.');
+		if (host_split.length > 2)
+			host = host_split.slice(1, host_split.length - 1).join("");
+		this.warn('detected host:', host);
+		if (host == 'blank')
+			return false;
+		if (this.__conf.hosts_blacklist && this.__conf.hosts_blacklist.includes(host))
+			return true;
+		if (this.__conf.hosts_whitelist && this.__conf.hosts_whitelist.length != 0)
+			return this.__conf.hosts_whitelist.includes(host) ? false : true;
+		return false;
+	}
+}
+
+module.exports = WebpageFilter;