← Back to branch summary

~gue5t/midori/throbber-sync

« back to all changes in this revision

Viewing changes to extensions/tabby.vala

  • Committer: Tarmac
  • Author(s): André Stösel
  • Date: 2013-10-11 19:40:36 UTC
  • mfrom: (6430.1.4 tabby-open-uris)
  • Revision ID: tarmac-20131011194036-1eubhnfqsucz73bo
handle urls as argument when starting midori

Show diffs side-by-side

added added

removed removed

Lines of Context:
extensions/tabby.vala
26
26
        public abstract void close ();
27
27
    }
28
28
 
 
29
    public enum SessionState {
 
30
        OPEN,
 
31
        CLOSED,
 
32
        RESTORING
 
33
    }
 
34
 
29
35
    namespace Base {
30
36
        /* each base class should connect to all necessary signals and provide an abstract function to handle them */
31
37
 
68
74
            protected GLib.SList<double?> tab_sorting;
69
75
 
70
76
            public Midori.Browser browser { get; protected set; }
 
77
            public SessionState state { get; protected set; default = SessionState.CLOSED; }
71
78
 
72
79
            public abstract void add_item (Katze.Item item);
73
80
            public abstract void uri_changed (Midori.View view, string uri);
78
85
            public abstract void tab_reordered (Gtk.Widget tab, uint pos);
79
86
 
80
87
            public abstract Katze.Array get_tabs ();
 
88
            public abstract double? get_max_sorting ();
81
89
 
82
90
            public void attach (Midori.Browser browser) {
83
91
                this.browser = browser;
90
98
                browser.delete_event.connect_after(this.delete_event);
91
99
                browser.notebook.page_reordered.connect_after (this.tab_reordered);
92
100
 
 
101
                this.state = SessionState.OPEN;
 
102
 
93
103
                foreach (Midori.View view in browser.get_tabs ()) {
94
104
                    this.tab_added (browser, view);
95
105
                    this.helper_data_changed (browser, view);
100
110
                this.browser = browser;
101
111
 
102
112
                Katze.Array tabs = this.get_tabs ();
 
113
                unowned Katze.Array? open_uris = browser.get_data ("tabby-open-uris");
103
114
 
104
 
                if(tabs.is_empty ()) {
 
115
                if(tabs.is_empty () && open_uris == null) {
105
116
                    Katze.Item item = new Katze.Item ();
106
117
                    item.uri = "about:home";
107
118
                    tabs.add_item (item);
115
126
                browser.delete_event.connect_after(this.delete_event);
116
127
                browser.notebook.page_reordered.connect_after (this.tab_reordered);
117
128
 
118
 
                GLib.List<unowned Katze.Item> items = tabs.get_items ();
 
129
                GLib.List<unowned Katze.Item> items = new GLib.List<unowned Katze.Item> ();
 
130
                if (open_uris != null) {
 
131
                    items.concat (open_uris.get_items ());
 
132
                }
 
133
                items.concat (tabs.get_items ());
119
134
                unowned GLib.List<unowned Katze.Item> u_items = items;
120
135
 
121
136
                bool delay = false;
122
137
 
 
138
                this.state = SessionState.RESTORING;
 
139
 
123
140
                GLib.Idle.add (() => {
124
141
                    /* Note: we need to use `items` for something to maintain a valid reference */
125
142
                    GLib.PtrArray new_tabs = new GLib.PtrArray ();
127
144
                        for (int i = 0; i < 3; i++) {
128
145
                            if (u_items == null) {
129
146
                                this.helper_reorder_tabs (new_tabs);
 
147
                                this.state = SessionState.OPEN;
130
148
                                return false;
131
149
                            }
132
150
 
146
164
                        }
147
165
                        this.helper_reorder_tabs (new_tabs);
148
166
                    }
149
 
                    return u_items != null;
 
167
                    if (u_items == null) {
 
168
                        this.state = SessionState.OPEN;
 
169
                        return false;
 
170
                    }
 
171
                    return true;
150
172
                });
151
173
            }
152
174
 
185
207
                }
186
208
 
187
209
                if (prev_meta_sorting == null)
188
 
                    prev_sorting = double.parse ("0");
 
210
                    if (this.state == SessionState.RESTORING)
 
211
                        prev_sorting = this.get_max_sorting ();
 
212
                    else
 
213
                        prev_sorting = double.parse ("0");
189
214
                else
190
215
                    prev_sorting = double.parse (prev_meta_sorting);
191
216
 
434
459
                 return tabs;
435
460
            }
436
461
 
 
462
            public override double? get_max_sorting () {
 
463
                string sqlcmd = "SELECT MAX(sorting) FROM tabs WHERE session_id = :session_id";
 
464
                Sqlite.Statement stmt;
 
465
                if (this.db.prepare_v2 (sqlcmd, -1, out stmt, null) != Sqlite.OK)
 
466
                    critical (_("Failed to select from database: %s"), db.errmsg ());
 
467
                stmt.bind_int64 (stmt.bind_parameter_index (":session_id"), this.id);
 
468
                int result = stmt.step ();
 
469
                if (!(result == Sqlite.DONE || result == Sqlite.ROW)) {
 
470
                    critical (_("Failed to select from database: %s"), db.errmsg ());
 
471
                } else if (result == Sqlite.ROW) {
 
472
                    double? sorting;
 
473
                    string? sorting_string = stmt.column_double (0).to_string ();
 
474
                    if (sorting_string != null) { /* we have to use a seperate if condition to avoid a `possibly unassigned local variable` error */
 
475
                        if (double.try_parse (sorting_string, out sorting)) {
 
476
                            return sorting;
 
477
                        }
 
478
                    }
 
479
                 }
 
480
 
 
481
                 return double.parse ("0");
 
482
            }
 
483
 
437
484
            internal Session (Sqlite.Database db) {
438
485
                this.db = db;
439
486
 
549
596
            return false;
550
597
        }
551
598
 
 
599
        private void set_open_uris (Midori.Browser browser) {
 
600
            Midori.App app = this.get_app ();
 
601
            unowned string?[] uris = app.get_data ("open-uris");
 
602
 
 
603
            if (uris != null) {
 
604
                Katze.Array tabs = new Katze.Array (typeof (Katze.Item));
 
605
 
 
606
                for(int i = 0; uris[i] != null; i++) {
 
607
                    Katze.Item item = new Katze.Item ();
 
608
                    item.name = uris[i];
 
609
                    item.uri = Midori.Sokoke.magic_uri (uris[i], true, true);
 
610
                    if (item.uri != null) {
 
611
                        tabs.add_item (item);
 
612
                    }
 
613
                }
 
614
                if (!tabs.is_empty()) {
 
615
                    browser.set_data ("tabby-open-uris", tabs);
 
616
                }
 
617
            }
 
618
 
 
619
            app.add_browser.disconnect (this.set_open_uris);
 
620
        }
 
621
 
552
622
        private void browser_added (Midori.Browser browser) {
553
623
            Base.Session session = browser.get_data<Base.Session> ("tabby-session");
554
624
            if (session == null) {
571
641
            /* FixMe: provide an option to replace Local.Storage with IStorage based Objects */
572
642
            this.storage = new Local.Storage (this.get_app ()) as Base.Storage;
573
643
 
574
 
            app.add_browser.connect (browser_added);
575
 
            app.remove_browser.connect (browser_removed);
 
644
            app.add_browser.connect (this.set_open_uris);
 
645
            app.add_browser.connect (this.browser_added);
 
646
            app.remove_browser.connect (this.browser_removed);
576
647
 
577
648
            GLib.Idle.add (this.load_session);
578
649
        }