Merge lp:~midori/midori/per-site-preferences into lp:midori

[André Stösel]

Unmerged revisions

6530. By André Stösel on 2014-01-06

add old per-site-preferences extension (doesn't build)

=== added file 'extensions/per-site-preferences.vala'
--- extensions/per-site-preferences.vala	1970-01-01 00:00:00 +0000
+++ extensions/per-site-preferences.vala	2014-01-06 23:18:23 +0000
@@ -0,0 +1,328 @@
+/*
+   Copyright (C) 2011 André Stösel <[e-mail]>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   See the file COPYING for the full license text.
+*/
+
+using Gtk;
+using Soup;
+using WebKit;
+using Midori;
+
+/*
+    ToDo: it's possible that the request is reused (404 for favicon)
+*/
+
+private PSP.Manager? PSPMI; // var name "PSPManager" causes some vala error -> todo: report it
+
+namespace PSP {
+    namespace Actions {
+    }
+
+    namespace Conditions {
+        private interface NavigationPolicyDescision : GLib.Object {
+            public abstract bool match_navdes (WebKit.WebFrame p0, WebKit.NetworkRequest p1, WebKit.WebNavigationAction p2, WebKit.WebPolicyDecision p3);
+        }
+
+        private interface NewWindowsPolicyDescision : GLib.Object {
+            public abstract bool match_windes (WebKit.WebFrame p0, WebKit.NetworkRequest p1, WebKit.WebNavigationAction p2, WebKit.WebPolicyDecision p3);
+        }
+
+        private interface ResourceRequestStarting : GLib.Object {
+            public abstract bool match_resreq (WebFrame p0, WebResource p1, NetworkRequest p2, NetworkResponse? p3);
+        }
+
+
+        private abstract class Base : GLib.Object {
+            public string key; // unique! ToDo: check with some kind of metaclass or something like that | GType-Name?
+            public string name;
+            public string description;
+
+            public abstract bool is_ready ();
+        }
+
+        private class Uri : Base, NavigationPolicyDescision {
+            public string key = "uri-match";
+
+            private GLib.Regex? regex;
+
+            public override bool is_ready () {
+                if (this.regex != null) {
+                    return true;
+                }
+                return false;
+            }
+
+            public void set_pattern (string pattern) {
+                this.regex = new GLib.Regex (pattern, GLib.RegexCompileFlags.CASELESS);
+            }
+
+            public bool match_navdes (WebKit.WebFrame p0, WebKit.NetworkRequest p1, WebKit.WebNavigationAction p2, WebKit.WebPolicyDecision p3) {
+                return this.regex.match (p1.uri);
+            }
+        }
+    }
+
+    enum RuleOperator {
+        OR,
+        AND,
+        AND_NOT
+    }
+
+    private errordomain RuleError {
+        TYPE_ALREADY_DEFINED,
+        UNKNOWN_CONDITION_TYPE,
+        ILLEGAL_CONDITION_TYPE,
+        UNREADY_CONDITION
+    }
+
+    private class Rule : GLib.Object {
+        private GLib.Type? condition_type;
+        private RuleOperator operator;
+        private GLib.PtrArray actions;
+        private GLib.PtrArray conditions;
+
+        public void set_condition_type (GLib.Type type) throws RuleError {
+            if (this.condition_type == null) {
+                if (
+                    type == typeof (Conditions.NavigationPolicyDescision) ||
+                    type == typeof (Conditions.NewWindowsPolicyDescision) ||
+                    type == typeof (Conditions.ResourceRequestStarting)
+                ) {
+                    this.condition_type = type;
+                } else {
+                    throw new RuleError.UNKNOWN_CONDITION_TYPE ("Can't set unknown condition type!");
+                }
+            } else {
+                throw new RuleError.TYPE_ALREADY_DEFINED ("Condition type is already defined and can't be changed!");
+            }
+        }
+
+        public void add_condition (PSP.Conditions.Base condition) throws RuleError {
+            if (condition.is_ready () == true) {
+                if (Type.from_instance (condition).is_a (this.condition_type)) {
+                    condition.ref ();
+                    this.conditions.add (condition);
+                } else {
+                    throw new RuleError.ILLEGAL_CONDITION_TYPE ("One rule can only contain one type of conditions!");
+                }
+            } else {
+                throw new RuleError.UNREADY_CONDITION ("The condition must be fully initialized before it can be added to a rule!");
+            }
+        }
+
+        public void connect (Midori.View view) throws RuleError {
+            unowned WebKit.WebView web_view = view.web_view;
+            if (this.condition_type == typeof(Conditions.NavigationPolicyDescision)) {
+                web_view.navigation_policy_decision_requested.connect (this.navigation_policy_decision_requested);
+            } else {
+                throw new RuleError.UNKNOWN_CONDITION_TYPE ("Can't connect unknown condition type!");
+            }
+        }
+
+        public void disconnect (Midori.View view) throws RuleError {
+            unowned WebKit.WebView web_view = view.web_view;
+            if (this.condition_type == typeof(Conditions.NavigationPolicyDescision)) {
+                web_view.navigation_policy_decision_requested.disconnect (this.navigation_policy_decision_requested);
+            } else {
+                throw new RuleError.UNKNOWN_CONDITION_TYPE ("Can't disconnect unknown condition type!");
+            }
+        }
+
+        /* if return is true: decision was made -> break the loop */
+        private bool evaluate_match (bool condition, int index, ref bool rule) {
+            if (this.operator == RuleOperator.AND_NOT) {
+                if (condition == true && index == 0) {
+                    rule = true;
+                } else if(condition == true) {
+                    rule = false;
+                    return true;
+                }
+            } else if (this.operator == RuleOperator.AND) {
+                if (condition) {
+                    rule = true;
+                } else {
+                    rule = false;
+                    return true;
+                }
+            } else if (condition == true) { // RuleOperator is OR
+                rule = true;
+                return true;
+            }
+            return false;
+        }
+
+        public bool navigation_policy_decision_requested (WebKit.WebFrame p0, WebKit.NetworkRequest p1, WebKit.WebNavigationAction p2, WebKit.WebPolicyDecision p3) {
+            bool match_rule = false;
+            for (int i = 0; i < this.conditions.len; i++) {
+                Conditions.NavigationPolicyDescision condition = this.conditions.index (i) as Conditions.NavigationPolicyDescision;
+                bool match_condition = condition.match_navdes (p0, p1, p2, p3);
+                if (this.evaluate_match (match_condition, i, ref match_rule))
+                    break;
+            }
+
+            if (match_rule) {
+                stdout.printf("Rule matches!\n");
+                // do stuff
+            }
+
+            return false;
+        }
+
+        construct {
+            this.conditions = new GLib.PtrArray ();
+        }
+    }
+
+    private class Manager : GLib.Object {
+        private Midori.App app;
+        private GLib.PtrArray rules;
+        public void add_rules (GLib.PtrArray rules) {
+            foreach (var browser in this.app.get_browsers ()) {
+                foreach (var tab in browser.get_tabs ()) {
+                    this.tab_add_rules (tab, rules);
+                }
+            }
+
+            for (int i = 0; i < rules.len; i++) {
+                this.rules.add (rules.index (i));
+            }
+        }
+
+        public void remove_rules (GLib.PtrArray rules) {
+            foreach (var browser in this.app.get_browsers ()) {
+                foreach (var tab in browser.get_tabs ()) {
+                    this.tab_remove_rules (tab, rules);
+                }
+            }
+
+            for (int i = 0; i < rules.len; i++) {
+                this.rules.remove (rules.index (i));
+            }
+        }
+
+        private void tab_add_rules (Midori.View view, GLib.PtrArray rules) {
+            for (int i = 0; i < rules.len; i++) {
+                PSP.Rule rule = rules.index (i) as PSP.Rule;
+                rule.connect (view);
+            }
+        }
+
+        private void tab_remove_rules (Midori.View view, GLib.PtrArray rules) {
+            for (int i = 0; i < rules.len; i++) {
+                PSP.Rule rule = rules.index (i) as PSP.Rule;
+                rule.disconnect (view);
+            }
+        }
+
+        private void tab_added (Midori.Browser browser, Midori.View view) {
+            this.tab_add_rules (view, this.rules);
+        }
+
+        private void tab_removed (Midori.Browser browser, Midori.View view) {
+            this.tab_remove_rules (view, this.rules);
+        }
+
+        private void browser_added (Midori.Browser browser) {
+            foreach (var tab in browser.get_tabs ()) {
+                this.tab_added (browser, tab);
+            }
+            browser.add_tab.connect (this.tab_added);
+            browser.remove_tab.connect (tab_removed);
+        }
+
+        private void browser_removed (Midori.Browser browser) {
+            foreach (var tab in browser.get_tabs ()) {
+                tab_removed (browser, tab);
+            }
+            browser.add_tab.disconnect (tab_added);
+            browser.remove_tab.disconnect (tab_removed);
+        }
+
+        public void activated (Midori.App app) {
+            this.app = app;
+            foreach (var browser in app.get_browsers ()) {
+                browser_added (browser);
+            }
+            app.add_browser.connect (browser_added);
+        }
+
+        public void deactivated () {
+            foreach (var browser in this.app.get_browsers ()) {
+                browser_removed (browser);
+            }
+            this.app.add_browser.disconnect (browser_added);
+        }
+
+        construct {
+            this.rules = new GLib.PtrArray ();
+        }
+    }
+}
+
+namespace PSPExtensions {
+    private class Base : Midori.Extension {
+        private GLib.PtrArray rules;
+
+        public void activated (Midori.App app) {
+            if (PSPMI == null) {
+                PSPMI = new PSP.Manager ();
+                PSPMI.activated (app);
+            } else {
+                PSPMI.ref ();
+            }
+
+            PSPMI.add_rules (this.rules);
+        }
+
+        public void deactivated () {
+            uint rcount = PSPMI.ref_count;
+            PSPMI.remove_rules (this.rules);
+            if (rcount == 1) {
+                PSPMI.deactivated ();
+                PSPMI = null;
+            } else {
+                PSPMI.unref ();
+            }
+        }
+
+        public void add_rule (PSP.Rule rule) {
+            rule.ref ();
+            this.rules.add (rule);
+        }
+
+        construct {
+            this.rules = new GLib.PtrArray ();
+        }
+    }
+
+    private class Test : Base {
+        internal Test () {
+            GLib.Object (name: _("Just a test"),
+                         description: _("...."),
+                         version: "0.1",
+                         authors: "André Stösel <[e-mail]>");
+
+            activate.connect (this.activated);
+            deactivate.connect (this.deactivated);
+
+            PSP.Rule rule = new PSP.Rule ();
+            rule.set_condition_type (typeof (PSP.Conditions.NavigationPolicyDescision));
+            var c1 = new PSP.Conditions.Uri ();
+            c1.set_pattern ("pyit\\.de");
+            rule.add_condition (c1);
+
+            this.add_rule (rule);
+        }
+    }
+}
+
+public Midori.Extension extension_init () {
+    return new PSPExtensions.Test ();
+}
+