~midori/midori/trunk

/*
   Copyright (C) 2013 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.
*/

namespace Apps {
    const string APP_PREFIX = PACKAGE_NAME + " -a ";
    const string PROFILE_PREFIX = PACKAGE_NAME + " -c ";

    private class Launcher : GLib.Object, GLib.Initable {
        internal GLib.File file;
        internal string name;
        internal string icon_name;
        internal string exec;
        internal string uri;

        internal static string get_favicon_name_for_uri (string prefix, GLib.File folder, string uri, bool testing)
        {
            string icon_name = Midori.Stock.WEB_BROWSER;

            if (testing == true)
                return icon_name;

            if (prefix != PROFILE_PREFIX)
            {
                try {
                    var pixbuf = Midori.Paths.get_icon (uri, null);
                    if (pixbuf == null)
                        throw new FileError.EXIST ("No favicon loaded");
                    string icon_filename = folder.get_child ("icon.png").get_path ();
                    pixbuf.save (icon_filename, "png", null, "compression", "7", null);
#if HAVE_WIN32
                    string doubleslash_icon = icon_filename.replace ("\\", "\\\\");
                    icon_name = doubleslash_icon;
#else
                    icon_name = icon_filename;
#endif
                }
                catch (Error error) {
                    GLib.warning (_("Failed to fetch application icon in %s: %s"), folder.get_path (), error.message);
                }
            }
            return icon_name;
        }

        internal static string prepare_desktop_file (string prefix, string name, string uri, string title, string icon_name)
        {
            string exec;
#if HAVE_WIN32
            string doubleslash_uri = uri.replace ("\\", "\\\\");
            string quoted_uri = GLib.Shell.quote (doubleslash_uri);
            exec = prefix + quoted_uri;
#else
            exec = prefix + uri;
#endif
            var keyfile = new GLib.KeyFile ();
            string entry = "Desktop Entry";

            keyfile.set_string (entry, "Version", "1.0");
            keyfile.set_string (entry, "Type", "Application");
            keyfile.set_string (entry, "Name", name);
            keyfile.set_string (entry, "Exec", exec);
            keyfile.set_string (entry, "TryExec", PACKAGE_NAME);
            keyfile.set_string (entry, "Icon", icon_name);
            keyfile.set_string (entry, "Categories", "Network;");
            /*
               Using the sanitized URI as a class matches midori_web_app_new
               So dock type launchers can distinguish different apps with the same executable
             */
            if (exec.has_prefix (APP_PREFIX))
                keyfile.set_string (entry, "StartupWMClass", uri.delimit (":.\\/", '_'));

            return keyfile.to_data();
        }

        internal static File get_app_folder () {
            var data_dir = File.new_for_path (Midori.Paths.get_user_data_dir ()).get_child (PACKAGE_NAME);
            return data_dir.get_child ("apps");
        }

        internal static async File create_app (string uri, string title, Gtk.Widget? proxy) {
            string checksum = Checksum.compute_for_string (ChecksumType.MD5, uri, -1);
            var folder = get_app_folder ();
            yield Launcher.create (APP_PREFIX, folder.get_child (checksum),
                uri, title, proxy);
            return folder.get_child (checksum);
        }

        internal static File get_profile_folder () {
            var data_dir = File.new_for_path (Midori.Paths.get_user_data_dir ()).get_child (PACKAGE_NAME);
            return data_dir.get_child ("profiles");
        }

        internal static async File create_profile (Gtk.Widget? proxy) {
            string uuid = g_dbus_generate_guid ();
            string config = Path.build_path (Path.DIR_SEPARATOR_S,
                Midori.Paths.get_user_data_dir (), PACKAGE_NAME, "profiles", uuid);
            var folder = get_profile_folder ();
            yield Launcher.create (PROFILE_PREFIX, folder.get_child (uuid),
                config, _("Midori (%s)").printf (uuid), proxy);
            return folder.get_child (uuid);
        }

        internal static async void create (string prefix, GLib.File folder, string uri, string title, Gtk.Widget proxy) {
            /* Strip LRE leading character and / */
            string name = title.delimit ("‪/", ' ').strip();
            string filename = Midori.Download.clean_filename (name);
            string icon_name = Midori.Stock.WEB_BROWSER;
            bool testing = false;
            if (proxy == null)
                testing = true;
            var file = folder.get_child ("desc");

            try {
                folder.make_directory_with_parents (null);
            } catch (IOError.EXISTS exist_error) {
                /* It's no error if the folder already exists */
            } catch (Error error) {
                warning (_("Failed to create new launcher (%s): %s"), file.get_path (), error.message);
            }

            icon_name = get_favicon_name_for_uri (prefix, folder, uri, testing);
            string desktop_file = prepare_desktop_file (prefix, name, uri, title, icon_name);

            try {
                var stream = yield file.replace_async (null, false, GLib.FileCreateFlags.NONE);
                yield stream.write_async (desktop_file.data);
                // Create a launcher/ menu
#if HAVE_WIN32
                Midori.Sokoke.create_win32_desktop_lnk (prefix, filename, uri);
#else
                var data_dir = File.new_for_path (Midori.Paths.get_user_data_dir ());
                var desktop_dir = data_dir.get_child ("applications");
                try {
                    desktop_dir.make_directory_with_parents (null);
                } catch (IOError.EXISTS exist_error) {
                    /* It's no error if the folder already exists */
                }

                yield file.copy_async (desktop_dir.get_child (filename + ".desktop"),
                    GLib.FileCopyFlags.NONE);
#endif
                if (proxy != null) {
                    var browser = proxy.get_toplevel () as Midori.Browser;
                    browser.send_notification (_("Launcher created"),
                        _("You can now run <b>%s</b> from your launcher or menu").printf (name));
                }
            }
            catch (Error error) {
                warning (_("Failed to create new launcher (%s): %s"), file.get_path (), error.message);
                if (proxy != null) {
                    var browser = proxy.get_toplevel () as Midori.Browser;
                    browser.send_notification (_("Error creating launcher"),
                        _("Failed to create new launcher (%s): %s").printf (file.get_path (), error.message));
                }
            }
        }

        internal Launcher (GLib.File file) {
            this.file = file;
        }

        bool init (GLib.Cancellable? cancellable) throws GLib.Error {
            var keyfile = new GLib.KeyFile ();
            try {
                keyfile.load_from_file (file.get_child ("desc").get_path (), GLib.KeyFileFlags.NONE);
            } catch (Error desc_error) {
                throw new FileError.EXIST (_("No file \"desc\" found"));
            }

            exec = keyfile.get_string ("Desktop Entry", "Exec");
            if (!exec.has_prefix (APP_PREFIX) && !exec.has_prefix (PROFILE_PREFIX))
                return false;

            name = keyfile.get_string ("Desktop Entry", "Name");
            icon_name = keyfile.get_string ("Desktop Entry", "Icon");
            uri = exec.replace (APP_PREFIX, "").replace (PROFILE_PREFIX, "");
            return true;
        }
    }

    private class Sidebar : Gtk.VBox, Midori.Viewable {
        Gtk.Toolbar? toolbar = null;
        Gtk.ListStore store = new Gtk.ListStore (1, typeof (Launcher));
        Gtk.TreeView treeview;
        Katze.Array array;
        GLib.File app_folder;
        GLib.File profile_folder;

        public unowned string get_stock_id () {
            return Midori.Stock.WEB_BROWSER;
        }

        public unowned string get_label () {
            return _("Applications");
        }

        public Gtk.Widget get_toolbar () {
            if (toolbar == null) {
                toolbar = new Gtk.Toolbar ();

                var profile = new Gtk.ToolButton.from_stock (Gtk.STOCK_ADD);
                profile.label = _("New _Profile");
                profile.tooltip_text = _("Creates a new, independent profile and a launcher");
                profile.use_underline = true;
                profile.is_important = true;
                profile.show ();
                profile.clicked.connect (() => {
                    Launcher.create_profile.begin (this);
                });
                toolbar.insert (profile, -1);

                var app = new Gtk.ToolButton.from_stock (Gtk.STOCK_ADD);
                app.label = _("New _App");
                app.tooltip_text = _("Creates a new app for a specific site");
                app.use_underline = true;
                app.is_important = true;
                app.show ();
                app.clicked.connect (() => {
                    var view = (get_toplevel () as Midori.Browser).tab as Midori.View;
                    string checksum = Checksum.compute_for_string (ChecksumType.MD5, view.get_display_uri (), -1);
                    Launcher.create.begin (APP_PREFIX, app_folder.get_child (checksum),
                        view.get_display_uri (), view.get_display_title (), this);
                });
                toolbar.insert (app, -1);
            }
            return toolbar;
        }

        void row_activated (Gtk.TreePath path, Gtk.TreeViewColumn column) {
            Gtk.TreeIter iter;
            if (store.get_iter (out iter, path)) {
                Launcher launcher;
                store.get (iter, 0, out launcher);
                try {
                    GLib.Process.spawn_command_line_async (launcher.exec);
                }
                catch (Error error) {
                    var browser = get_toplevel () as Midori.Browser;
                    browser.send_notification (_("Error launching"), error.message);
                }
            }
        }

        bool button_released (Gdk.EventButton event) {
            Gtk.TreePath? path;
            Gtk.TreeViewColumn column;
            if (event.button != 1)
            	return false;
            if (treeview.get_path_at_pos ((int)event.x, (int)event.y, out path, out column, null, null)) {
                if (path != null) {
                    if (column == treeview.get_column (2)) {
                        Gtk.TreeIter iter;
                        if (store.get_iter (out iter, path)) {
                            Launcher launcher;
                            store.get (iter, 0, out launcher);
                            try {
                                launcher.file.trash (null);
                                store.remove (iter);

                                string filename = Midori.Download.clean_filename (launcher.name);
#if HAVE_WIN32
                                string lnk_filename = Midori.Sokoke.get_win32_desktop_lnk_path_for_filename (filename);
                                if (GLib.FileUtils.test (lnk_filename, GLib.FileTest.EXISTS)) {
                                    var lnk_file = File.new_for_path (lnk_filename);
                                    lnk_file.trash ();
                                }
#else
                                var data_dir = File.new_for_path (Midori.Paths.get_user_data_dir ());
                                data_dir.get_child ("applications").get_child (filename + ".desktop").trash ();
#endif
                            }
                            catch (Error error) {
                                GLib.critical ("Failed to remove launcher (%s): %s", launcher.file.get_path (), error.message);
                            }
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        public Sidebar (Katze.Array array, GLib.File app_folder, GLib.File profile_folder) {
            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);

            column = new Gtk.TreeViewColumn ();
            Gtk.CellRendererPixbuf renderer_button = new Gtk.CellRendererPixbuf ();
            column.pack_start (renderer_button, false);
            column.set_cell_data_func (renderer_button, on_render_button);
            treeview.append_column (column);

            treeview.row_activated.connect (row_activated);
            treeview.button_release_event.connect (button_released);
            treeview.show ();
            pack_start (treeview, true, true, 0);

            this.array = array;
            array.add_item.connect (launcher_added);
            array.remove_item.connect (launcher_removed);
            foreach (GLib.Object item in array.get_items ())
                launcher_added (item);

            this.app_folder = app_folder;
            this.profile_folder = profile_folder;
        }

        private int tree_sort_func (Gtk.TreeModel model, Gtk.TreeIter a, Gtk.TreeIter b) {
            Launcher launcher1, launcher2;
            model.get (a, 0, out launcher1);
            model.get (b, 0, out launcher2);
            return strcmp (launcher1.name, launcher2.name);
        }
        void launcher_added (GLib.Object item) {
            var launcher = item as Launcher;
            Gtk.TreeIter iter;
            store.append (out iter);
            store.set (iter, 0, launcher);
        }

        void launcher_removed (GLib.Object item) {
            // TODO remove iter
        }

        private void on_render_icon (Gtk.CellLayout column, Gtk.CellRenderer renderer,
            Gtk.TreeModel model, Gtk.TreeIter iter) {

            Launcher launcher;
            model.get (iter, 0, out launcher);

            try {
                int icon_width = 48, icon_height = 48;
                Gtk.icon_size_lookup_for_settings (get_settings (),
                    Gtk.IconSize.DIALOG, out icon_width, out icon_height);
                var pixbuf = new Gdk.Pixbuf.from_file_at_size (launcher.icon_name, icon_width, icon_height);
                renderer.set ("pixbuf", pixbuf);
            }
            catch (Error error) {
                renderer.set ("icon-name", launcher.icon_name);
            }
            renderer.set ("stock-size", Gtk.IconSize.DIALOG,
                          "xpad", 4);
        }

        private void on_render_text (Gtk.CellLayout column, Gtk.CellRenderer renderer,
            Gtk.TreeModel model, Gtk.TreeIter iter) {

            Launcher launcher;
            model.get (iter, 0, out launcher);
            renderer.set ("markup",
                Markup.printf_escaped ("<b>%s</b>\n%s",
                    launcher.name, launcher.uri),
                          "ellipsize", Pango.EllipsizeMode.END);
        }

        void on_render_button (Gtk.CellLayout column, Gtk.CellRenderer renderer,
            Gtk.TreeModel model, Gtk.TreeIter iter) {

            renderer.set ("stock-id", Gtk.STOCK_DELETE,
                          "stock-size", Gtk.IconSize.MENU);
        }
    }

    private class Manager : Midori.Extension {
        internal Katze.Array array;
        internal GLib.File app_folder;
        internal GLib.File profile_folder;
        internal GLib.List<GLib.FileMonitor> monitors;
        internal GLib.List<Gtk.Widget> widgets;

        void app_changed (GLib.File file, GLib.File? other, GLib.FileMonitorEvent event) {
            try {
                switch (event) {
                case GLib.FileMonitorEvent.DELETED:
                    // TODO array.remove_item ();
                    break;
                case GLib.FileMonitorEvent.CREATED:
                    var launcher = new Launcher (file);
                    if (launcher.init ())
                        array.add_item (launcher);
                    break;
                case GLib.FileMonitorEvent.CHANGED:
                    // TODO
                    break;
                }
            }
            catch (Error error) {
                warning ("Application changed (%s): %s", file.get_path (), error.message);
            }
        }

        async void populate_apps (File app_folder) {
            try {
                try {
                    app_folder.make_directory_with_parents (null);
                } catch (IOError.EXISTS exist_error) {
                    /* It's no error if the folder already exists */
                }

                var monitor = app_folder.monitor_directory (0, null);
                monitor.changed.connect (app_changed);
                monitors.append (monitor);

                var enumerator = yield app_folder.enumerate_children_async ("standard::name", 0);
                while (true) {
                    var files = yield enumerator.next_files_async (10);
                    if (files == null)
                        break;
                    foreach (var info in files) {
                        var file = app_folder.get_child (info.get_name ());
                        try {
                            var launcher = new Launcher (file);
                            if (launcher.init ())
                                array.add_item (launcher);
                        }
                        catch (Error error) {
                            warning ("Failed to parse launcher (%s): %s", file.get_path (), error.message);
                        }
                    }
                }
            }
            catch (Error io_error) {
                warning ("Failed to list apps (%s): %s",
                         app_folder.get_path (), io_error.message);
            }
        }

        void browser_added (Midori.Browser browser) {
            var accels = new Gtk.AccelGroup ();
            browser.add_accel_group (accels);
            var action_group = browser.get_action_group ();

            var action = new Gtk.Action ("CreateLauncher", _("Create _Launcher"),
                _("Creates a new app for a specific site"), null);
            action.activate.connect (() => {
                var view = browser.tab as Midori.View;
                Launcher.create_app.begin (view.get_display_uri (), view.get_display_title (), view);
            });
            action_group.add_action_with_accel (action, "<Ctrl><Shift>A");
            action.set_accel_group (accels);
            action.connect_accelerator ();

            var viewable = new Sidebar (array, app_folder, profile_folder);
            viewable.show ();
            browser.panel.append_page (viewable);
            widgets.append (viewable);
        }

        void activated (Midori.App app) {
            array = new Katze.Array (typeof (Launcher));
            monitors = new GLib.List<GLib.FileMonitor> ();
            app_folder = Launcher.get_app_folder ();
            populate_apps.begin (app_folder);
            profile_folder = Launcher.get_profile_folder ();
            populate_apps.begin (profile_folder);
            widgets = new GLib.List<Gtk.Widget> ();
            foreach (var browser in app.get_browsers ())
                browser_added (browser);
            app.add_browser.connect (browser_added);
        }

        void deactivated () {
            var app = get_app ();
            foreach (var monitor in monitors)
                monitor.changed.disconnect (app_changed);
            monitors = null;

            app.add_browser.disconnect (browser_added);
            foreach (var widget in widgets)
                widget.destroy ();
            foreach (var browser in app.get_browsers ()) {
                var action_group = browser.get_action_group ();
                var action = action_group.get_action ("CreateLauncher");
                action_group.remove_action (action);
            }

        }

        internal Manager () {
            GLib.Object (name: _("Web App Manager"),
                         description: _("Manage websites installed as applications"),
                         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 Apps.Manager ();
}

class ExtensionsAppsDesktop : Midori.Test.Job {
    public static void test () { new ExtensionsAppsDesktop ().run_sync (); }
    public override async void run (Cancellable cancellable) throws GLib.Error {
        string uri = "http://example.com";
        string checksum = Checksum.compute_for_string (ChecksumType.MD5, uri, -1);
        var apps = Apps.Launcher.get_app_folder ().get_child (checksum);
        Midori.Paths.remove_path (apps.get_path ());

        var data_dir = File.new_for_path (Midori.Paths.get_user_data_dir ());
        var desktop_dir = data_dir.get_child ("applications");
        Midori.Paths.remove_path (desktop_dir.get_child ("Example.desktop").get_path ());

        var folder = yield Apps.Launcher.create_app (uri, "Example", null);
        var launcher = new Apps.Launcher (folder);
        launcher.init ();
        Katze.assert_str_equal (folder.get_path (), launcher.uri, uri);
        yield Apps.Launcher.create_profile (null);
    }
}

public void extension_test () {
    Test.add_func ("/extensions/apps/desktop", ExtensionsAppsDesktop.test);
}