/*
   Copyright (C) 2014 Christian Dywan <christian@twotoasts.de>

   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 {
    /* Spawn the application specified by @app_info on the uri, trying to
       remember the association between the content-type and the application
       chosen
       Returns whether the application was spawned successfully. */
    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);
        } catch (Error error) {
            warning ("Failed to open \"%s\": %s", uri, error.message);
            return false;
        }
        /* Failing to save the association is a non-fatal error so report success */
        try {
            new Associations ().remember (content_type, app_info);
        } catch (Error error) {
            warning ("Failed to save association for \"%s\": %s", uri, error.message);
        }
        return true;
    }

    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);
            }
        }

        /* Determine a handler command-line for @content_type and spawn it on @uri.
           Returns whether a handler was found and spawned successfully. */
        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;
            }
        }

        /* Save @app_info in the persistent store as the handler for @content_type */
        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 ());
        }

        /* Save @commandline in the persistent store as the handler for @content_type */
        public void remember_custom_commandline (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 remember custom command line for \"%s\": %s", uri, error.message);
            }
            open (content_type, uri);
        }
    }
#else
        public Associations () {
        }

        /* Find a handler application for @content_type and spawn it on @uri.
           Returns whether a handler was found and spawned successfully. */
        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);
        }

        /* Save @app_info as the last-used handler for @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);
        }

        /* Save @commandline as a new system MIME handler for @content_type */
        public void remember_custom_commandline (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 remember 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 ();
    }

    /* Generate markup of the application's name followed by a description line. */
    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 ().remember_custom_commandline (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 = true;
            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 ();

            Gtk.Requisition req;
#if HAVE_GTK3
            get_content_area ().get_preferred_size (null, out req);
#else
            get_content_area ().size_request (out req);
#endif
            (this as Gtk.Window).set_default_size (req.width*2, req.height*3/2);

            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 (() => {
                dialog.transient_for = this.get_toplevel () as Gtk.Window;
                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_expand (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 (unowned string content_type in ContentType.list_registered ())
                launcher_added (content_type);
            foreach (unowned 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,
#endif
                          "width-chars", 30,
                          "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),
#if HAVE_GTK3
                          "max-width-chars", 30,
#endif
                          "width-chars", 30,
                          "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) {
            string content_type = get_content_type (uri, null);
            return open_with_type (uri, content_type, tab, NextStep.TRY_OPEN);
        }

        bool navigation_requested (Midori.Tab tab, string uri) {
	    /* FIXME: Make this a list of known/internal uris to pass-thru */
            if (uri.has_prefix ("file://") || Midori.URI.is_http (uri) || Midori.URI.is_blank (uri))
                return false;

            /* Don't find app for abp links, we should handle them internally */
            if (uri.has_prefix("abp:"))
                return true;

            string content_type = get_content_type (uri, null);
            open_with_type (uri, content_type, tab, 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);
        }

        /* Returns %TRUE if the attempt to download and open failed immediately, %FALSE otherwise */
        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);
            /* Don't download websites */
            if (content_type == "application/octet-stream")
                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,
                        _("Download error"),
                        _("Cannot open '%s' because the download failed."
                          ).printf (download.destination_uri), false);
            });
            download.start ();
            return true;
            #endif
        }

        /* If @next_step is %NextStep.TRY_OPEN, tries to pick a handler automatically.
           If the automatic handler did not exist or could not run, asks for an application.
           Returns whether an application was found and launched successfully. */
        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 opening directly failed or wasn't tried, ask for an association */
            if (open_with (uri, content_type, widget) != null)
                return true;
            return false;
        }

        /* Returns the application chosen to open the uri+content_type if the application
           was spawned successfully, %NULL if none was chosen or running was unsuccessful. */
        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.navigation_requested.connect_after (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.navigation_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 <christian@twotoasts.de>");

            this.activate.connect (activated);
            this.deactivate.connect (deactivated);
        }
    }
}

public Midori.Extension extension_init () {
    return new ExternalApplications.Manager ();
}