/*

 * Copyright (C) 2001 Ximian, Inc.

 * Copyright (C) 2007 Vincent Geddes.

 * Copyright (C) 2012-2018 Juan Pablo Ugarte.

 *

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

 *   Paolo Borelli <pborelli@katamail.com>

 *   Vincent Geddes <vgeddes@gnome.org>

 *   Juan Pablo Ugarte <juanpablougarte@gmail.com>

 */

#include <config.h>

#include "glade-window.h"

#include "glade-resources.h"

#include "glade-preferences.h"

#include "glade-registration.h"

#include "glade-intro.h"

#include <gladeui/glade.h>

#include <gladeui/glade-popup.h>

#include <gladeui/glade-inspector.h>

#include <gladeui/glade-adaptor-chooser.h>

#include <gladeui/glade-project.h>

#include <string.h>

#include <glib/gstdio.h>

#include <glib/gi18n.h>

#include <gdk/gdkkeysyms.h>

#include <gtk/gtk.h>

#ifdef MAC_INTEGRATION

#  include <gtkosxapplication.h>

#endif

#define ACTION_GROUP_STATIC             "GladeStatic"

#define ACTION_GROUP_PROJECT            "GladeProject"

#define ACTION_GROUP_PROJECTS_LIST_MENU "GladeProjectsList"

#define READONLY_INDICATOR (_("[Read Only]"))

#define URL_DEVELOPER_MANUAL "http://library.gnome.org/devel/gladeui/"

#define CONFIG_GROUP_WINDOWS        "Glade Windows"

#define GLADE_WINDOW_DEFAULT_WIDTH  720

#define GLADE_WINDOW_DEFAULT_HEIGHT 540

#define CONFIG_KEY_X                "x"

#define CONFIG_KEY_Y                "y"

#define CONFIG_KEY_WIDTH            "width"

#define CONFIG_KEY_HEIGHT           "height"

#define CONFIG_KEY_MAXIMIZED        "maximized"

#define CONFIG_GROUP_LOAD_SAVE      "Load and Save"

#define CONFIG_KEY_BACKUP           "backup"

#define CONFIG_KEY_AUTOSAVE         "autosave"

#define CONFIG_KEY_AUTOSAVE_SECONDS "autosave-seconds"

#define CONFIG_INTRO_GROUP          "Intro"

#define CONFIG_INTRO_DONE           "intro-done"

#define GLADE_WINDOW_ACTIVE_VIEW(w) ((GladeDesignView *) gtk_stack_get_visible_child (w->priv->view_stack))

struct _GladeWindowPrivate

{

  GladeApp *app;

  GtkStack *stack;

  GtkStack *view_stack;

  GtkHeaderBar *headerbar;

  GtkWidget *project_switcher ;

  GtkWindow *about_dialog;

  GladePreferences *preferences;

  GtkWidget *start_page;

  GtkLabel  *version_label;

  GtkWidget *intro_button;

  GladeAdaptorChooser *adaptor_chooser;

  GtkStack *inspectors_stack;           /* Cached per project inspectors */

  GladeEditor  *editor;                 /* The editor */

  GtkWidget *statusbar;                 /* A pointer to the status bar. */

  guint statusbar_context_id;           /* The context id of general messages */

  guint statusbar_menu_context_id;      /* The context id of the menu bar */

  guint statusbar_actions_context_id;   /* The context id of actions messages */

  GActionGroup *actions;

  GtkRecentManager *recent_manager;

  GtkWidget *recent_menu;

  gchar *default_path;          /* the default path for open/save operations */

  GtkWidget *undo_button;       /* undo/redo button, right click for history */

  GtkWidget *redo_button;

  GtkWidget *toolbar;           /* Actions are added to the toolbar */

  gint actions_start;           /* start of action items */

  GtkWidget *center_paned;

  GtkWidget *left_paned;

  GtkWidget *open_button_box;   /* gtk_button_box_set_layout() set homogeneous to TRUE, and we do not want that in this case  */

  GtkWidget *save_button_box;

  GtkWidget *registration;      /* Registration and user survey dialog */

  GladeIntro *intro;

  GType new_type;

  GdkRectangle position;

};

static void check_reload_project (GladeWindow *window, GladeProject *project);

G_DEFINE_TYPE_WITH_PRIVATE (GladeWindow, glade_window, GTK_TYPE_WINDOW)

static void

refresh_title (GladeWindow *window)

{

  if (GLADE_WINDOW_ACTIVE_VIEW (window))

    {

      GladeProject *project = glade_design_view_get_project (GLADE_WINDOW_ACTIVE_VIEW (window));

      gchar *title, *name = NULL;

      GList *p;

      gtk_header_bar_set_custom_title (window->priv->headerbar, NULL);

      name = glade_project_get_name (project);

      if (glade_project_get_modified (project))

        name = g_strdup_printf ("*%s", name);

      else

        name = g_strdup (name);

      if (glade_project_get_readonly (project) != FALSE)

        title = g_strdup_printf ("%s %s", name, READONLY_INDICATOR);

      else

        title = g_strdup_printf ("%s", name);

      gtk_header_bar_set_title (window->priv->headerbar, title);

      g_free (title);

      g_free (name);

      if ((p = glade_app_get_projects ()) && g_list_next (p))

        gtk_header_bar_set_custom_title (window->priv->headerbar, window->priv->project_switcher);

      else

        {

          const gchar *path;

          /* Show path */

          if (project && (path = glade_project_get_path (project)))

            {

              gchar *dirname = g_path_get_dirname (path);

              const gchar *home = g_get_home_dir ();

              if (g_str_has_prefix (dirname, home))

                {

                  char *subtitle = &dirname[g_utf8_strlen (home, -1) - 1];

                  subtitle[0] = '~';

                  gtk_header_bar_set_subtitle (window->priv->headerbar, subtitle);

                }

              else

                gtk_header_bar_set_subtitle (window->priv->headerbar, dirname);

              g_free (dirname);

            }

          else

            gtk_header_bar_set_subtitle (window->priv->headerbar, NULL);

        }

    }

  else

    {

      gtk_header_bar_set_custom_title (window->priv->headerbar, NULL);

      gtk_header_bar_set_title (window->priv->headerbar, _("User Interface Designer"));

      gtk_header_bar_set_subtitle (window->priv->headerbar, NULL);

    }

}

static const gchar *

get_default_path (GladeWindow *window)

{

  return window->priv->default_path;

}

static void

update_default_path (GladeWindow *window, const gchar *filename)

{

  gchar *path;

  g_return_if_fail (filename != NULL);

  path = g_path_get_dirname (filename);

  g_free (window->priv->default_path);

  window->priv->default_path = g_strdup (path);

  g_free (path);

}

static void

activate_action (GtkToolButton *toolbutton, GladeWidgetAction *action)

{

  GladeWidget   *widget;

  GWActionClass *aclass = glade_widget_action_get_class (action);

  if ((widget = g_object_get_data (G_OBJECT (toolbutton), "glade-widget")))

    glade_widget_adaptor_action_activate (glade_widget_get_adaptor (widget),

                                          glade_widget_get_object (widget), 

                                          aclass->path);

}

static void

action_notify_sensitive (GObject *gobject, GParamSpec *arg1, GtkWidget *item)

{

  GladeWidgetAction *action = GLADE_WIDGET_ACTION (gobject);

  gtk_widget_set_sensitive (item, glade_widget_action_get_sensitive (action));

}

static void

action_disconnect (gpointer data, GClosure *closure)

{

  g_signal_handlers_disconnect_matched (data, G_SIGNAL_MATCH_FUNC,

                                        0, 0, NULL,

                                        action_notify_sensitive, NULL);

}

static void

clean_actions (GladeWindow *window)

{

  GtkContainer *container = GTK_CONTAINER (window->priv->toolbar);

  GtkToolbar *bar = GTK_TOOLBAR (window->priv->toolbar);

  GtkToolItem *item;

  if (window->priv->actions_start)

    {

      while ((item =

              gtk_toolbar_get_nth_item (bar, window->priv->actions_start)))

        gtk_container_remove (container, GTK_WIDGET (item));

    }

}

static void

add_actions (GladeWindow *window, GladeWidget *widget, GList *actions)

{

  GtkToolbar *bar = GTK_TOOLBAR (window->priv->toolbar);

  GtkToolItem *item = gtk_separator_tool_item_new ();

  gint n = 0;

  GList *l;

  gtk_toolbar_insert (bar, item, -1);

  gtk_widget_show (GTK_WIDGET (item));

  if (window->priv->actions_start == 0)

    window->priv->actions_start = gtk_toolbar_get_item_index (bar, item);

  for (l = actions; l; l = g_list_next (l))

    {

      GladeWidgetAction *action = l->data;

      GWActionClass     *aclass = glade_widget_action_get_class (action);

      if (!aclass->important || !glade_widget_action_get_visible (action))

        continue;

      if (glade_widget_action_get_children (action))

        {

          g_warning ("Trying to add a group action to the toolbar is unsupported");

          continue;

        }

      item = gtk_tool_button_new (NULL, aclass->label);

      gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item),

                                     (aclass->stock) ? aclass->stock : "system-run");

      if (aclass->label)

        gtk_widget_set_tooltip_text (GTK_WIDGET (item), aclass->label);

      g_object_set_data (G_OBJECT (item), "glade-widget", widget);

      /* We use destroy_data to keep track of notify::sensitive callbacks

       * on the action object and disconnect them when the toolbar item

       * gets destroyed.

       */

      g_signal_connect_data (item, "clicked",

                             G_CALLBACK (activate_action),

                             action, action_disconnect, 0);

      gtk_widget_set_sensitive (GTK_WIDGET (item), 

                                glade_widget_action_get_sensitive (action));

      g_signal_connect (action, "notify::sensitive",

                        G_CALLBACK (activate_action), GTK_WIDGET (item));

      gtk_toolbar_insert (bar, item, -1);

      gtk_tool_item_set_homogeneous (item, FALSE);

      gtk_widget_show_all (GTK_WIDGET (item));

      n++;

    }

  if (n == 0)

    clean_actions (window);

}

static GladeProject *

get_active_project (GladeWindow *window)

{

  if (GLADE_WINDOW_ACTIVE_VIEW (window))

    return glade_design_view_get_project (GLADE_WINDOW_ACTIVE_VIEW (window));

  return NULL;

}

static void

project_selection_changed_cb (GladeProject *project, GladeWindow *window)

{

  GladeProject *active_project;

  GladeWidget  *glade_widget = NULL;

  GList        *list;

  gint          num;

  active_project = get_active_project (window);

  /* This is sometimes called with a NULL project (to make the label

   * insensitive with no projects loaded)

   */

  g_return_if_fail (GLADE_IS_WINDOW (window));

  /* Only update the toolbar & workspace if the selection has changed on

   * the currently active project.

   */

  if (project == active_project)

    {

      list = glade_project_selection_get (project);

      num = g_list_length (list);

      if (num == 1 && !GLADE_IS_PLACEHOLDER (list->data))

        {

          glade_widget = glade_widget_get_from_gobject (G_OBJECT (list->data));

          clean_actions (window);

          if (glade_widget_get_actions (glade_widget))

            add_actions (window, glade_widget, glade_widget_get_actions (glade_widget));

        }

    }

  glade_editor_load_widget (window->priv->editor, glade_widget);

}

static void

refresh_stack_title_for_project (GladeWindow *window, GladeProject *project)

{

  GList *children, *l;

  children = gtk_container_get_children (GTK_CONTAINER (window->priv->view_stack));

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

    {

      GtkWidget *view = l->data;

      if (project == glade_design_view_get_project (GLADE_DESIGN_VIEW (view)))

        {

          gchar *name = glade_project_get_name (project);

          gchar *str;

          /* remove extension */

          if ((str = g_utf8_strrchr (name, -1, '.')))

            *str = '\0';

          if (glade_project_get_modified (project))

            str = g_strdup_printf ("*%s", name);

          else

            str = g_strdup (name);

          gtk_container_child_set (GTK_CONTAINER (window->priv->view_stack), view,

                                   "title", str, NULL);

          g_free (name);

          g_free (str);

          break;

        }

    }

  g_list_free (children);

}

static void

project_targets_changed_cb (GladeProject *project, GladeWindow *window)

{

  refresh_stack_title_for_project (window, project);

}

static void

actions_set_enabled (GladeWindow *window, const gchar *name, gboolean enabled)

{

  GAction *action = g_action_map_lookup_action (G_ACTION_MAP (window->priv->actions), name);

  g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled);

}

static void

project_actions_set_enabled (GladeWindow *window, gboolean enabled)

{

  actions_set_enabled (window, "close", enabled);

  actions_set_enabled (window, "save", enabled);

  actions_set_enabled (window, "save_as", enabled);

  actions_set_enabled (window, "properties", enabled);

  actions_set_enabled (window, "undo", enabled);

  actions_set_enabled (window, "redo", enabled);

  actions_set_enabled (window, "cut", enabled);

  actions_set_enabled (window, "copy", enabled);

  actions_set_enabled (window, "delete", enabled);

  actions_set_enabled (window, "previous", enabled);

  actions_set_enabled (window, "next", enabled);

}

static void

pointer_mode_actions_set_enabled (GladeWindow *window, gboolean enabled)

{

  actions_set_enabled (window, "select", enabled);

  actions_set_enabled (window, "drag_resize", enabled);

  actions_set_enabled (window, "margin_edit", enabled);

  actions_set_enabled (window, "align_edit", enabled);

}

static void

refresh_undo_redo (GladeWindow *window, GladeProject *project)

{

  GladeCommand *undo = NULL, *redo = NULL;

  GladeWindowPrivate *priv = window->priv;

  const gchar *desc;

  gchar *tooltip;

  if (project != NULL)

    {

      undo = glade_project_next_undo_item (project);

      redo = glade_project_next_redo_item (project);

    }

  /* Refresh Undo */

  actions_set_enabled (window, "undo", undo != NULL);

  desc = undo ? glade_command_description (undo) : _("the last action");

  tooltip = g_strdup_printf (_("Undo: %s"), desc);

  gtk_widget_set_tooltip_text (priv->undo_button, tooltip);

  g_free (tooltip);

  /* Refresh Redo */

  actions_set_enabled (window, "redo", redo != NULL);

  desc = redo ? glade_command_description (redo) : _("the last action");

  tooltip = g_strdup_printf (_("Redo: %s"), desc);

  gtk_widget_set_tooltip_text (priv->redo_button, tooltip);

  g_free (tooltip);

}

static void

cancel_autosave (gpointer data)

{

  guint autosave_id = GPOINTER_TO_UINT (data);

  g_source_remove (autosave_id);

}

static gboolean

autosave_project (gpointer data)

{

  GladeProject *project = (GladeProject *)data;

  GladeWindow *window = GLADE_WINDOW (glade_app_get_window ());

  gchar *display_name;

  display_name = glade_project_get_name (project);

  if (glade_project_autosave (project, NULL))

    glade_util_flash_message (window->priv->statusbar,

                              window->priv->statusbar_actions_context_id,

                              _("Autosaving '%s'"), display_name);

  else

    /* This is problematic, should we be more intrusive and popup a dialog ? */

    glade_util_flash_message (window->priv->statusbar,

                              window->priv->statusbar_actions_context_id,

                              _("Error autosaving '%s'"), display_name);

  g_free (display_name);

  /* This will remove the source id */

  g_object_set_data (G_OBJECT (project), "glade-autosave-id", NULL);

  return FALSE;

}

static void

project_queue_autosave (GladeWindow *window, GladeProject *project)

{

  if (glade_project_get_path (project) != NULL &&

      glade_project_get_modified (project) &&

      glade_preferences_autosave (window->priv->preferences))

    {

      guint autosave_id =

        g_timeout_add_seconds (glade_preferences_autosave_seconds (window->priv->preferences),

                               autosave_project, project);

      g_object_set_data_full (G_OBJECT (project), "glade-autosave-id",

                              GUINT_TO_POINTER (autosave_id), cancel_autosave);

    }

  else

      g_object_set_data (G_OBJECT (project), "glade-autosave-id", NULL);

}

static void

project_cancel_autosave (GladeProject *project)

{

  g_object_set_data (G_OBJECT (project), "glade-autosave-id", NULL);

}

static void

project_changed_cb (GladeProject *project,

                    GladeCommand *command,

                    gboolean      execute,

                    GladeWindow  *window)

{

  GladeProject *active_project = get_active_project (window);

  if (project == active_project)

    refresh_undo_redo (window, project);

  project_queue_autosave (window, project);

}

static void

project_notify_handler_cb (GladeProject *project,

                           GParamSpec *spec,

                           GladeWindow *window)

{

  GladeProject *active_project = get_active_project (window);

  if (strcmp (spec->name, "path") == 0)

    {

      refresh_title (window);

      refresh_stack_title_for_project (window, project);

    }

  else if (strcmp (spec->name, "format") == 0)

    {

      refresh_stack_title_for_project (window, project);

    }

  else if (strcmp (spec->name, "modified") == 0)

    {

      refresh_title (window);

      refresh_stack_title_for_project (window, project);

    }

  else if (strcmp (spec->name, "read-only") == 0)

    {

      refresh_stack_title_for_project (window, project);

      actions_set_enabled (window, "save", !glade_project_get_readonly (project));

    }

  else if (strcmp (spec->name, "has-selection") == 0 && (project == active_project))

    {

      gboolean has_selection = glade_project_get_has_selection (project);

      actions_set_enabled (window, "cut", has_selection);

      actions_set_enabled (window, "copy", has_selection);

      actions_set_enabled (window, "delete", has_selection);

    }

}

static void

clipboard_notify_handler_cb (GladeClipboard *clipboard,

                             GParamSpec     *spec,

                             GladeWindow    *window)

{

  if (strcmp (spec->name, "has-selection") == 0)

    {

      actions_set_enabled (window, "paste",

                           glade_clipboard_get_has_selection (clipboard));

    }

}

static void

on_pointer_mode_changed (GladeProject *project,

                         GParamSpec   *pspec,

                         GladeWindow  *window)

{

  GladeProject *active_project = get_active_project (window);

  if (!active_project)

    {

      pointer_mode_actions_set_enabled (window, FALSE);

      return;

    }

  else if (active_project != project)

    return;

  if (glade_project_get_pointer_mode (project) == GLADE_POINTER_ADD_WIDGET)

    return;

  pointer_mode_actions_set_enabled (window, TRUE);

}

static void

set_sensitivity_according_to_project (GladeWindow  *window,

                                      GladeProject *project)

{

  gboolean has_selection = glade_project_get_has_selection (project);

  actions_set_enabled (window, "cut", has_selection);

  actions_set_enabled (window, "copy", has_selection);

  actions_set_enabled (window, "delete", has_selection);

  actions_set_enabled (window, "save",

                       !glade_project_get_readonly (project));

  actions_set_enabled (window, "paste",

                       glade_clipboard_get_has_selection (glade_app_get_clipboard ()));

}

static gchar *

get_uri_from_project_path (const gchar *path)

{

  GError *error = NULL;

  gchar *uri = NULL;

  if (g_path_is_absolute (path))

    uri = g_filename_to_uri (path, NULL, &error);

  else

    {

      gchar *cwd = g_get_current_dir ();

      gchar *fullpath = g_build_filename (cwd, path, NULL);

      uri = g_filename_to_uri (fullpath, NULL, &error);

      g_free (cwd);

      g_free (fullpath);

    }

  if (error)

    {

      g_warning ("Could not convert local path \"%s\" to a uri: %s", path, error->message);

      g_error_free (error);

    }

  return uri;

}

static void

recent_add (GladeWindow *window, const gchar *path)

{

  gchar *uri = get_uri_from_project_path (path);

  GtkRecentData *recent_data;

  if (!uri)

    return;

  recent_data = g_slice_new (GtkRecentData);

  recent_data->display_name = NULL;

  recent_data->description = NULL;

  recent_data->mime_type = "application/x-glade";

  recent_data->app_name = (gchar *) g_get_application_name ();

  recent_data->app_exec = g_strjoin (" ", g_get_prgname (), "%u", NULL);

  recent_data->groups = NULL;

  recent_data->is_private = FALSE;

  gtk_recent_manager_add_full (window->priv->recent_manager, uri, recent_data);

  g_free (uri);

  g_free (recent_data->app_exec);

  g_slice_free (GtkRecentData, recent_data);

}

static void

recent_remove (GladeWindow * window, const gchar * path)

{

  gchar *uri = get_uri_from_project_path (path);

  if (!uri)

    return;

  gtk_recent_manager_remove_item (window->priv->recent_manager, uri, NULL);

  g_free (uri);

}

/* switch to a project and check if we need to reload it.

 *

 */

static void

switch_to_project (GladeWindow *window, GladeProject *project)

{

  GladeWindowPrivate *priv = window->priv;

  GtkWidget *view;

  view = GTK_WIDGET (glade_design_view_get_from_project (project));

  gtk_stack_set_visible_child (priv->view_stack, view);

  check_reload_project (window, project);

}

static void

on_open_action_activate (GSimpleAction *action,

                         GVariant      *parameter,

                         gpointer       data)

{

  GladeWindow *window = data;

  GtkWidget *filechooser;

  gchar *path = NULL, *default_path;

  filechooser = glade_util_file_dialog_new (_("Open\342\200\246"), NULL,

                                            GTK_WINDOW (window),

                                            GLADE_FILE_DIALOG_ACTION_OPEN);

  default_path = g_strdup (get_default_path (window));

  if (default_path != NULL)

    {

      gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filechooser),

                                           default_path);

      g_free (default_path);

    }

  if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_OK)

    path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filechooser));

  gtk_widget_destroy (filechooser);

  if (!path)

    return;

  glade_window_open_project (window, path);

  g_free (path);

}

static gboolean

check_loading_project_for_save (GladeProject *project)

{

  if (glade_project_is_loading (project))

    {

      gchar *name = glade_project_get_name (project);

      glade_util_ui_message (glade_app_get_window (),

                             GLADE_UI_INFO, NULL,

                             _("Project %s is still loading."), name);

      g_free (name);

      return TRUE;

    }

  return FALSE;

}

static gboolean

do_save (GladeWindow *window, GladeProject *project, const gchar *path)

{

  GError *error = NULL;

  GladeVerifyFlags verify_flags = 0;

  gchar *display_path = g_strdup (path);

  if (glade_preferences_backup (window->priv->preferences) &&

      !glade_project_backup (project, path, NULL))

    {

      if (!glade_util_ui_message (GTK_WIDGET (window),

                                  GLADE_UI_ARE_YOU_SURE, NULL,

                                  _("Failed to backup existing file, continue saving?")))

        {

          g_free (display_path);

          return FALSE;

        }

    }

  if (glade_preferences_warn_versioning (window->priv->preferences))

    verify_flags |= GLADE_VERIFY_VERSIONS;

  if (glade_preferences_warn_deprecations (window->priv->preferences))

    verify_flags |= GLADE_VERIFY_DEPRECATIONS;

  if (glade_preferences_warn_unrecognized (window->priv->preferences))

    verify_flags |= GLADE_VERIFY_UNRECOGNIZED;

  if (!glade_project_save_verify (project, path, verify_flags, &error))

    {

      if (error)

        {

          /* Reset path so future saves will prompt the file chooser */

          glade_project_reset_path (project);

          glade_util_ui_message (GTK_WIDGET (window), GLADE_UI_ERROR, NULL,

                                 _("Failed to save %s: %s"),

                                 display_path, error->message);

          g_error_free (error);

        }

      g_free (display_path);

      return FALSE;

    }

  /* Cancel any queued autosave when explicitly saving */

  project_cancel_autosave (project);

  g_free (display_path);

  return TRUE;

}

static void

save (GladeWindow *window, GladeProject *project, const gchar *path)

{

  gchar *display_name;

  time_t mtime;

  GtkWidget *dialog;

  GtkWidget *button;

  gint response;

  if (check_loading_project_for_save (project))

    return;

  /* check for external modification to the project file */

  if (glade_project_get_path (project))

    {

      mtime = glade_util_get_file_mtime (glade_project_get_path (project), NULL);

      if (mtime > glade_project_get_file_mtime (project))

        {

          dialog = gtk_message_dialog_new (GTK_WINDOW (window),

                                           GTK_DIALOG_MODAL,

                                           GTK_MESSAGE_WARNING,

                                           GTK_BUTTONS_NONE,

                                           _("The file %s has been modified since reading it"),

                                           glade_project_get_path (project));

          gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),

                                                    _("If you save it, all the external changes could be lost. "

                                                    "Save it anyway?"));

          gtk_window_set_title (GTK_WINDOW (dialog), "");

          button = gtk_button_new_with_mnemonic (_("_Save Anyway"));

          gtk_button_set_image (GTK_BUTTON (button),

                                gtk_image_new_from_icon_name ("document-save",

                                                                      GTK_ICON_SIZE_BUTTON));

          gtk_widget_show (button);

          gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,

                                        GTK_RESPONSE_ACCEPT);

          gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Don't Save"),

                                 GTK_RESPONSE_REJECT);

          gtk_dialog_set_default_response (GTK_DIALOG (dialog),

                                           GTK_RESPONSE_REJECT);

          response = gtk_dialog_run (GTK_DIALOG (dialog));

          gtk_widget_destroy (dialog);

          if (response == GTK_RESPONSE_REJECT)

            return;

      }

    }

  /* Interestingly; we cannot use `path' after glade_project_reset_path

   * because we are getting called with glade_project_get_path (project) as an argument.

   */

  if (!do_save (window, project, path))

    return;

  /* Get display_name here, it could have changed with "Save As..." */

  display_name = glade_project_get_name (project);

  recent_add (window, glade_project_get_path (project));

  update_default_path (window, glade_project_get_path (project));

  /* refresh names */

  refresh_title (window);

  refresh_stack_title_for_project (window, project);

  glade_util_flash_message (window->priv->statusbar,

                            window->priv->statusbar_actions_context_id,

                            _("Project '%s' saved"), display_name);