Merge lp:~midori/midori/openWith into lp:midori

[Cris Dywan]

Implement Open With extension dealing with file types

https://bugs.launchpad.net/midori/+bugs?field.tag=openwith

[lp:~midori/midori/openWith]

6583. By Paweł Forysiuk on 2014-02-24

Don't bother fetching hicon if path to executable is null, update code style a bit

6584. By Paweł Forysiuk on 2014-02-24

Merge lp:midori

6585. By Paweł Forysiuk on 2014-02-25

Add some sanity checks when feching hIcon

6586. By Cris Dywan on 2014-02-25

Implement Customize… menu item in Chooser

6587. By Cris Dywan on 2014-02-25

Add tooltip about customization to treeview

[Paweł Forysiuk (tuxator)]

review: Approve

=== modified file 'extensions/addons.c'
--- extensions/addons.c	2013-06-21 23:18:01 +0000
+++ extensions/addons.c	2014-02-25 19:27:20 +0000
@@ -485,8 +485,8 @@
         else
         {
             gchar* element_uri = g_filename_to_uri (element->fullpath, NULL, NULL);
-            sokoke_show_uri (NULL, element_uri,
-                             gtk_get_current_event_time (), NULL);
+            gboolean handled = FALSE;
+            g_signal_emit_by_name (midori_browser_get_current_tab (browser), "open-uri", element_uri, &handled);
             g_free (element_uri);
         }
 
@@ -522,8 +522,9 @@
     folder_uri = g_filename_to_uri (folder, NULL, NULL);
     g_free (folder);
 
-    sokoke_show_uri (gtk_widget_get_screen (GTK_WIDGET (addons->treeview)),
-                     folder_uri, gtk_get_current_event_time (), NULL);
+    MidoriBrowser* browser = midori_browser_get_for_widget (addons->treeview);
+    gboolean handled = FALSE;
+    g_signal_emit_by_name (midori_browser_get_current_tab (browser), "open-uri", folder_uri, &handled);
     g_free (folder_uri);
 }
 

=== added file 'extensions/open-with.vala'
--- extensions/open-with.vala	1970-01-01 00:00:00 +0000
+++ extensions/open-with.vala	2014-02-25 19:27:20 +0000
@@ -0,0 +1,802 @@
+/*
+   Copyright (C) 2014 Christian Dywan <[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.
+*/
+
+#if HAVE_WIN32
+namespace Sokoke {
+    extern static Gdk.Pixbuf get_gdk_pixbuf_from_win32_executable (string path);
+}
+#endif
+
+namespace ExternalApplications {
+    bool open_app_info (AppInfo app_info, string uri, string content_type) {
+        Midori.URI.recursive_fork_protection (uri, true);
+
+        try {
+            var uris = new List<File> ();
+            uris.append (File.new_for_uri (uri));
+            app_info.launch (uris, null);
+            new Associations ().remember (content_type, app_info);
+            return true;
+        } catch (Error error) {
+            warning ("Failed to open \"%s\": %s", uri, error.message);
+            return false;
+        }
+    }
+
+    class Associations : Object {
+#if HAVE_WIN32
+        string config_dir;
+        string filename;
+        KeyFile keyfile;
+
+        public Associations () {
+            config_dir = Midori.Paths.get_extension_config_dir ("open-with");
+            filename = Path.build_filename (config_dir, "config");
+            keyfile = new KeyFile ();
+
+            try {
+                keyfile.load_from_file (filename, KeyFileFlags.NONE);
+            } catch (FileError.NOENT exist_error) {
+                /* It's no error if no config file exists */
+            } catch (Error error) {
+                warning ("Failed to load associations: %s", error.message);
+            }
+        }
+
+        public bool open (string content_type, string uri) {
+            Midori.URI.recursive_fork_protection (uri, true);
+            try {
+                string commandline = keyfile.get_string ("mimes", content_type);
+                if ("%u" in commandline)
+                    commandline = commandline.replace ("%u", Shell.quote (uri));
+                else if ("%F" in commandline)
+                    commandline = commandline.replace ("%F", Shell.quote (Filename.from_uri (uri)));
+                return Process.spawn_command_line_async (commandline);
+            } catch (KeyFileError error) {
+                /* Not remembered before */
+                return false;
+            } catch (Error error) {
+                warning ("Failed to open \"%s\": %s", uri, error.message);
+                return false;
+            }
+        }
+
+        public void remember (string content_type, AppInfo app_info) throws Error {
+            keyfile.set_string ("mimes", content_type, get_commandline (app_info));
+            FileUtils.set_contents (filename, keyfile.to_data ());
+        }
+
+        public void custom (string content_type, string commandline, string name, string uri) {
+            keyfile.set_string ("mimes", content_type, commandline);
+            try {
+                FileUtils.set_contents (filename, keyfile.to_data ());
+            } catch (Error error) {
+                warning ("Failed to add remember custom command line for \"%s\": %s", uri, error.message);
+            }
+            open (content_type, uri);
+        }
+    }
+#else
+        public Associations () {
+        }
+
+        public bool open (string content_type, string uri) {
+            var app_info = AppInfo.get_default_for_type (content_type, false);
+            if (app_info == null)
+                return false;
+            return open_app_info (app_info, uri, content_type);
+        }
+
+        public void remember (string content_type, AppInfo app_info) throws Error {
+            app_info.set_as_last_used_for_type (content_type);
+            app_info.set_as_default_for_type (content_type);
+        }
+
+        public void custom (string content_type, string commandline, string name, string uri) {
+            try {
+                var app_info = AppInfo.create_from_commandline (commandline, name,
+                    "%u" in commandline ? AppInfoCreateFlags.SUPPORTS_URIS : AppInfoCreateFlags.NONE);
+                open_app_info (app_info, uri, content_type);
+            } catch (Error error) {
+                warning ("Failed to add custom command line for \"%s\": %s", uri, error.message);
+            }
+        }
+    }
+#endif
+
+    static string get_commandline (AppInfo app_info) {
+        return app_info.get_commandline () ?? app_info.get_executable ();
+    }
+
+    static string describe_app_info (AppInfo app_info) {
+        string name = app_info.get_display_name () ?? (Path.get_basename (app_info.get_executable ()));
+        string desc = app_info.get_description () ?? get_commandline (app_info);
+        return Markup.printf_escaped ("<b>%s</b>\n%s", name, desc);
+    }
+
+    static Icon? app_info_get_icon (AppInfo app_info) {
+        #if HAVE_WIN32
+        return Sokoke.get_gdk_pixbuf_from_win32_executable (app_info.get_executable ());
+        #else
+        return app_info.get_icon ();
+        #endif
+    }
+
+    class CustomizerDialog : Gtk.Dialog {
+        public Gtk.Entry name_entry;
+        public Gtk.Entry commandline_entry;
+
+        public CustomizerDialog (AppInfo app_info, Gtk.Widget widget) {
+            var browser = Midori.Browser.get_for_widget (widget);
+            transient_for = browser;
+
+            title = _("Custom…");
+#if !HAVE_GTK3
+            has_separator = false;
+#endif
+            destroy_with_parent = true;
+            set_icon_name (Gtk.STOCK_OPEN);
+            resizable = false;
+            add_buttons (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+                         Gtk.STOCK_SAVE, Gtk.ResponseType.ACCEPT);
+
+            var vbox = new Gtk.VBox (false, 8);
+            vbox.border_width = 8;
+            (get_content_area () as Gtk.Box).pack_start (vbox, true, true, 8);
+
+            var sizegroup = new Gtk.SizeGroup (Gtk.SizeGroupMode.HORIZONTAL);
+            var label = new Gtk.Label (_("Name:"));
+            sizegroup.add_widget (label);
+            label.set_alignment (0.0f, 0.5f);
+            vbox.pack_start (label, false, false, 0);
+            name_entry = new Gtk.Entry ();
+            name_entry.activates_default = true;
+            sizegroup.add_widget (name_entry);
+            vbox.pack_start (name_entry, true, true, 0);
+
+            label = new Gtk.Label (_("Command Line:"));
+            sizegroup.add_widget (label);
+            label.set_alignment (0.0f, 0.5f);
+            vbox.pack_start (label, false, false, 0);
+            commandline_entry = new Gtk.Entry ();
+            commandline_entry.activates_default = true;
+            sizegroup.add_widget (name_entry);
+            sizegroup.add_widget (commandline_entry);
+            vbox.pack_start (commandline_entry, true, true, 0);
+            get_content_area ().show_all ();
+            set_default_response (Gtk.ResponseType.ACCEPT);
+
+            name_entry.text = app_info.get_name ();
+            commandline_entry.text = get_commandline (app_info);
+        }
+    }
+
+    private class Chooser : Gtk.VBox {
+        Gtk.ListStore store = new Gtk.ListStore (1, typeof (AppInfo));
+        Gtk.TreeView treeview;
+        List<AppInfo> available;
+        string content_type;
+        string uri;
+
+        public Chooser (string uri, string content_type) {
+            this.content_type = content_type;
+            this.uri = uri;
+
+            Gtk.TreeViewColumn column;
+
+            treeview = new Gtk.TreeView.with_model (store);
+            treeview.headers_visible = false;
+
+            store.set_sort_column_id (0, Gtk.SortType.ASCENDING);
+            store.set_sort_func (0, tree_sort_func);
+
+            column = new Gtk.TreeViewColumn ();
+            Gtk.CellRendererPixbuf renderer_icon = new Gtk.CellRendererPixbuf ();
+            column.pack_start (renderer_icon, false);
+            column.set_cell_data_func (renderer_icon, on_render_icon);
+            treeview.append_column (column);
+
+            column = new Gtk.TreeViewColumn ();
+            column.set_sizing (Gtk.TreeViewColumnSizing.AUTOSIZE);
+            Gtk.CellRendererText renderer_text = new Gtk.CellRendererText ();
+            column.pack_start (renderer_text, true);
+            column.set_expand (true);
+            column.set_cell_data_func (renderer_text, on_render_text);
+            treeview.append_column (column);
+
+            treeview.row_activated.connect (row_activated);
+            treeview.show ();
+            var scrolled = new Gtk.ScrolledWindow (null, null);
+            scrolled.set_policy (Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
+            scrolled.add (treeview);
+            pack_start (scrolled);
+            int height;
+            treeview.create_pango_layout ("a\nb").get_pixel_size (null, out height);
+            scrolled.set_size_request (-1, height * 5);
+            treeview.button_release_event.connect (button_released);
+            treeview.tooltip_text = _("Right-click a suggestion to customize it");
+
+            available = new List<AppInfo> ();
+            foreach (var app_info in AppInfo.get_all_for_type (content_type))
+                launcher_added (app_info, uri);
+
+            if (store.iter_n_children (null) < 1) {
+                foreach (var app_info in AppInfo.get_all ())
+                    launcher_added (app_info, uri);
+            }
+        }
+
+        bool button_released (Gdk.EventButton event) {
+            if (event.button == 3)
+                return show_popup_menu (event);
+            return false;
+        }
+
+        bool show_popup_menu (Gdk.EventButton? event) {
+            Gtk.TreeIter iter;
+            if (treeview.get_selection ().get_selected (null, out iter)) {
+                AppInfo app_info;
+                store.get (iter, 0, out app_info);
+
+                var menu = new Gtk.Menu ();
+                var menuitem = new Gtk.ImageMenuItem.with_mnemonic (_("Custom…"));
+                menuitem.image = new Gtk.Image.from_stock (Gtk.STOCK_EDIT, Gtk.IconSize.MENU);
+                menuitem.activate.connect (() => {
+                    customize_app_info (app_info, content_type, uri);
+                });
+                menu.append (menuitem);
+                menu.show_all ();
+                Katze.widget_popup (treeview, menu, null, Katze.MenuPos.CURSOR);
+
+                return true;
+            }
+            return false;
+        }
+
+        void customize_app_info (AppInfo app_info, string content_type, string uri) {
+            var dialog = new CustomizerDialog (app_info, this);
+            bool accept = dialog.run () == Gtk.ResponseType.ACCEPT;
+            if (accept) {
+                string name = dialog.name_entry.text;
+                string commandline = dialog.commandline_entry.text;
+                new Associations ().custom (content_type, commandline, name, uri);
+                customized (app_info, content_type, uri);
+            }
+            dialog.destroy ();
+        }
+
+        public List<AppInfo> get_available () {
+            return available.copy ();
+        }
+
+        public AppInfo get_app_info () {
+            Gtk.TreeIter iter;
+            if (treeview.get_selection ().get_selected (null, out iter)) {
+                AppInfo app_info;
+                store.get (iter, 0, out app_info);
+                return app_info;
+            }
+            assert_not_reached ();
+        }
+
+        void on_render_icon (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            AppInfo app_info;
+            model.get (iter, 0, out app_info);
+
+            renderer.set ("gicon", app_info_get_icon (app_info),
+                          "stock-size", Gtk.IconSize.DIALOG,
+                          "xpad", 4);
+        }
+
+        void on_render_text (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            AppInfo app_info;
+            model.get (iter, 0, out app_info);
+            renderer.set ("markup", describe_app_info (app_info),
+                          "ellipsize", Pango.EllipsizeMode.END);
+        }
+
+        void launcher_added (AppInfo app_info, string uri) {
+            if (!app_info.should_show ())
+                return;
+
+            Gtk.TreeIter iter;
+            store.append (out iter);
+            store.set (iter, 0, app_info);
+
+            available.append (app_info);
+        }
+
+        int tree_sort_func (Gtk.TreeModel model, Gtk.TreeIter a, Gtk.TreeIter b) {
+            AppInfo app_info1, app_info2;
+            model.get (a, 0, out app_info1);
+            model.get (b, 0, out app_info2);
+            return strcmp (app_info1.get_display_name (), app_info2.get_display_name ());
+        }
+
+        void row_activated (Gtk.TreePath path, Gtk.TreeViewColumn column) {
+            Gtk.TreeIter iter;
+            if (store.get_iter (out iter, path)) {
+                AppInfo app_info;
+                store.get (iter, 0, out app_info);
+                selected (app_info);
+            }
+        }
+
+        public signal void selected (AppInfo app_info);
+        public signal void customized (AppInfo app_info, string content_type, string uri);
+    }
+
+    class ChooserDialog : Gtk.Dialog {
+        public Chooser chooser { get; private set; }
+
+        public ChooserDialog (string uri, string content_type, Gtk.Widget widget) {
+            string filename;
+            if (uri.has_prefix ("file://"))
+                filename = Midori.Download.get_basename_for_display (uri);
+            else
+                filename = uri;
+
+            var browser = Midori.Browser.get_for_widget (widget);
+            transient_for = browser;
+
+            title = _("Choose application");
+#if !HAVE_GTK3
+            has_separator = false;
+#endif
+            destroy_with_parent = true;
+            set_icon_name (Gtk.STOCK_OPEN);
+            resizable = false;
+            add_buttons (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
+                         Gtk.STOCK_OPEN, Gtk.ResponseType.ACCEPT);
+
+            var vbox = new Gtk.VBox (false, 8);
+            vbox.border_width = 8;
+            (get_content_area () as Gtk.Box).pack_start (vbox, true, true, 8);
+            var label = new Gtk.Label (_("Select an application to open \"%s\"".printf (filename)));
+            label.ellipsize = Pango.EllipsizeMode.MIDDLE;
+            vbox.pack_start (label, false, false, 0);
+            if (uri == "")
+                label.no_show_all = true;
+            chooser = new Chooser (uri, content_type);
+            vbox.pack_start (chooser, true, true, 0);
+
+            get_content_area ().show_all ();
+            set_default_response (Gtk.ResponseType.ACCEPT);
+            chooser.selected.connect ((app_info) => {
+                response (Gtk.ResponseType.ACCEPT);
+            });
+            chooser.customized.connect ((app_info, content_type, uri) => {
+                response (Gtk.ResponseType.CANCEL);
+            });
+        }
+
+        public AppInfo? open_with () {
+            show ();
+            bool accept = run () == Gtk.ResponseType.ACCEPT;
+            hide ();
+
+            if (!accept)
+                return null;
+            return chooser.get_app_info ();
+        }
+    }
+
+    class ChooserButton : Gtk.Button {
+        public AppInfo? app_info { get; set; }
+        public string? commandline { get; set; }
+        ChooserDialog dialog;
+        Gtk.Label app_name;
+        Gtk.Image icon;
+
+        public ChooserButton (string mime_type, string? commandline) {
+            string content_type = ContentType.from_mime_type (mime_type);
+            dialog = new ChooserDialog ("", content_type, this);
+            app_info = null;
+            foreach (var candidate in dialog.chooser.get_available ()) {
+                if (get_commandline (candidate) == commandline)
+                    app_info = candidate;
+            }
+
+            var hbox = new Gtk.HBox (false, 4);
+            icon = new Gtk.Image ();
+            hbox.pack_start (icon, false, false, 0);
+            app_name = new Gtk.Label (null);
+            app_name.use_markup = true;
+            app_name.ellipsize = Pango.EllipsizeMode.END;
+            hbox.pack_start (app_name, true, true, 0);
+            add (hbox);
+            show_all ();
+            update_label ();
+
+            clicked.connect (() => {
+                app_info = dialog.open_with ();
+                string new_commandline = app_info != null ? get_commandline (app_info) : null;
+                commandline = new_commandline;
+                selected (new_commandline);
+                update_label ();
+            });
+        }
+
+        void update_label () {
+            app_name.label = app_info != null ? describe_app_info (app_info).replace ("\n", " ") : _("None");
+            icon.set_from_gicon (app_info != null ? app_info_get_icon (app_info) : null, Gtk.IconSize.BUTTON);
+        }
+
+        public signal void selected (string? commandline);
+    }
+
+    class Types : Gtk.VBox {
+        public Gtk.ListStore store = new Gtk.ListStore (2, typeof (string), typeof (AppInfo));
+        Gtk.TreeView treeview;
+
+        public Types () {
+            Gtk.TreeViewColumn column;
+
+            treeview = new Gtk.TreeView.with_model (store);
+            treeview.headers_visible = false;
+
+            store.set_sort_column_id (0, Gtk.SortType.ASCENDING);
+            store.set_sort_func (0, tree_sort_func);
+
+            column = new Gtk.TreeViewColumn ();
+            column.set_sizing (Gtk.TreeViewColumnSizing.AUTOSIZE);
+            Gtk.CellRendererPixbuf renderer_type_icon = new Gtk.CellRendererPixbuf ();
+            column.pack_start (renderer_type_icon, false);
+            column.set_cell_data_func (renderer_type_icon, on_render_type_icon);
+            treeview.append_column (column);
+
+            column = new Gtk.TreeViewColumn ();
+            column.set_sizing (Gtk.TreeViewColumnSizing.AUTOSIZE);
+            Gtk.CellRendererText renderer_type_text = new Gtk.CellRendererText ();
+            column.pack_start (renderer_type_text, true);
+            column.set_cell_data_func (renderer_type_text, on_render_type_text);
+            treeview.append_column (column);
+
+            column = new Gtk.TreeViewColumn ();
+            column.set_sizing (Gtk.TreeViewColumnSizing.AUTOSIZE);
+            Gtk.CellRendererPixbuf renderer_icon = new Gtk.CellRendererPixbuf ();
+            column.pack_start (renderer_icon, false);
+            column.set_cell_data_func (renderer_icon, on_render_icon);
+            treeview.append_column (column);
+
+            column = new Gtk.TreeViewColumn ();
+            column.set_sizing (Gtk.TreeViewColumnSizing.AUTOSIZE);
+            Gtk.CellRendererText renderer_text = new Gtk.CellRendererText ();
+            column.pack_start (renderer_text, true);
+            column.set_expand (true);
+            column.set_cell_data_func (renderer_text, on_render_text);
+            treeview.append_column (column);
+
+            treeview.row_activated.connect (row_activated);
+            treeview.show ();
+            var scrolled = new Gtk.ScrolledWindow (null, null);
+            scrolled.set_policy (Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC);
+            scrolled.add (treeview);
+            pack_start (scrolled);
+            int height;
+            treeview.create_pango_layout ("a\nb").get_pixel_size (null, out height);
+            scrolled.set_size_request (-1, height * 5);
+
+            foreach (string content_type in ContentType.list_registered ())
+                launcher_added (content_type);
+            foreach (string scheme in Vfs.get_default ().get_supported_uri_schemes ())
+                launcher_added ("x-scheme-handler/" + scheme);
+
+            treeview.size_allocate.connect_after ((allocation) => {
+                treeview.columns_autosize ();
+            });
+        }
+
+        void on_render_type_icon (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            string content_type;
+            store.get (iter, 0, out content_type);
+
+            renderer.set ("gicon", ContentType.get_icon (content_type),
+                          "stock-size", Gtk.IconSize.BUTTON,
+                          "xpad", 4);
+        }
+
+        void on_render_type_text (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            string content_type;
+            AppInfo app_info;
+            store.get (iter, 0, out content_type, 1, out app_info);
+
+            string desc, mime_type;
+            if (content_type.has_prefix ("x-scheme-handler/")) {
+                desc = content_type.split ("/")[1] + "://";
+                mime_type = "";
+            } else {
+                desc = ContentType.get_description (content_type);
+                mime_type = ContentType.get_mime_type (content_type);
+            }
+
+            renderer.set ("markup",
+                Markup.printf_escaped ("<b>%s</b>\n%s",
+                    desc, mime_type),
+#if HAVE_GTK3
+                          "max-width-chars", 30,
+#else
+                          "width-chars", 30,
+#endif
+                          "ellipsize", Pango.EllipsizeMode.END);
+        }
+
+        void on_render_icon (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            AppInfo app_info;
+            model.get (iter, 1, out app_info);
+
+            renderer.set ("gicon", app_info_get_icon (app_info),
+                          "stock-size", Gtk.IconSize.MENU,
+                          "xpad", 4);
+        }
+
+        void on_render_text (Gtk.CellLayout column, Gtk.CellRenderer renderer,
+            Gtk.TreeModel model, Gtk.TreeIter iter) {
+
+            AppInfo app_info;
+            model.get (iter, 1, out app_info);
+            renderer.set ("markup", describe_app_info (app_info),
+                          "ellipsize", Pango.EllipsizeMode.END);
+        }
+
+        void launcher_added (string content_type) {
+            var app_info = AppInfo.get_default_for_type (content_type, false);
+            if (app_info == null)
+                return;
+
+            Gtk.TreeIter iter;
+            store.append (out iter);
+            store.set (iter, 0, content_type, 1, app_info);
+        }
+
+        int tree_sort_func (Gtk.TreeModel model, Gtk.TreeIter a, Gtk.TreeIter b) {
+            string content_type1, content_type2;
+            model.get (a, 0, out content_type1);
+            model.get (b, 0, out content_type2);
+            return strcmp (content_type1, content_type2);
+        }
+
+        void row_activated (Gtk.TreePath path, Gtk.TreeViewColumn column) {
+            Gtk.TreeIter iter;
+            if (store.get_iter (out iter, path)) {
+                string content_type;
+                store.get (iter, 0, out content_type);
+                selected (content_type, iter);
+            }
+        }
+
+        public signal void selected (string content_type, Gtk.TreeIter iter);
+    }
+
+
+    private class Manager : Midori.Extension {
+        enum NextStep {
+            TRY_OPEN,
+            OPEN_WITH
+        }
+
+        bool open_uri (Midori.Tab tab, string uri) {
+            return open_with_type (uri, get_content_type (uri, null), tab, NextStep.TRY_OPEN);
+        }
+
+        bool navigation_requested (WebKit.WebView web_view, WebKit.WebFrame frame, WebKit.NetworkRequest request,
+            WebKit.WebNavigationAction action, WebKit.WebPolicyDecision decision) {
+
+            string uri = request.uri;
+            if (Midori.URI.is_http (uri) || Midori.URI.is_blank (uri))
+                return false;
+
+            decision.ignore ();
+
+            string content_type = get_content_type (uri, null);
+            open_with_type (uri, content_type, web_view, NextStep.TRY_OPEN);
+            return true;
+        }
+
+        string get_content_type (string uri, string? mime_type) {
+            if (!uri.has_prefix ("file://") && !Midori.URI.is_http (uri)) {
+                string protocol = uri.split(":", 2)[0];
+                return "x-scheme-handler/" + protocol;
+            } else if (mime_type == null) {
+                string filename;
+                bool uncertain;
+                try {
+                    filename = Filename.from_uri (uri);
+                } catch (Error error) {
+                    filename = uri;
+                }
+                return ContentType.guess (filename, null, out uncertain);
+            }
+            return ContentType.from_mime_type (mime_type);
+        }
+
+        bool open_with_type (string uri, string content_type, Gtk.Widget widget, NextStep next_step) {
+            #if HAVE_WEBKIT2
+            return open_now (uri, content_type, widget, next_step);
+            #else
+            if (!Midori.URI.is_http (uri))
+                return open_now (uri, content_type, widget, next_step);
+
+            var download = new WebKit.Download (new WebKit.NetworkRequest (uri));
+            download.destination_uri = Midori.Download.prepare_destination_uri (download, null);
+            if (!Midori.Download.has_enough_space (download, download.destination_uri))
+                return false;
+
+            download.notify["status"].connect ((pspec) => {
+                if (download.status == WebKit.DownloadStatus.FINISHED) {
+                    open_now (download.destination_uri, content_type, widget, next_step);
+                }
+                else if (download.status == WebKit.DownloadStatus.ERROR)
+                    Midori.show_message_dialog (Gtk.MessageType.ERROR,
+                        _("Error downloading the image!"),
+                        _("Can not download selected image."), false);
+            });
+            download.start ();
+            return true;
+            #endif
+        }
+
+        bool open_now (string uri, string content_type, Gtk.Widget widget, NextStep next_step) {
+            if (next_step == NextStep.TRY_OPEN && (new Associations ()).open (content_type, uri))
+                return true;
+            if (open_with (uri, content_type, widget) != null)
+                return true;
+            return false;
+        }
+
+        AppInfo? open_with (string uri, string content_type, Gtk.Widget widget) {
+            var dialog = new ChooserDialog (uri, content_type, widget);
+
+            var app_info = dialog.open_with ();
+            dialog.destroy ();
+
+            if (uri == "")
+                return app_info;
+
+            if (app_info == null)
+                return app_info;
+
+            return open_app_info (app_info, uri, content_type) ? app_info : null;
+        }
+
+        void context_menu (Midori.Tab tab, WebKit.HitTestResult hit_test_result, Midori.ContextAction menu) {
+            if ((hit_test_result.context & WebKit.HitTestResultContext.LINK) != 0)  {
+                string uri = hit_test_result.link_uri;
+                var action = new Gtk.Action ("OpenWith", _("Open _with…"), null, null);
+                action.activate.connect ((action) => {
+                    open_with_type (uri, get_content_type (uri, null), tab, NextStep.OPEN_WITH);
+                });
+                menu.add (action);
+            }
+#if !HAVE_WEBKIT2
+            if ((hit_test_result.context & WebKit.HitTestResultContext.IMAGE) != 0) {
+                string uri = hit_test_result.image_uri;
+                var action = new Gtk.Action ("OpenImageInViewer", _("Open in Image _Viewer"), null, null);
+                action.activate.connect ((action) => {
+                    open_with_type (uri, get_content_type (uri, null), tab, NextStep.TRY_OPEN);
+                });
+                menu.add (action);
+            }
+#endif
+        }
+
+        void show_preferences (Katze.Preferences preferences) {
+            var settings = get_app ().settings;
+            var category = preferences.add_category (_("File Types"), Gtk.STOCK_FILE);
+            preferences.add_group (null);
+
+            var sizegroup = new Gtk.SizeGroup (Gtk.SizeGroupMode.HORIZONTAL);
+            var label = new Gtk.Label (_("Text Editor"));
+            sizegroup.add_widget (label);
+            label.set_alignment (0.0f, 0.5f);
+            preferences.add_widget (label, "indented");
+            var entry = new ChooserButton ("text/plain", settings.text_editor);
+            sizegroup.add_widget (entry);
+            entry.selected.connect ((commandline) => {
+                settings.text_editor = commandline;
+            });
+            preferences.add_widget (entry, "spanned");
+
+            label = new Gtk.Label (_("News Aggregator"));
+            sizegroup.add_widget (label);
+            label.set_alignment (0.0f, 0.5f);
+            preferences.add_widget (label, "indented");
+            entry = new ChooserButton ("application/rss+xml", settings.news_aggregator);
+            sizegroup.add_widget (entry);
+            entry.selected.connect ((commandline) => {
+                settings.news_aggregator = commandline;
+            });
+            preferences.add_widget (entry, "spanned");
+
+            var types = new Types ();
+            types.selected.connect ((content_type, iter) => {
+                var app_info = open_with ("", content_type, preferences);
+                if (app_info == null)
+                    return;
+                try {
+                    app_info.set_as_default_for_type (content_type);
+                    types.store.set (iter, 1, app_info);
+                } catch (Error error) {
+                    warning ("Failed to select default for \"%s\": %s", content_type, error.message);
+                }
+            });
+            category.pack_start (types, true, true, 0);
+            types.show_all ();
+        }
+
+        public void tab_added (Midori.Browser browser, Midori.View view) {
+            view.web_view.navigation_policy_decision_requested.connect (navigation_requested);
+            view.open_uri.connect (open_uri);
+            view.context_menu.connect (context_menu);
+        }
+
+        public void tab_removed (Midori.Browser browser, Midori.View view) {
+            view.web_view.navigation_policy_decision_requested.disconnect (navigation_requested);
+            view.open_uri.disconnect (open_uri);
+            view.context_menu.disconnect (context_menu);
+        }
+
+        void browser_added (Midori.Browser browser) {
+            foreach (var tab in browser.get_tabs ())
+                tab_added (browser, tab);
+            browser.add_tab.connect (tab_added);
+            browser.remove_tab.connect (tab_removed);
+            browser.show_preferences.connect (show_preferences);
+        }
+
+        void activated (Midori.App app) {
+            foreach (var browser in app.get_browsers ())
+                browser_added (browser);
+            app.add_browser.connect (browser_added);
+        }
+
+        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);
+            browser.show_preferences.disconnect (show_preferences);
+        }
+
+        void deactivated () {
+            var app = get_app ();
+            foreach (var browser in app.get_browsers ())
+                browser_removed (browser);
+            app.add_browser.disconnect (browser_added);
+
+        }
+
+        internal Manager () {
+            GLib.Object (name: "External Applications",
+                         description: "Choose what to open unknown file types with",
+                         version: "0.1" + Midori.VERSION_SUFFIX,
+                         authors: "Christian Dywan <[e-mail]>");
+
+            this.activate.connect (activated);
+            this.deactivate.connect (deactivated);
+        }
+    }
+}
+
+public Midori.Extension extension_init () {
+    return new ExternalApplications.Manager ();
+}
+

=== modified file 'extensions/transfers.vala'
--- extensions/transfers.vala	2014-01-06 21:51:09 +0000
+++ extensions/transfers.vala	2014-02-25 19:27:20 +0000
@@ -14,7 +14,6 @@
 }
 
 namespace Sokoke {
-    extern static bool show_uri (Gdk.Screen screen, string uri, uint32 timestamp) throws Error;
     extern static void widget_get_text_size (Gtk.Widget widget, string sample, out int width, out int height);
 }
 
@@ -214,12 +213,8 @@
                 menuitem = new Gtk.ImageMenuItem.with_mnemonic (_("Open Destination _Folder"));
                 menuitem.image = new Gtk.Image.from_stock (Gtk.STOCK_DIRECTORY, Gtk.IconSize.MENU);
                 menuitem.activate.connect (() => {
-                    try {
-                        var folder = GLib.File.new_for_uri (transfer.destination);
-                        Sokoke.show_uri (get_screen (), folder.get_parent ().get_uri (), 0);
-                    } catch (Error error_folder) {
-                        GLib.warning (_("Failed to open download: %s"), error_folder.message);
-                    }
+                    var folder = GLib.File.new_for_uri (transfer.destination);
+                    (Midori.Browser.get_for_widget (this).tab as Midori.Tab).open_uri (folder.get_parent ().get_uri ());
                 });
                 menu.append (menuitem);
                 menuitem = new Gtk.ImageMenuItem.with_mnemonic (_("Copy Link Loc_ation"));

=== modified file 'katze/katze-utils.c'
--- katze/katze-utils.c	2013-11-05 21:51:18 +0000
+++ katze/katze-utils.c	2014-02-25 19:27:20 +0000
@@ -101,78 +101,12 @@
 }
 #endif
 
-static const gchar*
-katze_app_info_get_commandline (GAppInfo* info)
-{
-    const gchar* exe;
-
-    exe = g_app_info_get_commandline (info);
-    if (!exe)
-        exe = g_app_info_get_executable (info);
-    if (!exe)
-        exe = g_app_info_get_name (info);
-    return exe;
-}
-
 static gboolean
 proxy_entry_focus_out_event_cb (GtkEntry*      entry,
                                 GdkEventFocus* event,
                                 GObject*       object);
 
 static void
-proxy_combo_box_apps_changed_cb (GtkComboBox* button,
-                                 GObject*     object)
-{
-    guint active = gtk_combo_box_get_active (button);
-    GtkTreeModel* model = gtk_combo_box_get_model (button);
-    GtkTreeIter iter;
-
-    if (gtk_tree_model_iter_nth_child (model, &iter, NULL, active))
-    {
-        GAppInfo* info;
-        gboolean use_entry;
-        GtkWidget* child;
-        const gchar* exe;
-        const gchar* property = g_object_get_data (G_OBJECT (button), "property");
-
-        gtk_tree_model_get (model, &iter, 0, &info, -1);
-
-        use_entry = info && !g_app_info_get_icon (info);
-        child = gtk_bin_get_child (GTK_BIN (button));
-        if (use_entry && GTK_IS_CELL_VIEW (child))
-        {
-            GtkWidget* entry = gtk_entry_new ();
-            exe = g_app_info_get_executable (info);
-            if (exe && *exe && strcmp (exe, "%f"))
-                gtk_entry_set_text (GTK_ENTRY (entry), exe);
-            gtk_widget_show (entry);
-            gtk_container_add (GTK_CONTAINER (button), entry);
-            gtk_widget_grab_focus (entry);
-            g_signal_connect (entry, "focus-out-event",
-                G_CALLBACK (proxy_entry_focus_out_event_cb), object);
-            g_object_set_data_full (G_OBJECT (entry), "property",
-                                    g_strdup (property), g_free);
-        }
-        else if (!use_entry && GTK_IS_ENTRY (child))
-        {
-            /* Force the combo to change the item again */
-            gtk_widget_destroy (child);
-            gtk_combo_box_set_active (button, 0);
-            gtk_combo_box_set_active_iter (button, &iter);
-        }
-
-        if (info)
-        {
-            exe = katze_app_info_get_commandline (info);
-            g_object_set (object, property, exe, NULL);
-            g_object_unref (info);
-        }
-        else
-            g_object_set (object, property, "", NULL);
-    }
-}
-
-static void
 proxy_entry_activate_cb (GtkEntry* entry,
                          GObject*  object)
 {
@@ -326,130 +260,6 @@
         proxy_object_notify_string_cb, proxy);
 }
 
-static GList*
-katze_app_info_get_all_for_category (const gchar* category)
-{
-    #ifdef _WIN32
-    /* FIXME: Real filtering by category would be better */
-    const gchar* content_type = g_content_type_from_mime_type (category);
-    GList* all_apps = g_app_info_get_all_for_type (content_type);
-    #else
-    GList* all_apps = g_app_info_get_all ();
-    #endif
-    GList* apps = NULL;
-    GList* app;
-    for (app = apps; app; app = g_list_next (app))
-    {
-        GAppInfo* info = app->data;
-        #ifdef GDK_WINDOWING_X11
-        gchar* filename = g_strconcat ("applications/", g_app_info_get_id (info), NULL);
-        GKeyFile* file = g_key_file_new ();
-
-        if (g_key_file_load_from_data_dirs (file, filename, NULL, G_KEY_FILE_NONE, NULL))
-        {
-            gchar* cat = g_key_file_get_string (file, "Desktop Entry",
-                                                "Categories", NULL);
-            if (cat && g_strrstr (cat, category))
-                apps = g_list_append (apps, info);
-
-            g_free (cat);
-        }
-        g_key_file_free (file);
-        g_free (filename);
-        #else
-        apps = g_list_append (apps, info);
-        #endif
-    }
-    g_list_free (all_apps);
-    return apps;
-}
-
-static gboolean
-proxy_populate_apps (GtkWidget* widget)
-{
-    const gchar* property = g_object_get_data (G_OBJECT (widget), "property");
-    GObject* object = g_object_get_data (G_OBJECT (widget), "object");
-    gchar* string = katze_object_get_string (object, property);
-    if (!g_strcmp0 (string, ""))
-        katze_assign (string, NULL);
-    GtkSettings* settings = gtk_widget_get_settings (widget);
-    gint icon_width = 16;
-    if (settings == NULL)
-        settings = gtk_settings_get_for_screen (gdk_screen_get_default ());
-    gtk_icon_size_lookup_for_settings (settings, GTK_ICON_SIZE_MENU,
-                                       &icon_width, NULL);
-
-    GtkComboBox* combo = GTK_COMBO_BOX (widget);
-    GtkListStore* model = GTK_LIST_STORE (gtk_combo_box_get_model (combo));
-    GtkTreeIter iter_none;
-    gtk_list_store_insert_with_values (model, &iter_none, 0,
-        0, NULL, 1, NULL, 2, _("None"), 3, icon_width, -1);
-
-    const gchar* app_type = g_object_get_data (G_OBJECT (widget), "app-type");
-    GList* apps = g_app_info_get_all_for_type (app_type);
-    GAppInfo* info;
-    if (!apps)
-        apps = katze_app_info_get_all_for_category (app_type);
-    if (apps != NULL)
-    {
-        GList* app;
-        for (app = apps; app; app = g_list_next (app))
-        {
-            info = app->data;
-            const gchar* name = g_app_info_get_name (info);
-            GIcon* icon = g_app_info_get_icon (info);
-            gchar* icon_name;
-            GtkTreeIter iter;
-
-            if (!g_app_info_should_show (info))
-                continue;
-
-            icon_name = icon ? g_icon_to_string (icon) : NULL;
-            gtk_list_store_insert_with_values (model, &iter, G_MAXINT,
-                0, info, 1, icon_name, 2, name, 3, icon_width, -1);
-            if (string && !strcmp (katze_app_info_get_commandline (info), string))
-                gtk_combo_box_set_active_iter (combo, &iter);
-
-            g_free (icon_name);
-        }
-        g_list_free (apps);
-    }
-
-    info = g_app_info_create_from_commandline ("",
-        "", G_APP_INFO_CREATE_NONE, NULL);
-    gtk_list_store_insert_with_values (model, NULL, G_MAXINT,
-        0, info, 1, NULL, 2, _("Custom…"), 3, icon_width, -1);
-    g_object_unref (info);
-
-    if (gtk_combo_box_get_active (combo) == -1)
-    {
-        if (string)
-        {
-            GtkWidget* entry;
-            const gchar* exe;
-
-            info = g_app_info_create_from_commandline (string,
-                NULL, G_APP_INFO_CREATE_NONE, NULL);
-            entry = gtk_entry_new ();
-            exe = g_app_info_get_executable (info);
-            if (exe && *exe && strcmp (exe, "%f"))
-                gtk_entry_set_text (GTK_ENTRY (entry), string);
-            gtk_widget_show (entry);
-            gtk_container_add (GTK_CONTAINER (combo), entry);
-            g_object_unref (info);
-            g_signal_connect (entry, "focus-out-event",
-                G_CALLBACK (proxy_entry_focus_out_event_cb), object);
-            g_object_set_data_full (G_OBJECT (entry), "property",
-                                    g_strdup (property), g_free);
-        }
-        else
-            gtk_combo_box_set_active_iter (combo, &iter_none);
-    }
-    g_signal_connect (widget, "changed",
-                      G_CALLBACK (proxy_combo_box_apps_changed_cb), object);
-    return G_SOURCE_REMOVE;
-}
-
 /**
  * katze_property_proxy:
  * @object: a #GObject
@@ -483,6 +293,7 @@
  *         for choosing an application to open TYPE files, ie. "text/plain".
  *     "application-CATEGORY": the widget created will be particularly suitable
  *         for choosing an application to open CATEGORY files, ie. "Network".
+ *      Since 0.5.8 the CATEGORY hint is no longer supported.
  *     "custom-PROPERTY": the last value of an enumeration will be the "custom"
  *         value, where the user may enter text freely, which then updates
  *         the property PROPERTY instead. This applies only to enumerations.
@@ -652,27 +463,6 @@
         g_free (families);
         #endif
     }
-    else if (type == G_TYPE_PARAM_STRING && hint && g_str_has_prefix (hint, "application-"))
-    {
-        GtkListStore* model;
-        GtkCellRenderer* renderer;
-        const gchar* app_type = &hint[12];
-
-        model = gtk_list_store_new (4, G_TYPE_APP_INFO, G_TYPE_STRING,
-                                       G_TYPE_STRING, G_TYPE_INT);
-        widget = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model));
-        renderer = gtk_cell_renderer_pixbuf_new ();
-        gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (widget), renderer, FALSE);
-        gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (widget), renderer, "icon-name", 1);
-        gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (widget), renderer, "width", 3);
-        renderer = gtk_cell_renderer_text_new ();
-        gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (widget), renderer, TRUE);
-        gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (widget), renderer, "text", 2);
-
-        g_object_set_data_full (G_OBJECT (widget), "app-type", g_strdup (app_type), g_free);
-        g_object_set_data_full (G_OBJECT (widget), "object", g_object_ref (object), g_object_unref);
-        g_idle_add_full (G_PRIORITY_LOW, (GSourceFunc)proxy_populate_apps, widget, NULL);
-    }
     else if (type == G_TYPE_PARAM_STRING)
     {
         gchar* notify_property;

=== modified file 'katze/katze.vapi'
--- katze/katze.vapi	2013-09-22 16:22:10 +0000
+++ katze/katze.vapi	2014-02-25 19:27:20 +0000
@@ -36,5 +36,12 @@
         public unowned string? get_meta_string (string key);
         public void set_meta_string (string key, string value);
     }
+
+    [CCode (cheader_filename = "katze/katze.h")]
+    public class Preferences : Gtk.Dialog {
+        public unowned Gtk.Box add_category (string label, string icon);
+        public void add_group (string? label);
+        public void add_widget (Gtk.Widget widget, string type);
+    }
 }
 

=== modified file 'katze/midori-uri.vala'
--- katze/midori-uri.vala	2014-01-06 21:51:09 +0000
+++ katze/midori-uri.vala	2014-02-25 19:27:20 +0000
@@ -16,6 +16,8 @@
 
 namespace Midori {
     public class URI : Object {
+        static string? fork_uri = null;
+
         public static string? parse_hostname (string? uri, out string path) {
             path = null;
             if (uri == null)
@@ -205,5 +207,20 @@
             label = display;
             return type;
         }
+
+        /*
+          Protects against recursive invokations of Midori with the same URI.
+          Consider a tel:// URI opened via Tab.open_uri, being handed off to GIO,
+          which in turns calls exo-open, which in turn can't open tel:// and falls
+          back to the browser ie. Midori.
+          So: code opening URIs calls this function with %true, #Midori.App passes %false.
+
+          Since: 0.5.8
+         */
+        public static bool recursive_fork_protection (string uri, bool set_uri) {
+            if (set_uri)
+                fork_uri = uri;
+            return fork_uri != uri;
+        }
     }
 }

=== modified file 'midori/midori-app.c'
--- midori/midori-app.c	2014-02-24 11:33:50 +0000
+++ midori/midori-app.c	2014-02-25 19:27:20 +0000
@@ -535,7 +535,7 @@
     for (i = 0; i < n_files; i++)
     {
         gchar* uri = g_file_get_uri (files[i]);
-        if (sokoke_recursive_fork_protection (uri, FALSE))
+        if (midori_uri_recursive_fork_protection (uri, FALSE))
         {
             if (first)
             {

=== modified file 'midori/midori-browser.c'
--- midori/midori-browser.c	2014-02-12 22:56:28 +0000
+++ midori/midori-browser.c	2014-02-25 19:27:20 +0000
@@ -1496,7 +1496,11 @@
                               MidoriNewView where)
 {
     if (midori_paths_get_runtime_mode () == MIDORI_RUNTIME_MODE_APP)
-        return sokoke_show_uri (gtk_widget_get_screen (view), uri, 0, NULL);
+    {
+        gboolean handled = FALSE;
+        g_signal_emit_by_name (view, "open-uri", uri, &handled);
+        return handled;
+    }
     else if (midori_paths_get_runtime_mode () == MIDORI_RUNTIME_MODE_PRIVATE)
     {
         if (where == MIDORI_NEW_VIEW_WINDOW)
@@ -1613,37 +1617,6 @@
     }
 }
 
-static void
-midori_browser_download_status_cb (WebKitDownload*  download,
-                                   GParamSpec*      pspec,
-                                   GtkWidget*       widget)
-{
-#ifndef HAVE_WEBKIT2
-    const gchar* uri = webkit_download_get_destination_uri (download);
-    switch (webkit_download_get_status (download))
-    {
-        case WEBKIT_DOWNLOAD_STATUS_FINISHED:
-            if (!sokoke_show_uri (gtk_widget_get_screen (widget), uri, 0, NULL))
-            {
-                sokoke_message_dialog (GTK_MESSAGE_ERROR,
-                    _("Error opening the image!"),
-                    _("Can not open selected image in a default viewer."), FALSE);
-            }
-            break;
-        case WEBKIT_DOWNLOAD_STATUS_ERROR:
-            webkit_download_cancel (download);
-            sokoke_message_dialog (GTK_MESSAGE_ERROR,
-                _("Error downloading the image!"),
-                _("Can not download selected image."), FALSE);
-            break;
-        case WEBKIT_DOWNLOAD_STATUS_CREATED:
-        case WEBKIT_DOWNLOAD_STATUS_STARTED:
-        case WEBKIT_DOWNLOAD_STATUS_CANCELLED:
-            break;
-    }
-#endif
-}
-
 #ifdef HAVE_WEBKIT2
 static void
 midori_browser_close_tab_idle (GObject*      resource,
@@ -1679,18 +1652,6 @@
     {
         handled = FALSE;
     }
-    else if (type == MIDORI_DOWNLOAD_OPEN_IN_VIEWER)
-    {
-        gchar* destination_uri =
-            midori_download_prepare_destination_uri (download, NULL);
-        midori_browser_prepare_download (browser, download, destination_uri);
-        g_signal_connect (download, "notify::status",
-            G_CALLBACK (midori_browser_download_status_cb), GTK_WIDGET (browser));
-        g_free (destination_uri);
-        #ifndef HAVE_WEBKIT2
-        webkit_download_start (download);
-        #endif
-    }
     #ifdef HAVE_WEBKIT2
     else if (!webkit_download_get_destination (download))
     #else

=== modified file 'midori/midori-dialog.vala'
--- midori/midori-dialog.vala	2014-01-25 21:04:57 +0000
+++ midori/midori-dialog.vala	2014-02-25 19:27:20 +0000
@@ -103,6 +103,20 @@
         }
     }
 
+    public static void show_message_dialog (Gtk.MessageType type, string short, string detailed, bool modal) {
+        var dialog = new Gtk.MessageDialog (null, 0, type, Gtk.ButtonsType.OK, "%s", short);
+        dialog.format_secondary_text ("%s", detailed);
+        if (modal) {
+            dialog.run ();
+            dialog.destroy ();
+        } else {
+            dialog.response.connect ((response) => {
+                dialog.destroy ();
+            });
+            dialog.show ();
+        }
+    }
+
     public class FileChooserDialog : Gtk.FileChooserDialog {
         public FileChooserDialog (string title, Gtk.Window? window, Gtk.FileChooserAction action) {
             /* Creates a new file chooser dialog to Open or Save and Cancel.

=== modified file 'midori/midori-download.vala'
--- midori/midori-download.vala	2014-01-06 21:51:09 +0000
+++ midori/midori-download.vala	2014-02-25 19:27:20 +0000
@@ -11,7 +11,6 @@
 
 namespace Sokoke {
 #if !HAVE_WEBKIT2
-    extern static bool show_uri (Gdk.Screen screen, string uri, uint32 timestamp) throws Error;
     extern static bool message_dialog (Gtk.MessageType type, string short, string detailed, bool modal);
 #endif
 }
@@ -212,9 +211,13 @@
 
         public static bool open (WebKit.Download download, Gtk.Widget widget) throws Error {
 #if !HAVE_WEBKIT2
-            if (!has_wrong_checksum (download))
-                return Sokoke.show_uri (widget.get_screen (),
-                    download.destination_uri, Gtk.get_current_event_time ());
+            if (!has_wrong_checksum (download)) {
+                var browser = widget.get_toplevel ();
+                Tab? tab = null;
+                browser.get ("tab", tab);
+                if (tab != null)
+                    tab.open_uri (download.destination_uri);
+            }
 
             Sokoke.message_dialog (Gtk.MessageType.WARNING,
                 _("The downloaded file is erroneous."),

=== modified file 'midori/midori-extension.c'
--- midori/midori-extension.c	2013-12-09 19:49:15 +0000
+++ midori/midori-extension.c	2014-02-25 19:27:20 +0000
@@ -563,6 +563,7 @@
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libapps." G_MODULE_SUFFIX, activate));
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libdelayed-load." G_MODULE_SUFFIX, activate));
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libtabby." G_MODULE_SUFFIX, activate));
+        g_assert (midori_extension_activate_gracefully (app, extension_path, "libopen-with." G_MODULE_SUFFIX, activate));
         g_assert (midori_extension_activate_gracefully (app, extension_path, "libflummi." G_MODULE_SUFFIX, activate));
     }
     else
@@ -679,6 +680,7 @@
      && strcmp (filename, "libapps." G_MODULE_SUFFIX)
      && strcmp (filename, "libdelayed-load." G_MODULE_SUFFIX)
      && strcmp (filename, "libtabby." G_MODULE_SUFFIX)
+     && strcmp (filename, "libopen-with." G_MODULE_SUFFIX)
      && strcmp (filename, "libflummi." G_MODULE_SUFFIX))
         katze_array_add_item (extensions, extension);
 

=== modified file 'midori/midori-frontend.c'
--- midori/midori-frontend.c	2013-11-29 16:29:02 +0000
+++ midori/midori-frontend.c	2014-02-25 19:27:20 +0000
@@ -239,6 +239,7 @@
 
     /* FIXME need proper stock extension mechanism */
     midori_browser_activate_action (browser, "libtransfers." G_MODULE_SUFFIX "=true");
+    midori_browser_activate_action (browser, "libopen-with." G_MODULE_SUFFIX "=true");
     g_assert (g_module_error () == NULL);
 
     return browser;
@@ -301,7 +302,7 @@
                               gchar*     crash_log)
 {
     GError* error = NULL;
-    if (!sokoke_show_uri (gtk_widget_get_screen (button), crash_log, 0, &error))
+    if (!gtk_show_uri (gtk_widget_get_screen (button), crash_log, 0, &error))
     {
         sokoke_message_dialog (GTK_MESSAGE_ERROR,
                                _("Could not run external program."),

=== modified file 'midori/midori-preferences.c'
--- midori/midori-preferences.c	2013-12-09 11:40:39 +0000
+++ midori/midori-preferences.c	2014-02-25 19:27:20 +0000
@@ -490,18 +490,6 @@
     gtk_button_set_label (GTK_BUTTON (button), _("Open tabs in the background"));
     SPANNED_ADD (button);
 
-    INDENTED_ADD (gtk_label_new (NULL));
-    label = gtk_label_new (_("Text Editor"));
-    gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
-    INDENTED_ADD (label);
-    entry = katze_property_proxy (settings, "text-editor", "application-text/plain");
-    SPANNED_ADD (entry);
-    label = gtk_label_new (_("News Aggregator"));
-    gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
-    INDENTED_ADD (label);
-    entry = katze_property_proxy (settings, "news-aggregator", "application-News");
-    SPANNED_ADD (entry);
-
     /* Page "Network" */
     PAGE_NEW (GTK_STOCK_NETWORK, _("Network"));
     FRAME_NEW (NULL);

=== modified file 'midori/midori-tab.vala'
--- midori/midori-tab.vala	2013-12-09 20:23:03 +0000
+++ midori/midori-tab.vala	2014-02-25 19:27:20 +0000
@@ -88,6 +88,8 @@
         }
         }
 
+        /* Since: 0.5.8 */
+        public signal bool open_uri (string uri);
         public signal void console_message (string message, int line, string source_id);
         public signal void attach_inspector (WebKit.WebView inspector_view);
         /* Emitted when an open inspector that was previously

=== modified file 'midori/midori-view.c'
--- midori/midori-view.c	2013-12-09 20:23:03 +0000
+++ midori/midori-view.c	2014-02-25 19:27:20 +0000
@@ -558,19 +558,6 @@
         g_free (new_uri);
         return TRUE;
     }
-    else if (sokoke_external_uri (uri))
-    {
-        if (sokoke_show_uri (gtk_widget_get_screen (GTK_WIDGET (web_view)),
-                             uri, GDK_CURRENT_TIME, NULL))
-        {
-            #ifdef HAVE_WEBKIT2
-            webkit_policy_decision_ignore (decision);
-            #else
-            webkit_web_policy_decision_ignore (decision);
-            #endif
-            return TRUE;
-        }
-    }
     else if (g_str_has_prefix (uri, "data:image/"))
     {
         /* For security reasons, main content served as data: is limited to images
@@ -2109,16 +2096,6 @@
 }
 
 static void
-midori_web_view_open_in_viewer_cb (GtkAction* action,
-                                   gpointer   user_data)
-{
-    MidoriView* view = user_data;
-    gchar* uri = katze_object_get_string (view->hit_test, "image-uri");
-    midori_view_download_uri (view, MIDORI_DOWNLOAD_OPEN_IN_VIEWER, uri);
-    g_free (uri);
-}
-
-static void
 midori_web_view_menu_video_copy_activate_cb (GtkAction* action,
                                              gpointer   user_data)
 {
@@ -2146,8 +2123,8 @@
     MidoriView* view = user_data;
     gchar* data = (gchar*)g_object_get_data (G_OBJECT (action), "uri");
     gchar* uri = g_strconcat ("mailto:", data, NULL);
-    sokoke_show_uri (gtk_widget_get_screen (view->web_view),
-                     uri, GDK_CURRENT_TIME, NULL);
+    gboolean handled = FALSE;
+    g_signal_emit_by_name (view, "open-uri", uri, &handled);
     g_free (uri);
 }
 #endif
@@ -2358,8 +2335,6 @@
             midori_web_view_menu_image_copy_activate_cb, view);
         midori_context_action_add_simple (menu, "SaveImage", _("Save I_mage"), NULL, GTK_STOCK_SAVE,
             midori_web_view_menu_image_save_activate_cb, view);
-        midori_context_action_add_simple (menu, "OpenImageInViewer", _("Open in Image _Viewer"), NULL, GTK_STOCK_OPEN,
-            midori_web_view_open_in_viewer_cb, view);
     }
 
     if (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA)
@@ -4013,12 +3988,19 @@
                 g_free (exception);
             }
         }
-        else if (sokoke_external_uri (uri))
-        {
-            sokoke_show_uri (NULL, uri, GDK_CURRENT_TIME, NULL);
-        }
         else
         {
+            if (sokoke_external_uri (uri))
+            {
+                gboolean handled = FALSE;
+                g_signal_emit_by_name (view, "open-uri", uri, &handled);
+                if (handled)
+                {
+                    g_free (temporary_uri);
+                    return;
+                }
+            }
+
             midori_tab_set_uri (MIDORI_TAB (view), uri);
             katze_item_set_uri (view->item, midori_tab_get_uri (MIDORI_TAB (view)));
             katze_assign (view->title, NULL);

=== modified file 'midori/midori.vapi'
--- midori/midori.vapi	2014-01-30 21:43:31 +0000
+++ midori/midori.vapi	2014-02-25 19:27:20 +0000
@@ -118,6 +118,7 @@
         public signal void quit ();
         public signal void send_notification (string title, string message);
         public static void update_history (Katze.Item item, string type, string event);
+        public signal void show_preferences (Katze.Preferences preferences);
     }
 
     [CCode (cheader_filename = "midori/midori.h")]

=== modified file 'midori/sokoke.c'
--- midori/sokoke.c	2013-10-28 23:36:29 +0000
+++ midori/sokoke.c	2014-02-25 19:27:20 +0000
@@ -37,6 +37,7 @@
 #ifdef G_OS_WIN32
 #include <windows.h>
 #include <shlobj.h>
+#include <gdk/gdkwin32.h>
 #endif
 
 static gchar*
@@ -109,39 +110,8 @@
                        const gchar*   detailed_message,
                        gboolean       modal)
 {
-    GtkWidget* dialog = gtk_message_dialog_new (
-        NULL, 0, message_type, GTK_BUTTONS_OK, "%s", short_message);
-    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
-                                              "%s", detailed_message);
-    if (modal)
-    {
-        gtk_dialog_run (GTK_DIALOG (dialog));
-        gtk_widget_destroy (dialog);
-    }
-    else
-    {
-        g_signal_connect_swapped (dialog, "response",
-            G_CALLBACK (gtk_widget_destroy), dialog);
-        gtk_widget_show (dialog);
-    }
-
-}
-
-#ifndef G_OS_WIN32
-static void
-sokoke_open_with_response_cb (GtkWidget* dialog,
-                              gint       response,
-                              GtkEntry*  entry)
-{
-    if (response == GTK_RESPONSE_ACCEPT)
-    {
-        const gchar* command = gtk_entry_get_text (entry);
-        const gchar* uri = g_object_get_data (G_OBJECT (dialog), "uri");
-        sokoke_spawn_program (command, FALSE, uri, TRUE, FALSE);
-    }
-    gtk_widget_destroy (dialog);
-}
-#endif
+    midori_show_message_dialog (message_type, short_message, detailed_message, modal);
+}
 
 GAppInfo*
 sokoke_default_for_uri (const gchar* uri,
@@ -164,86 +134,6 @@
 }
 
 /**
- * sokoke_show_uri:
- * @screen: a #GdkScreen, or %NULL
- * @uri: the URI to show
- * @timestamp: the timestamp of the event
- * @error: the location of a #GError, or %NULL
- *
- * Shows the specified URI with an application or xdg-open.
- * x-scheme-handler is supported for GLib < 2.28 as of 0.3.3.
- *
- * Return value: %TRUE on success, %FALSE if an error occurred
- **/
-gboolean
-sokoke_show_uri (GdkScreen*   screen,
-                 const gchar* uri,
-                 guint32      timestamp,
-                 GError**     error)
-{
-    #ifdef G_OS_WIN32
-    CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
-    SHELLEXECUTEINFO info = { sizeof (info) };
-    info.nShow = SW_SHOWNORMAL;
-    info.lpFile = uri;
-
-    return ShellExecuteEx (&info);
-    #else
-
-    GtkWidget* dialog;
-    GtkWidget* box;
-    gchar* filename;
-    gchar* ms;
-    GtkWidget* entry;
-
-    g_return_val_if_fail (GDK_IS_SCREEN (screen) || !screen, FALSE);
-    g_return_val_if_fail (uri != NULL, FALSE);
-    g_return_val_if_fail (!error || !*error, FALSE);
-
-    sokoke_recursive_fork_protection (uri, TRUE);
-
-    /* g_app_info_launch_default_for_uri, gdk_display_get_app_launch_context */
-    if (gtk_show_uri (screen, uri, timestamp, error))
-        return TRUE;
-
-    {
-        gchar* command = g_strconcat ("xdg-open ", uri, NULL);
-        gboolean result = g_spawn_command_line_async (command, error);
-        g_free (command);
-        if (result)
-            return TRUE;
-        if (error)
-            *error = NULL;
-    }
-
-    dialog = gtk_dialog_new_with_buttons (_("Open with"), NULL, 0,
-        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-        GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
-    box = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
-    if (g_str_has_prefix (uri, "file:///"))
-        filename = g_filename_from_uri (uri, NULL, NULL);
-    else
-        filename = g_strdup (uri);
-    ms = g_strdup_printf (_("Choose an application or command to open \"%s\":"),
-                          filename);
-    gtk_box_pack_start (GTK_BOX (box), gtk_label_new (ms), TRUE, FALSE, 4);
-    g_free (ms);
-    entry = gtk_entry_new ();
-    gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
-    gtk_box_pack_start (GTK_BOX (box), entry, TRUE, FALSE, 4);
-    g_signal_connect (dialog, "response",
-                      G_CALLBACK (sokoke_open_with_response_cb), entry);
-    g_object_set_data_full (G_OBJECT (dialog), "uri",
-                            filename, (GDestroyNotify)g_free);
-    gtk_widget_show_all (dialog);
-    gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
-    gtk_widget_grab_focus (entry);
-
-    return TRUE;
-    #endif
-}
-
-/**
  * sokoke_prepare_command:
  * @command: the command, properly quoted
  * @argument: any arguments, properly quoted
@@ -919,36 +809,6 @@
 #endif
 }
 
-/**
- * sokoke_recursive_fork_protection
- * @uri: the URI to check
- * @set_uri: if TRUE the URI will be saved
- *
- * Protects against recursive invokations of the Midori executable
- * with the same URI.
- *
- * As an example, consider having an URI starting with 'tel://'. You
- * could attempt to open it with sokoke_show_uri. In turn, 'exo-open'
- * might be called. Now quite possibly 'exo-open' is unable to handle
- * 'tel://' and might well fall back to 'midori' as default browser.
- *
- * To protect against this scenario, call this function with the
- * URI and %TRUE before calling any external tool.
- * #MidoriApp calls sokoke_recursive_fork_protection() with %FALSE
- * and bails out if %FALSE is returned.
- *
- * Return value: %TRUE if @uri is new, %FALSE on recursion
- **/
-gboolean
-sokoke_recursive_fork_protection (const gchar* uri,
-                                  gboolean     set_uri)
-{
-    static gchar* fork_uri = NULL;
-    if (set_uri)
-        katze_assign (fork_uri, g_strdup (uri));
-    return g_strcmp0 (fork_uri, uri) == 0 ? FALSE : TRUE;
-}
-
 static void
 sokoke_widget_clipboard_owner_clear_func (GtkClipboard* clipboard,
                                           gpointer      user_data)
@@ -1121,4 +981,23 @@
     g_free (lnk_path);
     g_free (launcher_type);
 }
+
+GdkPixbuf*
+sokoke_get_gdk_pixbuf_from_win32_executable (gchar* path)
+{
+    if (path == NULL)
+        return NULL;
+
+    GdkPixbuf* pixbuf = NULL;
+    HICON hIcon = NULL;
+    HINSTANCE hInstance = NULL;
+    hIcon = ExtractIcon (hInstance, (LPCSTR)path, 0);
+    if (hIcon == NULL)
+        return NULL;
+
+    pixbuf = gdk_win32_icon_to_pixbuf_libgtk_only (hIcon, NULL, NULL);
+    DestroyIcon (hIcon);
+
+    return pixbuf;
+}
 #endif

=== modified file 'midori/sokoke.h'
--- midori/sokoke.h	2013-08-02 16:40:27 +0000
+++ midori/sokoke.h	2014-02-25 19:27:20 +0000
@@ -29,19 +29,6 @@
                                          const gchar*    detailed_message,
                                          gboolean        modal);
 
-gboolean
-sokoke_show_uri_with_mime_type          (GdkScreen*      screen,
-                                         const gchar*    uri,
-                                         const gchar*    mime_type,
-                                         guint32         timestamp,
-                                         GError**        error);
-
-gboolean
-sokoke_show_uri                         (GdkScreen*      screen,
-                                         const gchar*    uri,
-                                         guint32         timestamp,
-                                         GError**        error);
-
 gchar*
 sokoke_prepare_command                  (const gchar*    command,
                                          gboolean        quote_command,
@@ -112,10 +99,6 @@
 gboolean
 sokoke_resolve_hostname                 (const gchar*        hostname);
 
-gboolean
-sokoke_recursive_fork_protection        (const gchar*         uri,
-                                         gboolean             set_uri);
-
 void
 sokoke_widget_copy_clipboard (GtkWidget*          widget,
                               const gchar*        text,

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2014-02-20 20:30:42 +0000
+++ po/POTFILES.in	2014-02-25 19:27:20 +0000
@@ -45,6 +45,7 @@
 extensions/delayed-load.vala
 extensions/devpet.vala
 extensions/external-download-manager.vala
+extensions/open-with.vala
 extensions/feed-panel/feed-atom.c
 extensions/feed-panel/feed-panel.c
 extensions/feed-panel/feed-parse.c