/*

 * Copyright (C) 2001 Ximian, Inc.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of the

 * License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * Authors:

 *   Chema Celorio <chema@celorio.com>

 */

#include <config.h>

/**

 * SECTION:glade-utils

 * @Title: Glade Utils

 * @Short_Description: Welcome to the zoo.

 *

 * This is where all of that really usefull miscalanious stuff lands up.

 */

#include "glade.h"

#include "glade-project.h"

#include "glade-command.h"

#include "glade-debug.h"

#include "glade-placeholder.h"

#include "glade-widget.h"

#include "glade-widget-adaptor.h"

#include "glade-property.h"

#include "glade-property-class.h"

#include "glade-clipboard.h"

#include "glade-private.h"

#include <string.h>

#include <gdk/gdkkeysyms.h>

#include <gmodule.h>

#include <glib/gi18n-lib.h>

#include <glib/gstdio.h>

#include <errno.h>

#ifdef G_OS_WIN32

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#include <shellapi.h>

#endif

#define GLADE_UTIL_COPY_BUFFSIZE       1024

/**

 * glade_util_compose_get_type_func:

 * @name:

 *

 * TODO: write me

 *

 * Returns:

 */

static gchar *

glade_util_compose_get_type_func (const gchar *name)

{

  gchar *retval;

  GString *tmp;

  gint i = 1, j;

  tmp = g_string_new (name);

  while (tmp->str[i])

    {

      if (g_ascii_isupper (tmp->str[i]))

        {

          tmp = g_string_insert_c (tmp, i++, '_');

          j = 0;

          while (g_ascii_isupper (tmp->str[i++]))

            j++;

          if (j > 2)

            g_string_insert_c (tmp, i - 2, '_');

          continue;

        }

      i++;

    }

  tmp = g_string_append (tmp, "_get_type");

  retval = g_ascii_strdown (tmp->str, tmp->len);

  g_string_free (tmp, TRUE);

  return retval;

}

/**

 * glade_util_get_type_from_name:

 * @name: the name of the #GType - like 'GtkWidget' or a "get-type" function.

 * @have_func: function-name flag -- true if the name is a "get-type" function.

 *

 * Returns the type using the "get type" function name based on @name.  

 * If the @have_func flag is true,@name is used directly, otherwise the get-type 

 * function is contrived from @name then used.

 *

 * Returns: the new #GType

 */

GType

glade_util_get_type_from_name (const gchar *name, gboolean have_func)

{

  static GModule *allsymbols = NULL;

  GType (*get_type) (void);

  GType type = 0;

  gchar *func_name = (gchar *) name;

  if ((type = g_type_from_name (name)) == 0 &&

      (have_func ||

       (func_name = glade_util_compose_get_type_func (name)) != NULL))

    {

      if (!allsymbols)

        allsymbols = g_module_open (NULL, 0);

      if (g_module_symbol (allsymbols, func_name, (gpointer) & get_type))

        {

          g_assert (get_type);

          type = get_type ();

        }

      else

        {

          g_warning (_("We could not find the symbol \"%s\""), func_name);

        }

      if (!have_func)

	g_free (func_name);

    }

  if (type == 0)

    g_warning (_("Could not get the type from \"%s\""), name);

  return type;

}

/**

 * glade_utils_get_pspec_from_funcname:

 * @funcname: the symbol name of a function to generate a #GParamSpec

 *

 * Returns: A #GParamSpec created by the delagate function

 *          specified by @funcname

 */

GParamSpec *

glade_utils_get_pspec_from_funcname (const gchar *funcname)

{

  static GModule *allsymbols = NULL;

  GParamSpec *pspec = NULL;

  GParamSpec *(*get_pspec) (void) = NULL;

  if (!allsymbols)

    allsymbols = g_module_open (NULL, 0);

  if (!g_module_symbol (allsymbols, funcname, (gpointer) & get_pspec))

    {

      g_warning (_("We could not find the symbol \"%s\""), funcname);

      return NULL;

    }

  g_assert (get_pspec);

  pspec = get_pspec ();

  return pspec;

}

void

_glade_util_dialog_set_hig (GtkDialog *dialog)

{

  GtkWidget *vbox, *action_area;

  /* HIG spacings */

  vbox = gtk_dialog_get_content_area (dialog);

  gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);

  gtk_box_set_spacing (GTK_BOX (vbox), 2); /* 2 * 5 + 2 = 12 */

  action_area = gtk_dialog_get_action_area (dialog);

  gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);

  gtk_box_set_spacing (GTK_BOX (action_area), 6);

}

/**

 * glade_util_ui_message:

 * @parent: a #GtkWindow cast as a #GtkWidget

 * @type:   a #GladeUIMessageType

 * @widget: a #GtkWidget to append to the dialog vbox

 * @format: a printf style format string

 * @...:    args for the format.

 *

 * Creates a new warning dialog window as a child of @parent containing

 * the text of @format, runs it, then destroys it on close. Depending

 * on @type, a cancel button may apear or the icon may change.

 *

 * Returns: True if the @type was GLADE_UI_ARE_YOU_SURE and the user

 *          selected "OK", True if the @type was GLADE_UI_YES_OR_NO and

 *          the user selected "YES"; False otherwise.

 */

gint

glade_util_ui_message (GtkWidget *parent,

                       GladeUIMessageType type,

                       GtkWidget *widget,

                       const gchar *format,

                       ...)

{

  GtkWidget *dialog;

  GtkMessageType message_type = GTK_MESSAGE_INFO;

  GtkButtonsType buttons_type = GTK_BUTTONS_OK;

  va_list args;

  gchar *string;

  gint response;

  va_start (args, format);

  string = g_strdup_vprintf (format, args);

  va_end (args);

  /* Get message_type */

  switch (type)

    {

      case GLADE_UI_INFO:

        message_type = GTK_MESSAGE_INFO;

        break;

      case GLADE_UI_WARN:

      case GLADE_UI_ARE_YOU_SURE:

        message_type = GTK_MESSAGE_WARNING;

        break;

      case GLADE_UI_ERROR:

        message_type = GTK_MESSAGE_ERROR;

        break;

      case GLADE_UI_YES_OR_NO:

        message_type = GTK_MESSAGE_QUESTION;

        break;

        break;

      default:

        g_critical ("Bad arg for glade_util_ui_message");

        break;

    }

  /* Get buttons_type */

  switch (type)

    {

      case GLADE_UI_INFO:

      case GLADE_UI_WARN:

      case GLADE_UI_ERROR:

        buttons_type = GTK_BUTTONS_OK;

        break;

      case GLADE_UI_ARE_YOU_SURE:

        buttons_type = GTK_BUTTONS_OK_CANCEL;

        break;

      case GLADE_UI_YES_OR_NO:

        buttons_type = GTK_BUTTONS_YES_NO;

        break;

        break;

      default:

        g_critical ("Bad arg for glade_util_ui_message");

        break;

    }

  dialog = gtk_message_dialog_new (GTK_WINDOW (parent),

                                   GTK_DIALOG_DESTROY_WITH_PARENT,

                                   message_type, buttons_type, NULL);

  gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), string);

  if (widget)

    {

      gtk_box_pack_end (GTK_BOX

                        (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),

                        widget, TRUE, TRUE, 2);

      gtk_widget_show (widget);

      /* If theres additional content, make it resizable */

      gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);

    }

  response = gtk_dialog_run (GTK_DIALOG (dialog));

  gtk_widget_destroy (dialog);

  g_free (string);

  return (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_YES);

}

gboolean

glade_util_check_and_warn_scrollable (GladeWidget *parent,

                                      GladeWidgetAdaptor *child_adaptor,

                                      GtkWidget *parent_widget)

{

  if (GTK_IS_SCROLLED_WINDOW (glade_widget_get_object (parent)) &&

      GWA_SCROLLABLE_WIDGET (child_adaptor) == FALSE)

    {

      GladeWidgetAdaptor *vadaptor =

          glade_widget_adaptor_get_by_type (GTK_TYPE_VIEWPORT);

      GladeWidgetAdaptor *parent_adaptor = glade_widget_get_adaptor (parent);

      glade_util_ui_message (parent_widget,

                             GLADE_UI_INFO, NULL,

                             _("Cannot add non scrollable %s widget to a %s directly.\n"

			       "Add a %s first."), 

			     glade_widget_adaptor_get_title (child_adaptor),

                             glade_widget_adaptor_get_title (parent_adaptor), 

			     glade_widget_adaptor_get_title (vadaptor));

      return TRUE;

    }

  return FALSE;

}

typedef struct

{

  GtkStatusbar *statusbar;

  guint context_id;

  guint message_id;

} FlashInfo;

static const guint flash_length = 3;

static gboolean

remove_message_timeout (FlashInfo *fi)

{

  gtk_statusbar_remove (fi->statusbar, fi->context_id, fi->message_id);

  g_slice_free (FlashInfo, fi);

  /* remove the timeout */

  return FALSE;

}

/**

 * glade_utils_flash_message:

 * @statusbar: The statusbar

 * @context_id: The message context_id

 * @format: The message to flash on the statusbar

 *

 * Flash a temporary message on the statusbar.

 */

void

glade_util_flash_message (GtkWidget *statusbar,

                          guint context_id,

                          gchar *format,

                          ...)

{

  va_list args;

  FlashInfo *fi;

  gchar *message;

  g_return_if_fail (GTK_IS_STATUSBAR (statusbar));

  g_return_if_fail (format != NULL);

  va_start (args, format);

  message = g_strdup_vprintf (format, args);

  va_end (args);

  fi = g_slice_new0 (FlashInfo);

  fi->statusbar = GTK_STATUSBAR (statusbar);

  fi->context_id = context_id;

  fi->message_id = gtk_statusbar_push (fi->statusbar, fi->context_id, message);

  g_timeout_add_seconds (flash_length, (GSourceFunc) remove_message_timeout,

                         fi);

  g_free (message);

}

static gint

glade_util_compare_uline_labels (const gchar *labela, const gchar *labelb)

{

  for (;;)

    {

      gunichar c1, c2;

      if (*labela == '\0')

        return (*labelb == '\0') ? 0 : -1;

      if (*labelb == '\0')

        return 1;

      c1 = g_utf8_get_char (labela);

      if (c1 == '_')

        {

          labela = g_utf8_next_char (labela);

          c1 = g_utf8_get_char (labela);

        }

      c2 = g_utf8_get_char (labelb);

      if (c2 == '_')

        {

          labelb = g_utf8_next_char (labelb);

          c2 = g_utf8_get_char (labelb);

        }

      if (c1 < c2)

        return -1;

      if (c1 > c2)

        return 1;

      labela = g_utf8_next_char (labela);

      labelb = g_utf8_next_char (labelb);

    }

  /* Shouldn't be reached. */

  return 0;

}

/**

 * glade_util_compare_stock_labels:

 * @a: a #gconstpointer to a #GtkStockItem

 * @b: a #gconstpointer to a #GtkStockItem

 *

 * This is a #GCompareFunc that compares the labels of two stock items, 

 * ignoring any '_' characters. It isn't particularly efficient.

 *

 * Returns: negative value if @a < @b; zero if @a = @b; 

 *          positive value if @a > @b

 */

gint

glade_util_compare_stock_labels (gconstpointer a, gconstpointer b)

{

  const gchar *stock_ida = a, *stock_idb = b;

  GtkStockItem itema, itemb;

  gboolean founda, foundb;

  gint retval;

G_GNUC_BEGIN_IGNORE_DEPRECATIONS

  founda = gtk_stock_lookup (stock_ida, &itema);

  foundb = gtk_stock_lookup (stock_idb, &itemb);

G_GNUC_END_IGNORE_DEPRECATIONS

  if (founda)

    {

      if (!foundb)

        retval = -1;

      else

        /* FIXME: Not ideal for UTF-8. */

        retval = glade_util_compare_uline_labels (itema.label, itemb.label);

    }

  else

    {

      if (!foundb)

        retval = 0;

      else

        retval = 1;

    }

  return retval;

}

/**

 * glade_util_file_dialog_new:

 * @title: dialog title

 * @project: a #GladeProject used when saving

 * @parent: a parent #GtkWindow for the dialog

 * @action: a #GladeUtilFileDialogType to say if the dialog will open or save

 *

 * Returns: a "glade file" file chooser dialog. The caller is responsible 

 *          for showing the dialog

 */

GtkWidget *

glade_util_file_dialog_new (const gchar *title,

                            GladeProject *project,

                            GtkWindow *parent,

                            GladeUtilFileDialogType action)

{

  GtkWidget *file_dialog;

  GtkFileFilter *file_filter;

  g_return_val_if_fail ((action == GLADE_FILE_DIALOG_ACTION_OPEN ||

                         action == GLADE_FILE_DIALOG_ACTION_SAVE), NULL);

  g_return_val_if_fail ((action != GLADE_FILE_DIALOG_ACTION_SAVE ||

                         GLADE_IS_PROJECT (project)), NULL);

  file_dialog = gtk_file_chooser_dialog_new (title, parent, action,

                                             _("_Cancel"), GTK_RESPONSE_CANCEL,

                                             action ==

                                             GLADE_FILE_DIALOG_ACTION_OPEN ?

                                             _("_Open") : _("_Save"),

                                             GTK_RESPONSE_OK, NULL);

  file_filter = gtk_file_filter_new ();

  gtk_file_filter_add_pattern (file_filter, "*");

  gtk_file_filter_set_name (file_filter, _("All Files"));

  gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_dialog), file_filter);

  file_filter = gtk_file_filter_new ();

  gtk_file_filter_add_pattern (file_filter, "*.glade");

  gtk_file_filter_set_name (file_filter, _("Libglade Files"));

  gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_dialog), file_filter);

  file_filter = gtk_file_filter_new ();

  gtk_file_filter_add_pattern (file_filter, "*.ui");

  gtk_file_filter_set_name (file_filter, _("GtkBuilder Files"));

  gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_dialog), file_filter);

  file_filter = gtk_file_filter_new ();

  gtk_file_filter_add_pattern (file_filter, "*.ui");

  gtk_file_filter_add_pattern (file_filter, "*.glade");

  gtk_file_filter_set_name (file_filter, _("All Glade Files"));

  gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (file_dialog), file_filter);

  gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (file_dialog), file_filter);

  gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER

                                                  (file_dialog), TRUE);

  gtk_dialog_set_default_response (GTK_DIALOG (file_dialog), GTK_RESPONSE_OK);

  return file_dialog;

}

/**

 * glade_util_replace:

 * @str: a string

 * @a: a #gchar

 * @b: a #gchar

 *

 * Replaces each occurance of the character @a in @str to @b.

 */

void

glade_util_replace (gchar *str, gchar a, gchar b)

{

  g_return_if_fail (str != NULL);

  while (*str != 0)

    {

      if (*str == a)

        *str = b;

      str = g_utf8_next_char (str);

    }

}

/**

 * _glade_util_strreplace:

 * @str: a string

 * @free_str: wheter to free str or not

 * @key: the key string to search for

 * @replacement: string to replace key

 *

 * Replaces each occurance of the string @key in @str to @replacement.

 */

gchar *

_glade_util_strreplace (gchar *str,

                        gboolean free_str,

                        const gchar *key,

                        const gchar *replacement)

{

  gchar *retval, **array;

  if ((array = g_strsplit (str, key, -1)) && array[0])

    retval = g_strjoinv (replacement, array);

  else

    retval = g_strdup (str);

  g_strfreev (array);

  if (free_str)

    g_free (str);

  return retval;

}

/**

 * glade_util_read_prop_name:

 * @str: a string

 *

 * Return a usable version of a property identifier as found

 * in a freshly parserd #GladeInterface

 */

gchar *

glade_util_read_prop_name (const gchar *str)

{

  gchar *id;

  g_return_val_if_fail (str != NULL, NULL);

  id = g_strdup (str);

  glade_util_replace (id, '_', '-');

  return id;

}

/**

 * glade_util_duplicate_underscores:

 * @name: a string

 *

 * Duplicates @name, but the copy has two underscores in place of any single

 * underscore in the original.

 *

 * Returns: a newly allocated string

 */

gchar *

glade_util_duplicate_underscores (const gchar *name)

{

  const gchar *tmp;

  const gchar *last_tmp = name;

  gchar *underscored_name = g_malloc (strlen (name) * 2 + 1);

  gchar *tmp_underscored = underscored_name;

  for (tmp = last_tmp; *tmp; tmp = g_utf8_next_char (tmp))

    {

      if (*tmp == '_')

        {

          memcpy (tmp_underscored, last_tmp, tmp - last_tmp + 1);

          tmp_underscored += tmp - last_tmp + 1;

          last_tmp = tmp + 1;

          *tmp_underscored++ = '_';

        }

    }

  memcpy (tmp_underscored, last_tmp, tmp - last_tmp + 1);

  return underscored_name;

}

/*

 * taken from gtk... maybe someday we can convince them to

 * expose gtk_container_get_all_children

 */

static void

gtk_container_children_callback (GtkWidget *widget, gpointer client_data)

{

  GList **children;

  children = (GList **) client_data;

  if (!g_list_find (*children, widget))

    *children = g_list_prepend (*children, widget);

}

/**

 * glade_util_container_get_all_children:

 * @container: a #GtkContainer

 *

 * Use this to itterate over all children in a GtkContainer,

 * as it used _forall() instead of _foreach() (and the GTK+ version

 * of this function is simply not exposed).

 *

 * Note that glade_widget_class_get_children() is the high-level

 * abstraction and will usually end up calling this function.

 *

 * Returns: a #GList giving the contents of @container

 */

GList *

glade_util_container_get_all_children (GtkContainer *container)

{

  GList *children = NULL;

  g_return_val_if_fail (GTK_IS_CONTAINER (container), NULL);

  gtk_container_forall (container, gtk_container_children_callback, &children);

  gtk_container_foreach (container, gtk_container_children_callback, &children);

  /* Preserve the natural order by reversing the list */

  return g_list_reverse (children);

}

/**

 * glade_util_count_placeholders:

 * @parent: a #GladeWidget

 *

 * Returns: the amount of #GladePlaceholders parented by @parent

 */

gint

glade_util_count_placeholders (GladeWidget *parent)

{

  gint placeholders = 0;

  GList *list, *children;

  /* count placeholders */

  if ((children = 

       glade_widget_adaptor_get_children (glade_widget_get_adaptor (parent), 

					  glade_widget_get_object (parent))) != NULL)

    {

      for (list = children; list && list->data; list = list->next)

        {

          if (GLADE_IS_PLACEHOLDER (list->data))

            placeholders++;

        }

      g_list_free (children);

    }

  return placeholders;

}

static GtkTreeIter *

glade_util_find_iter (GtkTreeModel *model,

                      GtkTreeIter *iter,

                      GladeWidget *findme,

                      gint column)

{

  GtkTreeIter *retval = NULL;

  GObject *object = NULL;

  GtkTreeIter *next;

  g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL);

  g_return_val_if_fail (iter != NULL, NULL);

  next = gtk_tree_iter_copy (iter);

  g_return_val_if_fail (next != NULL, NULL);

  while (retval == NULL)

    {

      GladeWidget *widget;

      gtk_tree_model_get (model, next, column, &object, -1);

      if (object &&

          gtk_tree_model_get_column_type (model, column) == G_TYPE_OBJECT)

        g_object_unref (object);

      widget = glade_widget_get_from_gobject (object);

      if (widget == findme)

        {

          retval = gtk_tree_iter_copy (next);

          break;

        }

      else if (glade_widget_is_ancestor (findme, widget))

        {

          if (gtk_tree_model_iter_has_child (model, next))

            {

              GtkTreeIter child;

              gtk_tree_model_iter_children (model, &child, next);

              if ((retval = glade_util_find_iter

                   (model, &child, findme, column)) != NULL)

                break;

            }

          /* Only search the branches where the searched widget

           * is actually a child of the this row, optimize the

           * searching this way

           */

          break;

        }

      if (!gtk_tree_model_iter_next (model, next))

        break;

    }

  gtk_tree_iter_free (next);

  return retval;

}

/**

 * glade_util_find_iter_by_widget:

 * @model: a #GtkTreeModel

 * @findme: a #GladeWidget

 * @column: a #gint

 *

 * Looks through @model for the #GtkTreeIter corresponding to 

 * @findme under @column.

 *

 * Returns: a newly allocated #GtkTreeIter from @model corresponding

 * to @findme which should be freed with gtk_tree_iter_free()

 * 

 */

GtkTreeIter *

glade_util_find_iter_by_widget (GtkTreeModel *model,

                                GladeWidget *findme,

                                gint column)

{

  GtkTreeIter iter;

  if (gtk_tree_model_get_iter_first (model, &iter))

    {

      return glade_util_find_iter (model, &iter, findme, column);

    }

  return NULL;

}

/**

 * glade_util_purify_list:

 * @list: A #GList

 *

 * Returns: A newly allocated version of @list with no 

 *          duplicate data entries

 */

GList *

glade_util_purify_list (GList * list)

{

  GList *l, *newlist = NULL;

  for (l = list; l; l = l->next)

    if (!g_list_find (newlist, l->data))

      newlist = g_list_prepend (newlist, l->data);

  g_list_free (list);

  return g_list_reverse (newlist);

}

/**

 * glade_util_added_in_list:

 * @old_list: the old #GList

 * @new_list: the new #GList

 *

 * Returns: A newly allocated #GList of elements that

 *          are in @new but not in @old

 *

 */

GList *

glade_util_added_in_list (GList *old_list, GList *new_list)

{

  GList *added = NULL, *list;

  for (list = new_list; list; list = list->next)

    {

      if (!g_list_find (old_list, list->data))

        added = g_list_prepend (added, list->data);

    }

  return g_list_reverse (added);

}

/**

 * glade_util_removed_from_list:

 * @old_list: the old #GList

 * @new_list: the new #GList

 *

 * Returns: A newly allocated #GList of elements that

 *          are in @old no longer in @new

 *

 */

GList *

glade_util_removed_from_list (GList *old_list, GList *new_list)

{

  GList *added = NULL, *list;

  for (list = old_list; list; list = list->next)

    {

      if (!g_list_find (new_list, list->data))

        added = g_list_prepend (added, list->data);

    }

  return g_list_reverse (added);

}

/**

 * glade_util_canonical_path:

 * @path: any path that may contain ".." or "." components

 *

 * Returns: an absolute path to the specified file or directory

 *          that contains no ".." or "." components (this does

 *          not call readlink like realpath() does).

 *

 * Note: on some systems; I think its possible that we dont have

 *       permission to execute in the directory in which the glade

 *       file resides; I decided finally to do it this way anyway

 *       since libc's realpath() does exactly the same.

 */

gchar *

glade_util_canonical_path (const gchar *path)

{

  gchar *orig_dir, *dirname, *basename, *direct_dir, *direct_name = NULL;

  g_return_val_if_fail (path != NULL, NULL);

  basename = g_path_get_basename (path);

  if ((orig_dir = g_get_current_dir ()) != NULL)

    {

      if ((dirname = g_path_get_dirname (path)) != NULL)

        {

          if (g_chdir (dirname) == 0)

            {

              if ((direct_dir = g_get_current_dir ()) != NULL)

		{

		  direct_name = g_build_filename (direct_dir, basename, NULL);

		  g_free (direct_dir);

		}

              else