/*
 * 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
                g_warning ("g_path");

              if (g_chdir (orig_dir) != 0)
                g_warning ("Unable to chdir back to %s directory (%s)",
                           orig_dir, g_strerror (errno));

            }
          else
            g_warning ("Unable to chdir to %s directory (%s)",
                       dirname, g_strerror (errno));

          g_free (dirname);
        }
      else
        g_warning ("Unable to get directory component of %s\n", path);
      g_free (orig_dir);
    }

  if (basename)
    g_free (basename);

  return direct_name;
}

static GModule *
try_load_library (const gchar *library_path, const gchar *library_name)
{
  gchar *path = g_module_build_path (library_path, library_name);
  GModule *module = NULL;

  if (!library_path || g_file_test (path, G_FILE_TEST_EXISTS))
    {
      if (!(module = g_module_open (path, G_MODULE_BIND_LAZY)))
        g_warning ("Failed to load %s: %s", path, g_module_error ());
    }

  g_free (path);

  return module;
}

/**
 * glade_util_load_library:
 * @library_name: name of the library
 *
 * Loads the named library from the Glade modules and lib directory or failing that
 * from the standard platform specific directories. (Including /usr/local/lib for unices)
 *
 * The @library_name should not include any platform specifix prefix or suffix,
 * those are automatically added, if needed, by g_module_build_path()
 *
 * Returns: a #GModule on success, or %NULL on failure.
 */
GModule *
glade_util_load_library (const gchar *library_name)
{
  GModule *module = NULL;
  const gchar *search_path;
  gint i;

  if ((search_path = g_getenv (GLADE_ENV_MODULE_PATH)) != NULL)
    {
      gchar **split;

      if ((split = g_strsplit (search_path, ":", 0)) != NULL)
        {
          for (i = 0; split[i] != NULL; i++)
            if ((module = try_load_library (split[i], library_name)) != NULL)
              break;

          g_strfreev (split);
        }
    }

  if (g_getenv (GLADE_ENV_TESTING) == NULL && !module)
    {
      const gchar *paths[] = { glade_app_get_modules_dir (),
                               glade_app_get_lib_dir (),
#ifndef G_OS_WIN32 /* Try local lib dir on Unices */
                               "/usr/local/lib",
#endif
                               NULL}; /* Use default system paths */

      
      for (i = 0; i < G_N_ELEMENTS (paths); i++)
        if ((module = try_load_library (paths[i], library_name)) != NULL)
          break;
    }

  return module;
}

/**
 * glade_util_file_is_writeable:
 * @path:  the path to the file
 *
 * Checks whether the file at @path is writeable
 *
 * Returns: TRUE if file is writeable
 */
gboolean
glade_util_file_is_writeable (const gchar *path)
{
  GIOChannel *channel;
  g_return_val_if_fail (path != NULL, FALSE);

  /* The only way to really know if the file is writable */
  if ((channel = g_io_channel_new_file (path, "a+", NULL)) != NULL)
    {
      g_io_channel_unref (channel);
      return TRUE;
    }
  return FALSE;
}

/**
 * glade_util_have_devhelp:
 *
 * Returns: whether the devhelp module is loaded
 */
gboolean
glade_util_have_devhelp (void)
{
  static gint have_devhelp = -1;
  gchar *ptr;
  gint cnt, ret, major, minor;
  GError *error = NULL;

#define DEVHELP_OLD_MESSAGE  \
    "The DevHelp installed on your system is too old, " \
    "devhelp feature will be disabled."

#define DEVHELP_MISSING_MESSAGE  \
    "No DevHelp installed on your system, " \
    "devhelp feature will be disabled."

  if (have_devhelp >= 0)
    return have_devhelp;

  have_devhelp = 0;

  if ((ptr = g_find_program_in_path ("devhelp")) != NULL)
    {
      g_free (ptr);

      if (g_spawn_command_line_sync ("devhelp --version",
                                     &ptr, NULL, &ret, &error))
        {
          /* If we have a successfull return code.. parse the output.
           */
          if (ret == 0)
            {
              gchar name[16];
              if ((cnt = sscanf (ptr, "%15s %d.%d\n",
                                 name, &major, &minor)) == 3)
                {
                  /* Devhelp 0.12 required.
                   */
                  if (major >= 2 || (major >= 0 && minor >= 12))
                    have_devhelp = 1;
                  else
                    g_message (DEVHELP_OLD_MESSAGE);
                }
              else

                {
                  if (ptr != NULL || strlen (ptr) > 0)
                    g_warning ("devhelp had unparsable output: "
                               "'%s' (parsed %d elements)", ptr, cnt);
                  else
                    g_message (DEVHELP_OLD_MESSAGE);
                }
            }
          else
            g_warning ("devhelp had bad return code: '%d'", ret);
        }
      else
        {
          g_warning ("Error trying to launch devhelp: %s", error->message);
          g_error_free (error);
        }
    }
  else
    g_message (DEVHELP_MISSING_MESSAGE);

  return have_devhelp;
}

/**
 * glade_util_get_devhelp_icon:
 * @size: the preferred icon size
 *
 * Creates an image displaying the devhelp icon.
 *
 * Returns: a #GtkImage
 */
GtkWidget *
glade_util_get_devhelp_icon (GtkIconSize size)
{
  GtkIconTheme *icon_theme;
  GdkScreen *screen;
  GtkWidget *image;
  gchar *path;

  image = gtk_image_new ();
  screen = gtk_widget_get_screen (GTK_WIDGET (image));
  icon_theme = gtk_icon_theme_get_for_screen (screen);

  if (gtk_icon_theme_has_icon (icon_theme, GLADE_DEVHELP_ICON_NAME))
    {
      gtk_image_set_from_icon_name (GTK_IMAGE (image), GLADE_DEVHELP_ICON_NAME,
                                    size);
    }
  else
    {
      path =
          g_build_filename (glade_app_get_pixmaps_dir (),
                            GLADE_DEVHELP_FALLBACK_ICON_FILE, NULL);

      gtk_image_set_from_file (GTK_IMAGE (image), path);

      g_free (path);
    }

  return image;
}

/**
 * glade_util_search_devhep:
 * @devhelp: the devhelp widget created by the devhelp module.
 * @book: the devhelp book (or %NULL)
 * @page: the page in the book (or %NULL)
 * @search: the search string (or %NULL)
 *
 * Envokes devhelp with the appropriate search string
 *
 */
void
glade_util_search_devhelp (const gchar *book,
                           const gchar *page,
                           const gchar *search)
{
  GError *error = NULL;
  gchar *book_comm = NULL, *page_comm = NULL, *search_comm = NULL;
  gchar *string;

  g_return_if_fail (glade_util_have_devhelp ());

  if (book)
    book_comm = g_strdup_printf ("book:%s", book);
  if (page)
    page_comm = g_strdup_printf (" page:%s", page);
  if (search)
    search_comm = g_strdup_printf (" %s", search);

  string = g_strdup_printf ("devhelp -s \"%s%s%s\"",
                            book_comm ? book_comm : "",
                            page_comm ? page_comm : "",
                            search_comm ? search_comm : "");

  if (g_spawn_command_line_async (string, &error) == FALSE)
    {
      g_warning ("Error envoking devhelp: %s", error->message);
      g_error_free (error);
    }

  g_free (string);
  if (book_comm)
    g_free (book_comm);
  if (page_comm)
    g_free (page_comm);
  if (search_comm)
    g_free (search_comm);
}

GtkWidget *
glade_util_get_placeholder_from_pointer (GtkContainer *container)
{
  GdkDeviceManager *manager;
  GdkDisplay *display;
  GdkDevice *device;
  GdkWindow *window;

  if (((display = gtk_widget_get_display (GTK_WIDGET (container))) || 
       (display = gdk_display_get_default ())) &&
      (manager = gdk_display_get_device_manager (display)) &&
      (device = gdk_device_manager_get_client_pointer (manager)) &&
      (window = gdk_device_get_window_at_position (device, NULL, NULL)))
    {
      gpointer widget;
      gdk_window_get_user_data (window, &widget);

      return GLADE_IS_PLACEHOLDER (widget) ? GTK_WIDGET (widget) : NULL;
    }

  return NULL;
}

/**
 * glade_util_object_is_loading:
 * @object: A #GObject
 *
 * Returns: Whether the object's project is being loaded or not.
 *       
 */
gboolean
glade_util_object_is_loading (GObject *object)
{
  GladeProject *project;
  GladeWidget *widget;

  g_return_val_if_fail (G_IS_OBJECT (object), FALSE);

  widget = glade_widget_get_from_gobject (object);
  g_return_val_if_fail (GLADE_IS_WIDGET (widget), FALSE);

  project = glade_widget_get_project (widget);

  return project && glade_project_is_loading (project);
}

/**
 * glade_util_url_show:
 * @url: An URL to display
 *
 * Portable function for showing an URL @url in a web browser.
 *
 * Returns: TRUE if a web browser was successfully launched, or FALSE
 *
 */
gboolean
glade_util_url_show (const gchar *url)
{
  GtkWidget *widget;
  GError *error = NULL;
  gboolean ret;

  g_return_val_if_fail (url != NULL, FALSE);

  widget = glade_app_get_window ();

  ret = gtk_show_uri (gtk_widget_get_screen (widget),
                      url, gtk_get_current_event_time (), &error);
  if (error != NULL)
    {
      GtkWidget *dialog_widget;

      dialog_widget = gtk_message_dialog_new (GTK_WINDOW (widget),
                                              GTK_DIALOG_DESTROY_WITH_PARENT,
                                              GTK_MESSAGE_ERROR,
                                              GTK_BUTTONS_CLOSE,
                                              "%s", _("Could not show link:"));
      gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG
                                                (dialog_widget), "%s",
                                                error->message);
      g_error_free (error);

      g_signal_connect (dialog_widget, "response",
                        G_CALLBACK (gtk_widget_destroy), NULL);

      gtk_window_present (GTK_WINDOW (dialog_widget));
    }

  return ret;
}

/**
 * glade_util_get_file_mtime:
 * @filename: A filename
 * @error: return location for errors
 *
 * Gets the UTC modification time of file @filename.
 *
 * Returns: The mtime of the file, or %0 if the file attributes
 *          could not be read.
 */
time_t
glade_util_get_file_mtime (const gchar *filename, GError **error)
{
  struct stat info;
  gint retval;

  retval = g_stat (filename, &info);

  if (retval != 0)
    {
      g_set_error (error,
                   G_FILE_ERROR,
                   g_file_error_from_errno (errno),
                   "could not stat file '%s': %s", filename,
                   g_strerror (errno));
      return (time_t) 0;
    }
  else
    {
      return info.st_mtime;
    }
}

gchar *
glade_util_filename_to_icon_name (const gchar *value)
{
  gchar *icon_name, *p;
  g_return_val_if_fail (value && value[0], NULL);

  icon_name = g_strdup_printf ("glade-generated-%s", value);

  if ((p = strrchr (icon_name, '.')) != NULL)
    *p = '-';

  return icon_name;
}

gchar *
glade_util_icon_name_to_filename (const gchar *value)
{
  /* sscanf makes us allocate a buffer */
  gchar filename[FILENAME_MAX], *p;
  g_return_val_if_fail (value && value[0], NULL);

  sscanf (value, "glade-generated-%s", filename);

  /* XXX: Filenames without an extention will evidently
   * break here
   */
  if ((p = strrchr (filename, '-')) != NULL)
    *p = '.';

  return g_strdup (filename);
}

gint
glade_utils_enum_value_from_string (GType enum_type, const gchar *strval)
{
  gint value = 0;
  const gchar *displayable;
  GValue *gvalue;

  g_return_val_if_fail (strval && strval[0], 0);

  if (((displayable =
        glade_get_value_from_displayable (enum_type, strval)) != NULL &&
       (gvalue =
        glade_utils_value_from_string (enum_type, displayable, NULL)) != NULL) ||
      (gvalue =
       glade_utils_value_from_string (enum_type, strval, NULL)) != NULL)
    {
      value = g_value_get_enum (gvalue);
      g_value_unset (gvalue);
      g_free (gvalue);
    }
  return value;
}

static gchar *
glade_utils_enum_string_from_value_real (GType enum_type,
                                         gint value,
                                         gboolean displayable)
{
  GValue gvalue = { 0, };
  gchar *string;

  g_value_init (&gvalue, enum_type);
  g_value_set_enum (&gvalue, value);

  string = glade_utils_string_from_value (&gvalue);
  g_value_unset (&gvalue);

  if (displayable && string)
    {
      const gchar *dstring = glade_get_displayable_value (enum_type, string);
      if (dstring)
        {
          g_free (string);
          return g_strdup (dstring);
        }
    }

  return string;
}

gchar *
glade_utils_enum_string_from_value (GType enum_type, gint value)
{
  return glade_utils_enum_string_from_value_real (enum_type, value, FALSE);
}

gchar *
glade_utils_enum_string_from_value_displayable (GType enum_type, gint value)
{
  return glade_utils_enum_string_from_value_real (enum_type, value, TRUE);
}


gint
glade_utils_flags_value_from_string (GType flags_type, const gchar *strval)
{
  gint value = 0;
  const gchar *displayable;
  GValue *gvalue;

  g_return_val_if_fail (strval && strval[0], 0);

  if (((displayable =
        glade_get_value_from_displayable (flags_type, strval)) != NULL &&
       (gvalue =
        glade_utils_value_from_string (flags_type, displayable, NULL)) != NULL) ||
      (gvalue =
       glade_utils_value_from_string (flags_type, strval, NULL)) != NULL)
    {
      value = g_value_get_flags (gvalue);
      g_value_unset (gvalue);
      g_free (gvalue);
    }
  return value;
}

static gchar *
glade_utils_flags_string_from_value_real (GType flags_type,
                                          gint value,
                                          gboolean displayable)
{
  GValue gvalue = { 0, };
  gchar *string;

  g_value_init (&gvalue, flags_type);
  g_value_set_flags (&gvalue, value);

  string = glade_utils_string_from_value (&gvalue);
  g_value_unset (&gvalue);

  if (displayable && string)
    {
      const gchar *dstring = glade_get_displayable_value (flags_type, string);
      if (dstring)
        {
          g_free (string);
          return g_strdup (dstring);
        }
    }

  return string;
}

gchar *
glade_utils_flags_string_from_value (GType flags_type, gint value)
{
  return glade_utils_flags_string_from_value_real (flags_type, value, FALSE);

}


gchar *
glade_utils_flags_string_from_value_displayable (GType flags_type, gint value)
{
  return glade_utils_flags_string_from_value_real (flags_type, value, TRUE);
}


/* A hash table of generically created property classes for
 * fundamental types, so we can easily use glade's conversion
 * system without using properties (only GTypes)
 */
static GHashTable *generic_property_classes = NULL;


static gboolean
utils_gtype_equal (gconstpointer v1, gconstpointer v2)
{
  return *((const GType *) v1) == *((const GType *) v2);
}

static guint
utils_gtype_hash (gconstpointer v)
{
  return *(const GType *) v;
}


static GladePropertyClass *
pclass_from_gtype (GType type)
{
  GladePropertyClass *property_class = NULL;
  GParamSpec *pspec = NULL;

  if (!generic_property_classes)
    generic_property_classes =
        g_hash_table_new_full (utils_gtype_hash, utils_gtype_equal, g_free,
                               (GDestroyNotify) glade_property_class_free);

  property_class = g_hash_table_lookup (generic_property_classes, &type);

  if (!property_class)
    {
      /* Support enum and flag types, and a hardcoded list of fundamental types */
      if (type == G_TYPE_CHAR)
        pspec = g_param_spec_char ("dummy", "dummy", "dummy",
                                   G_MININT8, G_MAXINT8, 0,
                                   G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_UCHAR)
        pspec = g_param_spec_char ("dummy", "dummy", "dummy",
                                   0, G_MAXUINT8, 0,
                                   G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_BOOLEAN)
        pspec = g_param_spec_boolean ("dummy", "dummy", "dummy",
                                      FALSE,
                                      G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_INT)
        pspec = g_param_spec_int ("dummy", "dummy", "dummy",
                                  G_MININT, G_MAXINT, 0,
                                  G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_UINT)
        pspec = g_param_spec_uint ("dummy", "dummy", "dummy",
                                   0, G_MAXUINT, 0,
                                   G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_LONG)
        pspec = g_param_spec_long ("dummy", "dummy", "dummy",
                                   G_MINLONG, G_MAXLONG, 0,
                                   G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_ULONG)
        pspec = g_param_spec_ulong ("dummy", "dummy", "dummy",
                                    0, G_MAXULONG, 0,
                                    G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_INT64)
        pspec = g_param_spec_int64 ("dummy", "dummy", "dummy",
                                    G_MININT64, G_MAXINT64, 0,
                                    G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_UINT64)
        pspec = g_param_spec_uint64 ("dummy", "dummy", "dummy",
                                     0, G_MAXUINT64, 0,
                                     G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_FLOAT)
        pspec = g_param_spec_float ("dummy", "dummy", "dummy",
                                    G_MINFLOAT, G_MAXFLOAT, 1.0F,
                                    G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_DOUBLE)
        pspec = g_param_spec_double ("dummy", "dummy", "dummy",
                                     G_MINDOUBLE, G_MAXDOUBLE, 1.0F,
                                     G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_STRING)
        pspec = g_param_spec_string ("dummy", "dummy", "dummy",
                                     NULL, G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (type == G_TYPE_OBJECT || g_type_is_a (type, G_TYPE_OBJECT))
        pspec = g_param_spec_object ("dummy", "dummy", "dummy",
                                     type, G_PARAM_READABLE | G_PARAM_WRITABLE);
      else if (G_TYPE_IS_ENUM (type))
        {
          GEnumClass *eclass = g_type_class_ref (type);
          pspec = g_param_spec_enum ("dummy", "dummy", "dummy",
                                     type, eclass->minimum,
                                     G_PARAM_READABLE | G_PARAM_WRITABLE);
          g_type_class_unref (eclass);
        }
      else if (G_TYPE_IS_FLAGS (type))
        pspec = g_param_spec_flags ("dummy", "dummy", "dummy",
                                    type, 0,
                                    G_PARAM_READABLE | G_PARAM_WRITABLE);

      if (pspec)
        {
          if ((property_class =
               glade_property_class_new_from_spec_full (NULL, pspec,
                                                        FALSE)) != NULL)
            {
              /* XXX If we ever free the hash table, property classes wont touch
               * the allocated pspecs, so they would theoretically be leaked.
               */
              g_hash_table_insert (generic_property_classes,
                                   g_memdup (&type, sizeof (GType)),
                                   property_class);
            }
          else
            g_warning ("Unable to create property class for type %s",
                       g_type_name (type));
        }
      else
        g_warning ("No generic conversion support for type %s",
                   g_type_name (type));
    }
  return property_class;
}

/**
 * glade_utils_value_from_string:
 * @type: a #GType to convert with
 * @string: the string to convert
 * @project: the #GladeProject to look for formats of object names when needed
 * @widget: if the value is a gobject, this #GladeWidget will be used to look
 *          for an object in the same widget tree.
 *
 * Allocates and sets a #GValue of type @type
 * set to @string (using glade conversion routines) 
 *
 * Returns: A newly allocated and set #GValue
 */
GValue *
glade_utils_value_from_string (GType type,
                               const gchar *string,
                               GladeProject *project)
{
  GladePropertyClass *pclass;

  g_return_val_if_fail (type != G_TYPE_INVALID, NULL);
  g_return_val_if_fail (string != NULL, NULL);

  if ((pclass = pclass_from_gtype (type)) != NULL)
    return glade_property_class_make_gvalue_from_string (pclass, string, project);

  return NULL;
}

/**
 * glade_utils_boolean_from_string:
 * @string: the string to convert
 * @value: return location
 *
 * Parse a boolean value
 *
 * Returns: True if there was an error on the conversion.
 */
gboolean
glade_utils_boolean_from_string (const gchar *string, gboolean *value)
{
  if (string)
    {
      const gchar *c = string;

      /* Skip white spaces */
      while (g_ascii_isspace (*c))
        c++;

      /* We only need the first char */
      switch (*c)
        {
          case '1':
          case 't':
          case 'T':
          case 'y':
          case 'Y':
            if (value)
              *value = TRUE;
            return FALSE;
          break;

          case '0':
          case 'f':
          case 'F':
          case 'n':
          case 'N':
            if (value)
              *value = FALSE;
            return FALSE;
          break;
        }
    }

  return TRUE;
}

/**
 * glade_utils_string_from_value:
 * @value: a #GValue to convert
 *
 * Serializes #GValue into a string 
 * (using glade conversion routines) 
 *
 * Returns: A newly allocated string
 */
gchar *
glade_utils_string_from_value (const GValue *value)
{
  GladePropertyClass *pclass;

  g_return_val_if_fail (value != NULL, NULL);

  if ((pclass = pclass_from_gtype (G_VALUE_TYPE (value))) != NULL)
    return glade_property_class_make_string_from_gvalue (pclass, value);

  return NULL;
}


/**
 * glade_utils_liststore_from_enum_type:
 * @enum_type: A #GType
 * @include_empty: wheather to prepend an "Unset" slot
 *
 * Creates a liststore suitable for comboboxes and such to 
 * chose from a variety of types.
 *
 * Returns: A new #GtkListStore
 */
GtkListStore *
glade_utils_liststore_from_enum_type (GType enum_type, gboolean include_empty)
{
  GtkListStore *store;
  GtkTreeIter iter;
  GEnumClass *eclass;
  guint i;

  eclass = g_type_class_ref (enum_type);

  store = gtk_list_store_new (1, G_TYPE_STRING);

  if (include_empty)
    {
      gtk_list_store_append (store, &iter);
      gtk_list_store_set (store, &iter, 0, _("None"), -1);
    }

  for (i = 0; i < eclass->n_values; i++)
    {
      const gchar *displayable =
          glade_get_displayable_value (enum_type, eclass->values[i].value_nick);

      gtk_list_store_append (store, &iter);
      gtk_list_store_set (store, &iter,
                          0,
                          displayable ? displayable : eclass->values[i].
                          value_nick, -1);
    }

  g_type_class_unref (eclass);

  return store;
}



/**
 * glade_utils_hijack_key_press:
 * @win: a #GtkWindow
 * event: the GdkEventKey 
 * user_data: unused
 *
 * This function is meant to be attached to key-press-event of a toplevel,
 * it simply allows the window contents to treat key events /before/ 
 * accelerator keys come into play (this way widgets dont get deleted
 * when cutting text in an entry etc.).
 * Creates a liststore suitable for comboboxes and such to 
 * chose from a variety of types.
 *
 * Returns: whether the event was handled
 */
gint
glade_utils_hijack_key_press (GtkWindow *win,
                              GdkEventKey *event,
                              gpointer user_data)
{
  GtkWidget *focus_widget;

  focus_widget = gtk_window_get_focus (win);
  if (focus_widget && (event->keyval == GDK_KEY_Delete ||       /* Filter Delete from accelerator keys */
                       ((event->state & GDK_CONTROL_MASK) &&    /* CNTL keys... */
                        ((event->keyval == GDK_KEY_c || event->keyval == GDK_KEY_C) ||  /* CNTL-C (copy)  */
                         (event->keyval == GDK_KEY_x || event->keyval == GDK_KEY_X) ||  /* CNTL-X (cut)   */
                         (event->keyval == GDK_KEY_v || event->keyval == GDK_KEY_V) ||  /* CNTL-V (paste) */
                         (event->keyval == GDK_KEY_n || event->keyval == GDK_KEY_N))))) /* CNTL-N (new project) */
    {
      return gtk_widget_event (focus_widget, (GdkEvent *) event);
    }
  return FALSE;
}


void
glade_utils_cairo_draw_line (cairo_t *cr,
                             GdkColor *color,
                             gint x1, gint y1,
                             gint x2, gint y2)
{
  cairo_save (cr);

G_GNUC_BEGIN_IGNORE_DEPRECATIONS
  gdk_cairo_set_source_color (cr, color);
G_GNUC_END_IGNORE_DEPRECATIONS
  cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);

  cairo_move_to (cr, x1 + 0.5, y1 + 0.5);
  cairo_line_to (cr, x2 + 0.5, y2 + 0.5);
  cairo_stroke (cr);

  cairo_restore (cr);
}


void
glade_utils_cairo_draw_rectangle (cairo_t *cr,
                                  GdkColor *color,
                                  gboolean filled,
                                  gint x, gint y,
                                  gint width, gint height)
{
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
  gdk_cairo_set_source_color (cr, color);
G_GNUC_END_IGNORE_DEPRECATIONS

  if (filled)
    {
      cairo_rectangle (cr, x, y, width, height);
      cairo_fill (cr);
    }
  else
    {
      cairo_rectangle (cr, x + 0.5, y + 0.5, width, height);
      cairo_stroke (cr);
    }
}


/* copied from gedit */
gchar *
glade_utils_replace_home_dir_with_tilde (const gchar *path)
{
#ifdef G_OS_UNIX
  gchar *tmp;
  gchar *home;

  g_return_val_if_fail (path != NULL, NULL);

  /* Note that g_get_home_dir returns a const string */
  tmp = (gchar *) g_get_home_dir ();

  if (tmp == NULL)
    return g_strdup (path);

  home = g_filename_to_utf8 (tmp, -1, NULL, NULL, NULL);
  if (home == NULL)
    return g_strdup (path);

  if (strcmp (path, home) == 0)
    {
      g_free (home);

      return g_strdup ("~");
    }

  tmp = home;
  home = g_strdup_printf ("%s/", tmp);
  g_free (tmp);

  if (g_str_has_prefix (path, home))
    {
      gchar *res;

      res = g_strdup_printf ("~/%s", path + strlen (home));

      g_free (home);

      return res;
    }

  g_free (home);

  return g_strdup (path);
#else
  return g_strdup (path);
#endif
}

static void
draw_tip (cairo_t *cr)
{
  cairo_line_to (cr, 2, 8);
  cairo_line_to (cr, 2, 4);
  cairo_line_to (cr, 0, 4);
  cairo_line_to (cr, 0, 3);
  cairo_line_to (cr, 3, 0);
  cairo_line_to (cr, 6, 3);
  cairo_line_to (cr, 6, 4);
  cairo_line_to (cr, 4, 4);

  cairo_translate (cr, 12, 6);
  cairo_rotate (cr, G_PI_2);
}

static void
draw_tips (cairo_t *cr)
{
  cairo_move_to (cr, 2, 8);
  draw_tip (cr); draw_tip (cr); draw_tip (cr); draw_tip (cr);
  cairo_close_path (cr);
}

static void
draw_pointer (cairo_t *cr)
{
  cairo_line_to (cr, 8, 3);
  cairo_line_to (cr, 19, 14);
  cairo_line_to (cr, 13.75, 14);
  cairo_line_to (cr, 16.5, 19);
  cairo_line_to (cr, 14, 21);
  cairo_line_to (cr, 11, 16);
  cairo_line_to (cr, 7, 19);
  cairo_line_to (cr, 7, 3);
  cairo_line_to (cr, 8, 3);
}

/* Needed for private draw functions! */
#include "glade-design-private.h"

/**
 * glade_utils_pointer_mode_render_icon:
 * @mode: the #GladePointerMode to render as icon
 * @size: icon size
 *
 * Render an icon representing the pointer mode.
 * Best view with sizes bigger than GTK_ICON_SIZE_LARGE_TOOLBAR.
 */ 
GdkPixbuf *
glade_utils_pointer_mode_render_icon (GladePointerMode mode, GtkIconSize size)
{
  GdkRGBA c1, c2, fg, bg;
  cairo_surface_t *surface;
  gint width, height;
  GdkPixbuf *pix;
  cairo_t *cr;

  if (gtk_icon_size_lookup (size, &width, &height) == FALSE) return NULL;

  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
  cr = cairo_create (surface);
  cairo_scale (cr, width/24.0, height/24.0);

  /* Now get colors */
  _glade_design_layout_get_colors (&bg, &fg, &c1, &c2);

  /* Clear surface */
  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
  cairo_fill(cr);
  cairo_set_operator (cr, CAIRO_OPERATOR_OVER);

  switch (mode)
    {
      case GLADE_POINTER_SELECT:
      case GLADE_POINTER_ADD_WIDGET:
        cairo_set_line_width (cr, 1);
        cairo_translate (cr, 1.5, 1.5);
        draw_pointer (cr);
        fg.alpha = .16;
        gdk_cairo_set_source_rgba (cr, &fg);
        cairo_stroke (cr);

        cairo_translate (cr, -1, -1);
        draw_pointer (cr);
        gdk_cairo_set_source_rgba (cr, &c2);
        cairo_fill_preserve (cr);
      
        fg.alpha = .64;
        gdk_cairo_set_source_rgba (cr, &fg);
        cairo_stroke (cr);
      break;
      case GLADE_POINTER_DRAG_RESIZE:
        cairo_set_line_width (cr, 1);
        cairo_translate (cr, 10.5, 3.5);
        
        draw_tips (cr);

        fg.alpha = .16;
        gdk_cairo_set_source_rgba (cr, &fg);
        cairo_stroke (cr);

        cairo_translate (cr, -1, -1);
        draw_tips (cr);
        
        gdk_cairo_set_source_rgba (cr, &c2);
        cairo_fill_preserve (cr);
        
        c1.red = MAX (0, c1.red - .1);
        c1.green = MAX (0, c1.green - .1);
        c1.blue = MAX (0, c1.blue - .1);
        gdk_cairo_set_source_rgba (cr, &c1);
        cairo_stroke (cr);
      break;
      case GLADE_POINTER_MARGIN_EDIT:
        {
          gdk_cairo_set_source_rgba (cr, &bg);
          cairo_rectangle (cr, 4, 4, 18, 18);
          cairo_fill (cr);

          c1.alpha = .1;
          gdk_cairo_set_source_rgba (cr, &c1);
          cairo_rectangle (cr, 6, 6, 16, 16);
          cairo_fill (cr);

          cairo_set_line_width (cr, 1);
          fg.alpha = .32;
          gdk_cairo_set_source_rgba (cr, &fg);
          cairo_move_to (cr, 16.5, 22);
          cairo_line_to (cr, 16.5, 16.5);
          cairo_line_to (cr, 22, 16.5);
          cairo_stroke (cr);

          c1.alpha = .16;
          gdk_cairo_set_source_rgba (cr, &c1);
          cairo_rectangle (cr, 16, 16, 6, 6);
          cairo_fill (cr);

          cairo_set_line_width (cr, 2);
          c1.alpha = .75;
          gdk_cairo_set_source_rgba (cr, &c1);
          cairo_move_to (cr, 6, 22);
          cairo_line_to (cr, 6, 6);
          cairo_line_to (cr, 22, 6);
          cairo_stroke (cr);

          c1.alpha = 1;
          cairo_scale (cr, .75, .75);
          cairo_set_line_width (cr, 4);
          _glade_design_layout_draw_node (cr, 16*1.25, 6*1.25, &c1, &c2);
          _glade_design_layout_draw_node (cr, 6*1.25, 16*1.25, &c1, &c2);
        }
      break;
      case GLADE_POINTER_ALIGN_EDIT:
        cairo_scale (cr, 1.5, 1.5);
        cairo_rotate (cr, 45*(G_PI/180));
        cairo_translate (cr, 11, 2);
        _glade_design_layout_draw_pushpin (cr, 2.5, &c1, &c2, &c2, &fg);
      break;
      default:
      break;
    }

  pix = gdk_pixbuf_get_from_surface (surface, 0, 0,
                                     cairo_image_surface_get_width (surface),
                                     cairo_image_surface_get_height (surface));

  cairo_surface_destroy (surface);
  cairo_destroy (cr);

  return pix;
}

/**
 * glade_utils_get_pointer:
 * @widget: The widget to get the mouse position relative for
 * @window: The window of the current event, or %NULL
 * @device: The device, if not specified, the current event will be expected to have a @device.
 * @x: The location to store the mouse pointer X position
 * @y: The location to store the mouse pointer Y position
 *
 * Get's the pointer position relative to @widget, while @window and @device
 * are not absolutely needed, they should be passed wherever possible.
 *
 */
void
glade_utils_get_pointer (GtkWidget *widget,
			 GdkWindow *window,
			 GdkDevice *device,
			 gint      *x,
			 gint      *y)
{
  gint device_x = 0, device_y = 0;
  gint final_x = 0, final_y = 0;
  GtkWidget *event_widget = NULL;

  g_return_if_fail (GTK_IS_WIDGET (widget));

  if (!device)
    {
      GdkEvent *event = gtk_get_current_event ();

      device = gdk_event_get_device (event);
      gdk_event_free (event);
    }

  g_return_if_fail (GDK_IS_DEVICE (device));

  if (!window)
    window = gtk_widget_get_window (widget);

  g_return_if_fail (GDK_IS_WINDOW (window));

  gdk_window_get_device_position (window, device, &device_x, &device_y, NULL);
  gdk_window_get_user_data (window, (gpointer)&event_widget);

  if (event_widget != widget)
    {
      gtk_widget_translate_coordinates (event_widget,
                                        widget,
                                        device_x, device_y,
					&final_x, &final_y);
    }
  else
    {
      final_x = device_x;
      final_y = device_y;
    }

  if (x)
    *x = final_x;
  if (y)
    *y = final_y;
}

/* Use this to disable scroll events on property editors,
 * we dont want them handling scroll because they are inside
 * a scrolled window and interrupt workflow causing unexpected
 * results when scrolled.
 */
static gint
abort_scroll_events (GtkWidget *widget,
		     GdkEvent  *event,
		     gpointer   user_data)
{
  GtkWidget *parent = gtk_widget_get_parent (widget);

  /* Removing the events from the mask doesnt work for
   * stubborn combo boxes which call gtk_widget_add_events()
   * in it's gtk_combo_box_init() - so handle the event and propagate
   * it up the tree so the scrollwindow still handles the scroll event.
   */
  gtk_propagate_event (parent, event);

  return TRUE;
}

void
glade_util_remove_scroll_events (GtkWidget *widget)
{
  gint events = gtk_widget_get_events (widget);

  events &= ~(GDK_SCROLL_MASK | GDK_SMOOTH_SCROLL_MASK);
  gtk_widget_set_events (widget, events);

  g_signal_connect (G_OBJECT (widget), "scroll-event",
		    G_CALLBACK (abort_scroll_events), NULL);
}

/**
 * _glade_util_file_get_relative_path:
 * @target: input GFile
 * @source: input GFile
 *
 * Gets the path for @source relative to @target even if @source is not a
 * descendant of @target.
 *
 */
gchar *
_glade_util_file_get_relative_path (GFile *target, GFile *source)
{
  gchar *relative_path;

  if ((relative_path = g_file_get_relative_path (target, source)) == NULL)
    {
      GString *relpath = g_string_new ("");

      g_object_ref (target);

      while (relative_path == NULL)
        {
          GFile *old_target = target;
          target = g_file_get_parent (target);

          relative_path = g_file_get_relative_path (target, source);

          g_string_append (relpath, "..");
          g_string_append_c (relpath, G_DIR_SEPARATOR);

          g_object_unref (old_target);
        }

      g_string_append (relpath, relative_path);
      g_free (relative_path);
      relative_path = g_string_free (relpath, FALSE);
    }

  return relative_path;
}
