/*
 Copyright (C) 2007-2013 Christian Dywan <christian@twotoasts.de>
 Copyright (C) 2009 Dale Whittaker <dayul@users.sf.net>
 Copyright (C) 2009 Alexander Butenko <a.butenka@gmail.com>

 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.
*/

#include "sokoke.h"

#include "midori-core.h"
#include "midori-platform.h"
#include "midori-app.h"

#include <config.h>
#if HAVE_UNISTD_H
    #include <unistd.h>
#endif
#include <stdlib.h>
#include <string.h>

#ifdef GDK_WINDOWING_X11
    #include <gdk/gdkx.h>
#endif

#include <gdk/gdkkeysyms.h>
#include <glib/gi18n.h>
#include <glib/gprintf.h>
#include <glib/gstdio.h>
#include "katze/katze.h"

#ifdef G_OS_WIN32
#include <windows.h>
#include <shlobj.h>
#include <gdk/gdkwin32.h>
#endif

static gchar*
sokoke_js_string_utf8 (JSStringRef js_string)
{
    size_t size_utf8;
    gchar* string_utf8;

    g_return_val_if_fail (js_string, NULL);

    size_utf8 = JSStringGetMaximumUTF8CStringSize (js_string);
    string_utf8 = g_new (gchar, size_utf8);
    JSStringGetUTF8CString (js_string, string_utf8, size_utf8);
    return string_utf8;
}

gchar*
sokoke_js_script_eval (JSContextRef js_context,
                       const gchar* script,
                       gchar**      exception)
{
    JSGlobalContextRef temporary_context = NULL;
    gchar* value;
    JSStringRef js_value_string;
    JSStringRef js_script;
    JSValueRef js_exception = NULL;
    JSValueRef js_value;

    g_return_val_if_fail (script, FALSE);

    if (!js_context)
        js_context = temporary_context = JSGlobalContextCreateInGroup (NULL, NULL);

    js_script = JSStringCreateWithUTF8CString (script);
    js_value = JSEvaluateScript (js_context, js_script,
        JSContextGetGlobalObject (js_context), NULL, 0, &js_exception);
    JSStringRelease (js_script);

    if (!js_value)
    {
        JSStringRef js_message = JSValueToStringCopy (js_context,
                                                      js_exception, NULL);
        g_return_val_if_fail (js_message != NULL, NULL);

        value = sokoke_js_string_utf8 (js_message);
        if (exception)
            *exception = value;
        else
        {
            g_warning ("%s", value);
            g_free (value);
        }
        JSStringRelease (js_message);
        if (temporary_context)
            JSGlobalContextRelease (temporary_context);
        return NULL;
    }

    js_value_string = JSValueToStringCopy (js_context, js_value, NULL);
    value = sokoke_js_string_utf8 (js_value_string);
    JSStringRelease (js_value_string);
    if (temporary_context)
        JSGlobalContextRelease (temporary_context);
    return value;
}

void
sokoke_message_dialog (GtkMessageType message_type,
                       const gchar*   short_message,
                       const gchar*   detailed_message,
                       gboolean       modal)
{
    midori_show_message_dialog (message_type, short_message, detailed_message, modal);
}

GAppInfo*
sokoke_default_for_uri (const gchar* uri,
                        gchar**      scheme_ptr)
{
    gchar* scheme;
    GAppInfo* info;

    scheme = g_uri_parse_scheme (uri);
    if (!scheme)
        return NULL;

    info = g_app_info_get_default_for_uri_scheme (scheme);
    if (scheme_ptr != NULL)
        *scheme_ptr = scheme;
    else
        g_free (scheme);
    return info;

}

/**
 * sokoke_prepare_command:
 * @command: the command, properly quoted
 * @argument: any arguments, properly quoted
 * @quote_command: if %TRUE, @command will be quoted
 * @quote_argument: if %TRUE, @argument will be quoted, ie. a URI or filename
 *
 * If @command contains %s, @argument will be quoted and inserted into
 * @command, which is left unquoted regardless of @quote_command.
 *
 * Return value: the command prepared for spawning
 **/
gchar*
sokoke_prepare_command (const gchar* command,
                        gboolean     quote_command,
                        const gchar* argument,
                        gboolean     quote_argument)
{
    g_return_val_if_fail (command != NULL, FALSE);
    g_return_val_if_fail (argument != NULL, FALSE);

    if (midori_debug ("paths"))
        g_print ("Preparing command: %s %d %s %d\n",
                 command, quote_command, argument, quote_argument);

    {
        gchar* uri_format;
        gchar* real_command;
        gchar* command_ready;

        /* .desktop files accept %u, %U, %f, %F as URI/ filename, we treat it like %s */
        real_command = g_strdup (command);
        if ((uri_format = strstr (real_command, "%u"))
         || (uri_format = strstr (real_command, "%U"))
         || (uri_format = strstr (real_command, "%f"))
         || (uri_format = strstr (real_command, "%F")))
            uri_format[1] = 's';


        if (strstr (real_command, "%s"))
        {
            gchar* argument_quoted = quote_argument ? g_shell_quote (argument) : g_strdup (argument);
            command_ready = g_strdup_printf (real_command, argument_quoted);
            g_free (argument_quoted);
        }
        else if (quote_argument)
        {
            gchar* quoted_command = quote_command ? g_shell_quote (real_command) : g_strdup (real_command);
            gchar* argument_quoted = g_shell_quote (argument);
            command_ready = g_strconcat (quoted_command, " ", argument_quoted, NULL);
            g_free (argument_quoted);
            g_free (quoted_command);
        }
        else
        {
            gchar* quoted_command = quote_command ? g_shell_quote (real_command) : g_strdup (real_command);
            command_ready = g_strconcat (quoted_command, " ", argument, NULL);
            g_free (quoted_command);
        }
        g_free (real_command);
        return command_ready;
    }
}

/**
 * sokoke_spawn_program:
 * @command: the command, properly quoted
 * @argument: any arguments, properly quoted
 * @quote_command: if %TRUE, @command will be quoted
 * @quote_argument: if %TRUE, @argument will be quoted, ie. a URI or filename
 * @sync: spawn synchronously and wait for command to exit
 *
 * If @command contains %s, @argument will be quoted and inserted into
 * @command, which is left unquoted regardless of @quote_command.
 *
 * Return value: %TRUE on success, %FALSE if an error occurred
 **/
gboolean
sokoke_spawn_program (const gchar* command,
                      gboolean     quote_command,
                      const gchar* argument,
                      gboolean     quote_argument,
                      gboolean     sync)
{
    GError* error;
    gchar* command_ready;
    gchar** argv;

    g_return_val_if_fail (command != NULL, FALSE);
    g_return_val_if_fail (argument != NULL, FALSE);

    command_ready = sokoke_prepare_command (command, quote_command, argument, quote_argument);
    g_print ("Launching command: %s\n", command_ready);

    error = NULL;
    if (!g_shell_parse_argv (command_ready, NULL, &argv, &error))
    {
        sokoke_message_dialog (GTK_MESSAGE_ERROR,
                               _("Could not run external program."),
                               error->message, FALSE);
        g_error_free (error);
        g_free (command_ready);
        return FALSE;
    }
    g_free (command_ready);

    error = NULL;
    if (sync)
        g_spawn_sync (NULL, argv, NULL,
            (GSpawnFlags)G_SPAWN_SEARCH_PATH,
            NULL, NULL, NULL, NULL, NULL, &error);
    else
        g_spawn_async (NULL, argv, NULL,
            (GSpawnFlags)G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
            NULL, NULL, NULL, &error);
    if (error != NULL)
    {
        sokoke_message_dialog (GTK_MESSAGE_ERROR,
                               _("Could not run external program."),
                               error->message, FALSE);
        g_error_free (error);
    }

    g_strfreev (argv);
    return TRUE;
}

void
sokoke_spawn_gdb (const gchar* gdb,
                  gboolean     sync)
{
    gchar* args = midori_paths_get_command_line_str (FALSE);
    const gchar* runtime_dir = midori_paths_get_runtime_dir ();
    gchar* cmd = g_strdup_printf (
        "--batch -ex 'set print thread-events off' -ex run "
        "-ex 'set logging on %s/%s' -ex 'bt' --return-child-result "
        "--args %s",
        runtime_dir, "gdb.bt", args);
    sokoke_spawn_program (gdb, TRUE, cmd, FALSE, sync);
    g_free (cmd);
    g_free (args);
}

void
sokoke_spawn_app (const gchar* uri,
                  gboolean     private)
{
    const gchar* executable = midori_paths_get_command_line (NULL)[0];
    gchar* uri_quoted = g_shell_quote (uri);
    gchar* argument;
    if (private)
    {
        gchar* config_quoted = g_shell_quote (midori_paths_get_config_dir_for_reading ());
        argument = g_strconcat ("-c ", config_quoted,
                                " -p ", uri_quoted, NULL);
    }
    else
        argument = g_strconcat ("-a ", uri_quoted, NULL);
    g_free (uri_quoted);
    sokoke_spawn_program (executable, TRUE, argument, FALSE, FALSE);
    g_free (argument);
}

static void
sokoke_resolve_hostname_cb (SoupAddress *address,
                            guint        status,
                            gpointer     data)
{
    if (status == SOUP_STATUS_OK)
        *(gint *)data = 1;
    else
        *(gint *)data = 2;
}

/**
 * sokoke_resolve_hostname
 * @hostname: a string typed by a user
 *
 * Takes a string that was typed by a user,
 * resolves the hostname, and returns the status.
 *
 * Return value: %TRUE if is a valid host, else %FALSE
 **/
gboolean
sokoke_resolve_hostname (const gchar* hostname)
{
    gchar* uri;
    gint host_resolved = 0;

    uri = g_strconcat ("http://", hostname, NULL);
    if (sokoke_prefetch_uri (NULL, uri, G_CALLBACK (sokoke_resolve_hostname_cb),
                             &host_resolved))
    {
        GTimer* timer = g_timer_new ();
        while (!host_resolved && g_timer_elapsed (timer, NULL) < 10)
            g_main_context_iteration (NULL, FALSE);
        g_timer_destroy (timer);
    }
    g_free (uri);
    return host_resolved == 1 ? TRUE : FALSE;
}

gboolean
sokoke_external_uri (const gchar* uri)
{
    GAppInfo* info;

    /* URI schemes are case-insensitive, followed by ':' - rfc3986 */
    if (!uri || !strncasecmp (uri, "http:", 5)
             || !strncasecmp (uri, "https:", 6)
             || !strncasecmp (uri, "file:", 5)
             || !strncasecmp (uri, "geo:", 4)
             || !strncasecmp (uri, "about:", 6))
        return FALSE;

    info = sokoke_default_for_uri (uri, NULL);
    if (info)
        g_object_unref (info);
    return info != NULL;
}

/**
 * sokoke_magic_uri:
 * @uri: a string typed by a user
 *
 * Takes a string that was typed by a user,
 * guesses what it is, and returns an URI.
 *
 * If it was a search, %NULL will be returned.
 *
 * Return value: a newly allocated URI, or %NULL
 **/
gchar*
sokoke_magic_uri (const gchar* uri,
                  gboolean     allow_search,
                  gboolean     allow_relative)
{
    gchar** parts;
    gchar* search;

    g_return_val_if_fail (uri, NULL);

    /* Add file:// if we have a local path */
    if (g_path_is_absolute (uri))
        return g_filename_to_uri (uri, NULL, NULL);
    if (allow_relative
     && g_file_test (uri, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
    {
        GFile* file = g_file_new_for_commandline_arg (uri);
        gchar* uri_ready = g_file_get_uri (file);
        g_object_unref (file);
        return uri_ready;
    }
    /* Parse geo URI geo:48.202778,16.368472;crs=wgs84;u=40 as a location */
    if (!strncmp (uri, "geo:", 4))
    {
        gchar* comma;
        gchar* semicolon;
        gchar* latitude;
        gchar* longitude;
        gchar* geo;

        comma = strchr (&uri[4], ',');
        /* geo:latitude,longitude[,altitude][;u=u][;crs=crs] */
        if (!(comma && *comma))
            return g_strdup (uri);
        semicolon = strchr (comma + 1, ';');
        if (!semicolon)
            semicolon = strchr (comma + 1, ',');
        latitude = g_strndup (&uri[4], comma - &uri[4]);
        if (semicolon)
            longitude = g_strndup (comma + 1, semicolon - comma - 1);
        else
            longitude = g_strdup (comma + 1);
        geo = g_strdup_printf ("http://www.openstreetmap.org/?mlat=%s&mlon=%s",
            latitude, longitude);
        g_free (latitude);
        g_free (longitude);
        return geo;
    }
    if (midori_uri_is_location (uri) || sokoke_external_uri (uri))
        return g_strdup (uri);
    if (midori_uri_is_ip_address (uri))
        return g_strconcat ("http://", uri, NULL);
    search = NULL;
    if (!strchr (uri, ' ') &&
        ((search = strchr (uri, ':')) || (search = strchr (uri, '@'))) &&
        search[0] && g_ascii_isdigit (search[1]))
        return g_strconcat ("http://", uri, NULL);
    if ((!strcmp (uri, "localhost") || strchr (uri, '/'))
      && sokoke_resolve_hostname (uri))
        return g_strconcat ("http://", uri, NULL);
    if (!search)
    {
        parts = g_strsplit (uri, ".", 0);
        if (parts[0] && parts[1])
        {
            if (!(parts[1][1] == '\0' && !g_ascii_isalpha (parts[1][0])))
                if (!strchr (parts[0], ' ') && !strchr (parts[1], ' '))
                {
                    search = g_strconcat ("http://", uri, NULL);
                    g_strfreev (parts);
                   return search;
                }
        }
        g_strfreev (parts);
    }
    if (!allow_search)
        midori_error (_("Invalid URI"));
    return NULL;
}

void sokoke_widget_set_visible (GtkWidget* widget, gboolean visible)
{
    /* Show or hide the widget */
    if (visible)
        gtk_widget_show (widget);
    else
        gtk_widget_hide (widget);
}

typedef enum
{
    SOKOKE_DESKTOP_UNTESTED,
    SOKOKE_DESKTOP_XFCE,
    SOKOKE_DESKTOP_OSX,
    SOKOKE_DESKTOP_UNKNOWN
} SokokeDesktop;

static SokokeDesktop
sokoke_get_desktop (void)
{
    #if HAVE_OSX
    return SOKOKE_DESKTOP_OSX;
    #elif defined (GDK_WINDOWING_X11)
    static SokokeDesktop desktop = SOKOKE_DESKTOP_UNTESTED;
    if (G_UNLIKELY (desktop == SOKOKE_DESKTOP_UNTESTED))
    {
        desktop = SOKOKE_DESKTOP_UNKNOWN;

        /* Are we running in Xfce >= 4.8? */
        if (!g_strcmp0 (g_getenv ("DESKTOP_SESSION"), "xfce"))
        {
            desktop = SOKOKE_DESKTOP_XFCE;
        }
        else
        {
            /* Are we running in Xfce <= 4.6? */
            GdkDisplay* display = gdk_display_get_default ();
            if (GDK_IS_X11_DISPLAY (display))
            {
                Display* xdisplay = GDK_DISPLAY_XDISPLAY (display);
                Window root_window = RootWindow (xdisplay, 0);
                Atom save_mode_atom = gdk_x11_get_xatom_by_name_for_display (
                    display, "_DT_SAVE_MODE");
                Atom actual_type;
                int actual_format;
                unsigned long n_items, bytes;
                gchar* value;
                int status = XGetWindowProperty (xdisplay, root_window,
                    save_mode_atom, 0, (~0L),
                    False, AnyPropertyType, &actual_type, &actual_format,
                    &n_items, &bytes, (unsigned char**)&value);
                if (status == Success)
                {
                    if (n_items == 6 && !strncmp (value, "xfce4", 6))
                        desktop = SOKOKE_DESKTOP_XFCE;
                    XFree (value);
                }
            }
        }
    }

    return desktop;
    #else
    return SOKOKE_DESKTOP_UNKNOWN;
    #endif
}

/**
 * sokoke_xfce_header_new:
 * @icon: an icon name
 * @title: the title of the header
 *
 * Creates an Xfce style header *if* Xfce is running.
 *
 * Return value: A #GtkWidget or %NULL
 *
 * Since 0.1.2 @icon may be NULL, and a default is used.
 **/
GtkWidget*
sokoke_xfce_header_new (const gchar* icon,
                        const gchar* title)
{
    g_return_val_if_fail (title, NULL);

    /* Create an xfce header with icon and title
       This returns NULL if the desktop is not Xfce */
    if (sokoke_get_desktop () == SOKOKE_DESKTOP_XFCE)
    {
        GtkWidget* entry;
        gchar* markup;
        GtkWidget* xfce_heading;
        GtkWidget* hbox;
        GtkWidget* image;
        GtkWidget* label;
        GtkWidget* vbox;
        GtkWidget* separator;

        xfce_heading = gtk_event_box_new ();
        entry = gtk_entry_new ();

        hbox = gtk_hbox_new (FALSE, 12);
        gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
        if (icon)
            image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_DIALOG);
        else
            image = gtk_image_new_from_stock (GTK_STOCK_PREFERENCES,
                GTK_ICON_SIZE_DIALOG);
        gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
        label = gtk_label_new (NULL);
        markup = g_strdup_printf ("<span size='large' weight='bold'>%s</span>",
                                  title);
        gtk_label_set_markup (GTK_LABEL (label), markup);
        gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
        gtk_container_add (GTK_CONTAINER (xfce_heading), hbox);
        g_free (markup);
        gtk_widget_destroy (entry);

        vbox = gtk_vbox_new (FALSE, 0);
        gtk_box_pack_start (GTK_BOX (vbox), xfce_heading, FALSE, FALSE, 0);

        separator = gtk_hseparator_new ();
        gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);

        return vbox;
    }
    return NULL;
}

gboolean
sokoke_key_file_save_to_file (GKeyFile*    key_file,
                              const gchar* filename,
                              GError**     error)
{
    gchar* data;
    gboolean success = FALSE;

    data = g_key_file_to_data (key_file, NULL, error);
    if (!data)
        return FALSE;

    success = g_file_set_contents (filename, data, -1, error);
    g_free (data);
    return success;
}

void
sokoke_widget_get_text_size (GtkWidget*   widget,
                             const gchar* text,
                             gint*        width,
                             gint*        height)
{
    PangoLayout* layout = gtk_widget_create_pango_layout (widget, text);
    pango_layout_get_pixel_size (layout, width, height);
    g_object_unref (layout);
}

/**
 * sokoke_time_t_to_julian:
 * @timestamp: a time_t timestamp value
 *
 * Calculates a unix timestamp to a julian day value.
 *
 * Return value: an integer.
 **/
gint64
sokoke_time_t_to_julian (const time_t* timestamp)
{
    GDate* date;
    gint64 julian;

    date = g_date_new ();

    g_date_set_time_t (date, *timestamp);
    julian = (gint64)g_date_get_julian (date);

    g_date_free (date);

    return julian;
}

gchar*
sokoke_replace_variables (const gchar* template,
                          const gchar* variable_first, ...)
{
    gchar* result = g_strdup (template);
    const gchar* variable;

    va_list args;
    va_start (args, variable_first);

    for (variable = variable_first; variable; variable = va_arg (args, const gchar*))
    {
        const gchar* value = va_arg (args, const gchar*);
        GRegex* regex = g_regex_new (variable, 0, 0, NULL);
        gchar* replaced = result;
        result = g_regex_replace_literal (regex, replaced, -1, 0, value, 0, NULL);
        g_free (replaced);
        g_regex_unref (regex);
    }

    va_end (args);

    return result;
}

/**
 * sokoke_window_activate_key:
 * @window: a #GtkWindow
 * @event: a #GdkEventKey
 *
 * Attempts to activate they key from the event, much
 * like gtk_window_activate_key(), including keys
 * that gtk_accelerator_valid() considers invalid.
 *
 * Return value: %TRUE on success
 **/
gboolean
sokoke_window_activate_key (GtkWindow*   window,
                            GdkEventKey* event)
{
    gchar *accel_name;
    GQuark accel_quark;
    GObject* object;
    GSList *slist;

    if (gtk_window_activate_key (window, event))
        return TRUE;

    /* Hack to allow Ctrl + Shift + Tab */
    if (event->keyval == 65056)
        event->keyval = GDK_KEY_Tab;

    /* We don't use gtk_accel_groups_activate because it refuses to
        activate anything that gtk_accelerator_valid doesn't like. */
    accel_name = gtk_accelerator_name (event->keyval, (event->state & gtk_accelerator_get_default_mod_mask ()));
    accel_quark = g_quark_from_string (accel_name);
    g_free (accel_name);
    object = G_OBJECT (window);

    for (slist = gtk_accel_groups_from_object (object); slist; slist = slist->next)
        if (gtk_accel_group_activate (slist->data, accel_quark,
                                      object, event->keyval, event->state))
            return TRUE;

    return FALSE;
}

/**
 * sokoke_gtk_action_count_modifiers:
 * @action: a #GtkAction
 *
 * Counts the number of modifiers in the accelerator
 * belonging to the action.
 *
 * Return value: the number of modifiers
 **/
guint
sokoke_gtk_action_count_modifiers (GtkAction* action)
{
    GtkAccelKey key;
    gint mods, cmods = 0;
    const gchar* accel_path;

    g_return_val_if_fail (GTK_IS_ACTION (action), 0);

    accel_path = gtk_action_get_accel_path (action);
    if (accel_path)
        if (gtk_accel_map_lookup_entry (accel_path, &key))
        {
            mods = key.accel_mods;
            while (mods)
            {
                if (1 & mods >> 0)
                    cmods++;
                mods = mods >> 1;
            }
        }
    return cmods;
}

/**
 * sokoke_prefetch_uri:
 * @settings: a #MidoriWebSettings instance, or %NULL
 * @uri: an URI string
 *
 * Attempts to prefetch the specified URI, that is
 * it tries to resolve the hostname in advance.
 *
 * Return value: %TRUE on success
 **/
gboolean
sokoke_prefetch_uri (MidoriWebSettings*  settings,
                     const char*         uri,
                     GCallback           callback,
                     gpointer            user_data)
{
    gchar* hostname;

    if (settings && !katze_object_get_boolean (settings, "enable-dns-prefetching"))
        return FALSE;

    if (!(hostname = midori_uri_parse_hostname (uri, NULL))
     || g_hostname_is_ip_address (hostname)
     || !midori_uri_is_http (uri))
    {
        g_free (hostname);
        return FALSE;
    }

    WebKitWebContext* context = webkit_web_context_get_default ();
    webkit_web_context_prefetch_dns (context, hostname);
    g_free (hostname);
    return FALSE;
}

static void
sokoke_widget_clipboard_owner_clear_func (GtkClipboard* clipboard,
                                          gpointer      user_data)
{
    g_object_unref (user_data);
}

void
sokoke_widget_copy_clipboard (GtkWidget*          widget,
                              const gchar*        text,
                              GtkClipboardGetFunc get_cb,
                              gpointer            owner)
{
    GdkDisplay* display = gtk_widget_get_display (widget);
    GtkClipboard* clipboard;

    g_return_if_fail (text != NULL);

    clipboard = gtk_clipboard_get_for_display (display, GDK_SELECTION_PRIMARY);
    gtk_clipboard_set_text (clipboard, text, -1);

    clipboard = gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
    if (get_cb == NULL)
        gtk_clipboard_set_text (clipboard, text, -1);
    else
    {
        GtkTargetList* target_list = gtk_target_list_new (NULL, 0);
        GtkTargetEntry* targets;
        gint n_targets;
        gtk_target_list_add_text_targets (target_list, 0);
        gtk_target_list_add_image_targets (target_list, 0, TRUE);
        targets = gtk_target_table_new_from_list (target_list, &n_targets);
        gtk_clipboard_set_with_owner (clipboard, targets, n_targets, get_cb,
            sokoke_widget_clipboard_owner_clear_func, owner);
        gtk_target_table_free (targets, n_targets);
        gtk_target_list_unref (target_list);
    }
}

static gboolean
sokoke_entry_has_placeholder_text (GtkEntry* entry)
{
    const gchar* text = gtk_entry_get_text (entry);
    const gchar* hint = gtk_entry_get_placeholder_text (entry);
    if (!gtk_widget_has_focus (GTK_WIDGET (entry))
     && hint != NULL
     && (text == NULL || !strcmp (text, hint)))
        return TRUE;
    return FALSE;
}

static void
sokoke_entry_changed_cb (GtkEditable* editable,
                         GtkEntry*    entry)
{
    const gchar* text = gtk_entry_get_text (entry);
    gboolean visible = text && *text
      && ! sokoke_entry_has_placeholder_text (entry);
    gtk_entry_set_icon_from_stock (
        entry, GTK_ENTRY_ICON_SECONDARY,
        visible ? GTK_STOCK_CLEAR : NULL);
}

static gboolean
sokoke_entry_focus_out_event_cb (GtkEditable*   editable,
                                 GdkEventFocus* event,
                                 GtkEntry*      entry)
{
    sokoke_entry_changed_cb (editable, entry);
    return FALSE;
}

static void
sokoke_entry_icon_released_cb (GtkEntry*            entry,
                               GtkEntryIconPosition icon_pos,
                               GdkEvent*            event,
                               gpointer             user_data)
{
    if (icon_pos != GTK_ENTRY_ICON_SECONDARY)
        return;

    gtk_entry_set_text (entry, "");
    gtk_widget_grab_focus (GTK_WIDGET (entry));
}

GtkWidget*
sokoke_search_entry_new (const gchar* placeholder_text)
{
    GtkWidget* entry = gtk_entry_new ();
    gtk_entry_set_placeholder_text (GTK_ENTRY (entry), placeholder_text);
    gtk_entry_set_icon_from_stock (GTK_ENTRY (entry),
                                   GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND);
    gtk_entry_set_icon_activatable (GTK_ENTRY (entry),
        GTK_ENTRY_ICON_SECONDARY, TRUE);
    {
        g_object_connect (entry,
            "signal::icon-release",
            G_CALLBACK (sokoke_entry_icon_released_cb), NULL,
            "signal::focus-in-event",
            G_CALLBACK (sokoke_entry_focus_out_event_cb), entry,
            "signal::focus-out-event",
            G_CALLBACK (sokoke_entry_focus_out_event_cb), entry,
            "signal::changed",
            G_CALLBACK (sokoke_entry_changed_cb), entry, NULL);
        sokoke_entry_changed_cb ((GtkEditable*)entry, GTK_ENTRY (entry));
    }
    return entry;
}

#ifdef G_OS_WIN32
gchar*
sokoke_get_win32_desktop_lnk_path_for_filename (gchar* filename)
{
    const gchar* desktop_dir;
    gchar* lnk_path, *lnk_file;

    /* CSIDL_PROGRAMS for "start menu -> programs" instead - needs saner/shorter filename */
    desktop_dir = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);

    lnk_file = g_strconcat (filename, ".lnk", NULL);
    lnk_path = g_build_filename (desktop_dir, lnk_file, NULL);

    g_free (lnk_file);

    return lnk_path;
}

void
sokoke_create_win32_desktop_lnk (gchar* prefix, gchar* filename, gchar* uri)
{
    WCHAR w[MAX_PATH];

    gchar* exec_dir, *exec_path, *argument;
    gchar* lnk_path, *launcher_type;

    IShellLink* pShellLink;
    IPersistFile* pPersistFile;

    exec_dir = g_win32_get_package_installation_directory_of_module (NULL);
    exec_path = g_build_filename (exec_dir, "bin", "midori.exe", NULL);

    if (g_str_has_suffix (prefix, " -a "))
        launcher_type = "-a";
    else if (g_str_has_suffix (prefix, " -c "))
        launcher_type = "-c";
    else
        g_assert_not_reached ();

    argument = g_strdup_printf ("%s \"%s\"", launcher_type, uri);

    /* Create link */
    CoCreateInstance (&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLink, (LPVOID *)&pShellLink);
    pShellLink->lpVtbl->SetPath (pShellLink, exec_path);
    pShellLink->lpVtbl->SetArguments (pShellLink, argument);
    /* TODO: support adding site favicon as webapp icon */
    /* pShellLink->lpVtbl->SetIconLocation (pShellLink, icon_path, icon_index); */

    /* Save link */
    lnk_path = sokoke_get_win32_desktop_lnk_path_for_filename (filename);
    pShellLink->lpVtbl->QueryInterface (pShellLink, &IID_IPersistFile, (LPVOID *)&pPersistFile);
    MultiByteToWideChar (CP_UTF8, 0, lnk_path, -1, w, MAX_PATH);
    pPersistFile->lpVtbl->Save (pPersistFile, w, TRUE);

    pPersistFile->lpVtbl->Release (pPersistFile);
    pShellLink->lpVtbl->Release (pShellLink);

    g_free (exec_dir);
    g_free (exec_path);
    g_free (argument);
    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