Adding upstream version 2.10.36.upstream/2.10.36

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2193 insertions, 0 deletions

diff --git a/plug-ins/gfig/gfig-dialog.c b/plug-ins/gfig/gfig-dialog.c
new file mode 100644
index 0000000..9f72b97
--- /dev/null
+++ b/plug-ins/gfig/gfig-dialog.c
@@ -0,0 +1,2193 @@
+/*
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This is a plug-in for GIMP.
+ *
+ * Generates images containing vector type drawings.
+ *
+ * Copyright (C) 1997 Andy Thomas  alt@picnic.demon.co.uk
+ *
+ * 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 3 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, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib.h>
+
+#ifdef G_OS_WIN32
+#include <libgimpbase/gimpwin32-io.h>
+#endif
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+#include "gfig.h"
+#include "gfig-style.h"
+#include "gfig-dialog.h"
+#include "gfig-arc.h"
+#include "gfig-bezier.h"
+#include "gfig-circle.h"
+#include "gfig-dobject.h"
+#include "gfig-ellipse.h"
+#include "gfig-grid.h"
+#include "gfig-line.h"
+#include "gfig-poly.h"
+#include "gfig-preview.h"
+#include "gfig-rectangle.h"
+#include "gfig-spiral.h"
+#include "gfig-star.h"
+#include "gfig-stock.h"
+
+#define SEL_BUTTON_WIDTH  100
+#define SEL_BUTTON_HEIGHT  20
+
+#define GRID_TYPE_MENU      1
+#define GRID_RENDER_MENU    2
+
+#define PAINT_BGS_MENU      2
+#define PAINT_TYPE_MENU     3
+
+#define OBJ_SELECT_GT       1
+#define OBJ_SELECT_LT       2
+#define OBJ_SELECT_EQ       4
+
+#define UPDATE_DELAY 300 /* From GtkRange in GTK+ 2.22 */
+
+/* Globals */
+gint   undo_level;  /* Last slot filled in -1 = no undo */
+GList *undo_table[MAX_UNDO];
+
+/* Values when first invoked */
+SelectItVals selvals =
+{
+  {
+    MIN_GRID + (MAX_GRID - MIN_GRID)/2, /* Gridspacing     */
+    RECT_GRID,            /* Default to rectangle type     */
+    FALSE,                /* drawgrid                      */
+    FALSE,                /* snap2grid                     */
+    FALSE,                /* lockongrid                    */
+    TRUE,                 /* show control points           */
+    0.0,                  /* grid_radius_min               */
+    10.0,                 /* grid_radius_interval          */
+    0.0,                  /* grid_rotation                 */
+    5.0,                  /* grid_granularity              */
+    120                   /* grid_sectors_desired          */
+  },
+  FALSE,                  /* show image                    */
+  MIN_UNDO + (MAX_UNDO - MIN_UNDO)/2,  /* Max level of undos */
+  TRUE,                   /* Show pos updates              */
+  0.0,                    /* Brush fade                    */
+  0.0,                    /* Brush gradient                */
+  20.0,                   /* Air brush pressure            */
+  ORIGINAL_LAYER,         /* Draw all objects on one layer */
+  LAYER_TRANS_BG,         /* New layers background         */
+  PAINT_BRUSH_TYPE,       /* Default to use brushes        */
+  FALSE,                  /* reverse lines                 */
+  TRUE,                   /* Scale to image when painting  */
+  1.0,                    /* Scale to image fp             */
+  BRUSH_BRUSH_TYPE,       /* Default to use a brush        */
+  LINE                    /* Initial object type           */
+};
+
+selection_option selopt =
+{
+  ADD,          /* type */
+  FALSE,        /* Antia */
+  FALSE,        /* Feather */
+  10.0,         /* feather radius */
+  ARC_SEGMENT,  /* Arc as a segment */
+  FILL_PATTERN, /* Fill as pattern */
+  100.0,        /* Max opacity */
+};
+
+/* Should be kept in sync with GfigOpts */
+typedef struct
+{
+  GtkAdjustment *gridspacing;
+  GtkAdjustment *grid_sectors_desired;
+  GtkAdjustment *grid_radius_interval;
+  GtkWidget     *gridtypemenu;
+  GtkWidget     *drawgrid;
+  GtkWidget     *snap2grid;
+  GtkWidget     *lockongrid;
+  GtkWidget     *showcontrol;
+} GfigOptWidgets;
+
+static GfigOptWidgets  gfig_opt_widget = { NULL, NULL, NULL, NULL, NULL, NULL };
+static gchar          *gfig_path       = NULL;
+static GtkWidget      *page_menu_bg;
+static GtkWidget      *tool_options_notebook;
+static GtkWidget      *fill_type_notebook;
+static guint           paint_timeout   = 0;
+
+static GtkActionGroup *gfig_actions    = NULL;
+
+
+static void       gfig_response              (GtkWidget *widget,
+                                              gint       response_id,
+                                              gpointer   data);
+static void       gfig_load_action_callback  (GtkAction *action,
+                                              gpointer   data);
+static void       gfig_save_action_callback  (GtkAction *action,
+                                              gpointer   data);
+static void       gfig_list_load_all         (const gchar *path);
+static void       gfig_list_free_all         (void);
+static void       create_notebook_pages      (GtkWidget *notebook);
+static void       select_filltype_callback   (GtkWidget *widget);
+static void       gfig_grid_action_callback  (GtkAction *action,
+                                              gpointer   data);
+static void       gfig_prefs_action_callback (GtkAction *action,
+                                              gpointer   data);
+static void       toggle_show_image          (void);
+static void       gridtype_combo_callback    (GtkWidget *widget,
+                                              gpointer data);
+
+static void      load_file_chooser_response  (GtkFileChooser *chooser,
+                                              gint            response_id,
+                                              gpointer        data);
+static void      save_file_chooser_response  (GtkFileChooser *chooser,
+                                              gint            response_id,
+                                              GFigObj        *obj);
+static void     paint_combo_callback         (GtkWidget *widget,
+                                              gpointer   data);
+
+static void     select_button_clicked        (gint       type);
+static void     select_button_clicked_lt     (void);
+static void     select_button_clicked_gt     (void);
+static void     select_button_clicked_eq     (void);
+static void     raise_selected_obj_to_top    (GtkWidget *widget,
+                                              gpointer   data);
+static void     lower_selected_obj_to_bottom (GtkWidget *widget,
+                                              gpointer   data);
+static void     raise_selected_obj           (GtkWidget *widget,
+                                              gpointer   data);
+static void     lower_selected_obj           (GtkWidget *widget,
+                                              gpointer   data);
+
+static void     toggle_obj_type              (GtkRadioAction *action,
+                                              GtkRadioAction *current,
+                                              gpointer        data);
+
+static GtkUIManager *create_ui_manager       (GtkWidget *window);
+
+
+gboolean
+gfig_dialog (void)
+{
+  GtkWidget    *main_hbox;
+  GtkWidget    *vbox;
+  GFigObj      *gfig;
+  GimpParasite *parasite;
+  gint          newlayer;
+  GtkWidget    *menubar;
+  GtkWidget    *toolbar;
+  GtkWidget    *combo;
+  GtkWidget    *frame;
+  gint          img_width;
+  gint          img_height;
+  GimpImageType img_type;
+  GtkWidget    *toggle;
+  GtkWidget    *right_vbox;
+  GtkWidget    *hbox;
+  GtkUIManager *ui_manager;
+  GtkWidget    *empty_label;
+  gchar        *path;
+
+  gimp_ui_init (PLUG_IN_BINARY, TRUE);
+
+  img_width  = gimp_drawable_width (gfig_context->drawable_id);
+  img_height = gimp_drawable_height (gfig_context->drawable_id);
+  img_type   = gimp_drawable_type_with_alpha (gfig_context->drawable_id);
+
+  /*
+   * See if there is a "gfig" parasite.  If so, this is a gfig layer,
+   * and we start by clearing it to transparent.
+   * If not, we create a new transparent layer.
+   */
+  gfig_list = NULL;
+  undo_level = -1;
+  parasite = gimp_item_get_parasite (gfig_context->drawable_id, "gfig");
+  gfig_context->enable_repaint = FALSE;
+
+  /* debug */
+  gfig_context->debug_styles = FALSE;
+
+  /* initial default style */
+  gfig_read_gimp_style (&gfig_context->default_style, "Base");
+  gfig_context->default_style.paint_type = selvals.painttype;
+
+  if (parasite)
+    {
+      gimp_drawable_fill (gfig_context->drawable_id, GIMP_FILL_TRANSPARENT);
+      gfig_context->using_new_layer = FALSE;
+      gimp_parasite_free (parasite);
+    }
+  else
+    {
+      newlayer = gimp_layer_new (gfig_context->image_id, "GFig",
+                                 img_width, img_height,
+                                 img_type,
+                                 100.0,
+                                 gimp_image_get_default_new_layer_mode (gfig_context->image_id));
+      gimp_drawable_fill (newlayer, GIMP_FILL_TRANSPARENT);
+      gimp_image_insert_layer (gfig_context->image_id, newlayer, -1, -1);
+      gfig_context->drawable_id = newlayer;
+      gfig_context->using_new_layer = TRUE;
+    }
+
+  gfig_stock_init ();
+
+  path = gimp_gimprc_query ("gfig-path");
+
+  if (path)
+    {
+      gfig_path = g_filename_from_utf8 (path, -1, NULL, NULL, NULL);
+      g_free (path);
+    }
+  else
+    {
+      gchar *gimprc    = gimp_personal_rc_file ("gimprc");
+      gchar *full_path = gimp_config_build_data_path ("gfig");
+      gchar *esc_path  = g_strescape (full_path, NULL);
+      g_free (full_path);
+
+      g_message (_("No %s in gimprc:\n"
+                   "You need to add an entry like\n"
+                   "(%s \"%s\")\n"
+                   "to your %s file."),
+                   "gfig-path", "gfig-path", esc_path,
+                   gimp_filename_to_utf8 (gimprc));
+
+      g_free (gimprc);
+      g_free (esc_path);
+    }
+
+  /* Start building the dialog up */
+  top_level_dlg = gimp_dialog_new (_("Gfig"), PLUG_IN_ROLE,
+                                   NULL, 0,
+                                   gimp_standard_help_func, PLUG_IN_PROC,
+
+                                   _("_Cancel"), GTK_RESPONSE_CANCEL,
+                                   _("_Close"),  GTK_RESPONSE_OK,
+
+                                   NULL);
+
+  gtk_dialog_set_alternative_button_order (GTK_DIALOG (top_level_dlg),
+                                           GTK_RESPONSE_OK,
+                                           GTK_RESPONSE_CANCEL,
+                                           -1);
+
+  g_signal_connect (top_level_dlg, "response",
+                    G_CALLBACK (gfig_response),
+                    top_level_dlg);
+
+  /* build the menu */
+  ui_manager = create_ui_manager (top_level_dlg);
+  menubar = gtk_ui_manager_get_widget (ui_manager, "/ui/gfig-menubar");
+  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (top_level_dlg))),
+                      menubar, FALSE, FALSE, 0);
+  gtk_widget_show (menubar);
+  toolbar = gtk_ui_manager_get_widget (ui_manager, "/ui/gfig-toolbar");
+  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
+  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (top_level_dlg))),
+                      toolbar, FALSE, FALSE, 0);
+  gtk_widget_show (toolbar);
+
+  gfig_dialog_action_set_sensitive ("undo", undo_level >= 0);
+
+  /* Main box */
+  main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
+  gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);
+  gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (top_level_dlg))),
+                    main_hbox, TRUE, TRUE, 0);
+
+  /* Preview itself */
+  gtk_box_pack_start (GTK_BOX (main_hbox), make_preview (), FALSE, FALSE, 0);
+
+  gtk_widget_show (gfig_context->preview);
+
+  right_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+  gtk_box_pack_start (GTK_BOX (main_hbox), right_vbox, FALSE, FALSE, 0);
+  gtk_widget_show (right_vbox);
+
+  /* Tool options notebook */
+  frame = gimp_frame_new ( _("Tool Options"));
+  gtk_box_pack_start (GTK_BOX (right_vbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  tool_options_notebook = gtk_notebook_new ();
+  gtk_container_add (GTK_CONTAINER (frame), tool_options_notebook);
+  gtk_notebook_set_show_tabs (GTK_NOTEBOOK (tool_options_notebook), FALSE);
+  gtk_notebook_set_show_border (GTK_NOTEBOOK (tool_options_notebook), FALSE);
+  gtk_widget_show (tool_options_notebook);
+  create_notebook_pages (tool_options_notebook);
+
+  /* Stroke frame on right side */
+  frame = gimp_frame_new (NULL);
+  gtk_box_pack_start (GTK_BOX (right_vbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  gfig_context->paint_type_toggle =
+    toggle = gtk_check_button_new_with_mnemonic (_("_Stroke"));
+
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), selvals.painttype);
+  gtk_frame_set_label_widget (GTK_FRAME (frame), toggle);
+  gtk_widget_show (toggle);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_container_add (GTK_CONTAINER (frame), hbox);
+  gtk_widget_show (hbox);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+  gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
+  gtk_widget_show (vbox);
+
+  gtk_widget_set_sensitive (vbox, selvals.painttype);
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (set_paint_type_callback),
+                    vbox);
+
+  /* foreground color button in Stroke frame*/
+  gfig_context->fg_color = g_new0 (GimpRGB, 1);
+  gfig_context->fg_color_button = gimp_color_button_new ("Foreground",
+                                                    SEL_BUTTON_WIDTH,
+                                                    SEL_BUTTON_HEIGHT,
+                                                    gfig_context->fg_color,
+                                                    GIMP_COLOR_AREA_SMALL_CHECKS);
+  g_signal_connect (gfig_context->fg_color_button, "color-changed",
+                    G_CALLBACK (set_foreground_callback),
+                    gfig_context->fg_color);
+  gimp_color_button_set_color (GIMP_COLOR_BUTTON (gfig_context->fg_color_button),
+                               &gfig_context->default_style.foreground);
+  gtk_box_pack_start (GTK_BOX (vbox), gfig_context->fg_color_button,
+                      FALSE, FALSE, 0);
+  gtk_widget_show (gfig_context->fg_color_button);
+
+  /* brush selector in Stroke frame */
+  gfig_context->brush_select
+    = gimp_brush_select_button_new ("Brush",
+                                    gfig_context->default_style.brush_name,
+                                    -1.0, -1, -1);
+  g_signal_connect (gfig_context->brush_select, "brush-set",
+                    G_CALLBACK (gfig_brush_changed_callback), NULL);
+  gtk_box_pack_start (GTK_BOX (vbox), gfig_context->brush_select,
+                      FALSE, FALSE, 0);
+  gtk_widget_show (gfig_context->brush_select);
+
+  /* Fill frame on right side */
+  frame = gimp_frame_new (_("Fill"));
+  gtk_box_pack_start (GTK_BOX (right_vbox), frame, FALSE, FALSE, 0);
+  gtk_widget_show (frame);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+  gtk_container_add (GTK_CONTAINER (frame), hbox);
+  gtk_widget_show (hbox);
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+  gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
+  gtk_widget_show (vbox);
+
+  /* fill style combo box in Style frame  */
+  gfig_context->fillstyle_combo = combo
+    = gimp_int_combo_box_new (_("No fill"),             FILL_NONE,
+                              _("Color fill"),          FILL_COLOR,
+                              _("Pattern fill"),        FILL_PATTERN,
+                              _("Shape gradient"),      FILL_GRADIENT,
+                              _("Vertical gradient"),   FILL_VERTICAL,
+                              _("Horizontal gradient"), FILL_HORIZONTAL,
+                              NULL);
+  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), 0);
+  g_signal_connect (combo, "changed",
+                    G_CALLBACK (select_filltype_callback),
+                    NULL);
+  gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0);
+  gtk_widget_show (combo);
+
+  fill_type_notebook = gtk_notebook_new ();
+  gtk_box_pack_start (GTK_BOX (vbox), fill_type_notebook, FALSE, FALSE, 0);
+  gtk_notebook_set_show_tabs (GTK_NOTEBOOK (fill_type_notebook), FALSE);
+  gtk_notebook_set_show_border (GTK_NOTEBOOK (fill_type_notebook), FALSE);
+  gtk_widget_show (fill_type_notebook);
+
+  /* An empty page for "No fill" */
+  empty_label = gtk_label_new ("");
+  gtk_widget_show (empty_label);
+  gtk_notebook_append_page (GTK_NOTEBOOK (fill_type_notebook),
+                            empty_label, NULL);
+
+  /* A page for the fill color button */
+  gfig_context->bg_color = g_new0 (GimpRGB, 1);
+  gfig_context->bg_color_button = gimp_color_button_new ("Background",
+                                           SEL_BUTTON_WIDTH, SEL_BUTTON_HEIGHT,
+                                           gfig_context->bg_color,
+                                           GIMP_COLOR_AREA_SMALL_CHECKS);
+  g_signal_connect (gfig_context->bg_color_button, "color-changed",
+                    G_CALLBACK (set_background_callback),
+                    gfig_context->bg_color);
+  gimp_color_button_set_color (GIMP_COLOR_BUTTON (gfig_context->bg_color_button),
+                               &gfig_context->default_style.background);
+  gtk_widget_show (gfig_context->bg_color_button);
+  gtk_notebook_append_page (GTK_NOTEBOOK (fill_type_notebook),
+                            gfig_context->bg_color_button, NULL);
+
+  /* A page for the pattern selector */
+  gfig_context->pattern_select
+    = gimp_pattern_select_button_new ("Pattern", gfig_context->default_style.pattern);
+  g_signal_connect (gfig_context->pattern_select, "pattern-set",
+                    G_CALLBACK (gfig_pattern_changed_callback), NULL);
+  gtk_widget_show (gfig_context->pattern_select);
+  gtk_notebook_append_page (GTK_NOTEBOOK (fill_type_notebook),
+                            gfig_context->pattern_select, NULL);
+
+  /* A page for the gradient selector */
+  gfig_context->gradient_select
+    = gimp_gradient_select_button_new ("Gradient", gfig_context->default_style.gradient);
+  g_signal_connect (gfig_context->gradient_select, "gradient-set",
+                    G_CALLBACK (gfig_gradient_changed_callback), NULL);
+  gtk_widget_show (gfig_context->gradient_select);
+  gtk_notebook_append_page (GTK_NOTEBOOK (fill_type_notebook),
+                            gfig_context->gradient_select, NULL);
+
+
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+  gtk_box_pack_start (GTK_BOX (right_vbox), vbox, FALSE, FALSE, 0);
+  gtk_widget_show (vbox);
+
+  /* "show image" checkbutton at bottom of style frame */
+  toggle = gtk_check_button_new_with_label (_("Show image"));
+  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
+                                gfig_context->show_background);
+  gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (gimp_toggle_button_update),
+                    &gfig_context->show_background);
+  g_signal_connect_swapped (toggle, "toggled",
+                    G_CALLBACK (gtk_widget_queue_draw),
+                    gfig_context->preview);
+  gtk_widget_show (toggle);
+
+  /* "snap to grid" checkbutton at bottom of style frame */
+  toggle = gtk_check_button_new_with_label (C_("checkbutton", "Snap to grid"));
+  gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (gimp_toggle_button_update),
+                    &selvals.opts.snap2grid);
+  gtk_widget_show (toggle);
+  gfig_opt_widget.snap2grid = toggle;
+
+  /* "show grid" checkbutton at bottom of style frame */
+  toggle = gtk_check_button_new_with_label (_("Show grid"));
+  gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (gimp_toggle_button_update),
+                    &selvals.opts.drawgrid);
+  g_signal_connect (toggle, "toggled",
+                    G_CALLBACK (draw_grid_clear),
+                    NULL);
+  gtk_widget_show (toggle);
+  gfig_opt_widget.drawgrid = toggle;
+
+  /* Load saved objects */
+  gfig_list_load_all (gfig_path);
+
+  /* Setup initial brush settings */
+  gfig_context->bdesc.name = gimp_context_get_brush ();
+  mygimp_brush_info (&gfig_context->bdesc.width, &gfig_context->bdesc.height);
+
+  gtk_widget_show (main_hbox);
+
+  gtk_widget_show (top_level_dlg);
+
+  gfig = gfig_load_from_parasite ();
+  if (gfig)
+    {
+      gfig_list_insert (gfig);
+      new_obj_2edit (gfig);
+      gfig_style_set_context_from_style (&gfig_context->default_style);
+      gfig_style_apply (&gfig_context->default_style);
+    }
+
+  gfig_context->enable_repaint = TRUE;
+  gfig_paint_callback ();
+
+  gtk_main ();
+
+  /* FIXME */
+  return TRUE;
+}
+
+static void
+gfig_response (GtkWidget *widget,
+               gint       response_id,
+               gpointer   data)
+{
+  GFigObj *gfig;
+
+  switch (response_id)
+    {
+    case GTK_RESPONSE_DELETE_EVENT:
+    case GTK_RESPONSE_CANCEL:
+      /* if we created a new layer, delete it */
+      if (gfig_context->using_new_layer)
+        {
+          gimp_image_remove_layer (gfig_context->image_id,
+                                   gfig_context->drawable_id);
+        }
+      else /* revert back to the original figure */
+        {
+          free_all_objs (gfig_context->current_obj->obj_list);
+          gfig_context->current_obj->obj_list = NULL;
+          gfig = gfig_load_from_parasite ();
+          if (gfig)
+            {
+              gfig_list_insert (gfig);
+              new_obj_2edit (gfig);
+            }
+          gfig_context->enable_repaint = TRUE;
+          gfig_paint_callback ();
+        }
+      break;
+
+    case GTK_RESPONSE_OK:  /* Close button */
+      gfig_save_as_parasite ();
+      break;
+
+    default:
+      break;
+    }
+
+  gtk_widget_destroy (widget);
+  gtk_main_quit ();
+}
+
+void
+gfig_dialog_action_set_sensitive (const gchar *name,
+                                  gboolean     sensitive)
+{
+  g_return_if_fail (name != NULL);
+
+  if (gfig_actions)
+    {
+      GtkAction *action = gtk_action_group_get_action (gfig_actions, name);
+
+      if (! action)
+        {
+          g_warning ("%s: Unable to set sensitivity of action "
+                     "which doesn't exist: %s",
+                     G_STRFUNC, name);
+          return;
+        }
+
+      g_object_set (action, "sensitive", sensitive ? TRUE : FALSE, NULL);
+    }
+}
+
+static gchar *
+gfig_get_user_writable_dir (void)
+{
+  if (gfig_path)
+    {
+      GList *list;
+      gchar *dir;
+
+      list = gimp_path_parse (gfig_path, 256, FALSE, NULL);
+      dir = gimp_path_get_user_writable_dir (list);
+      gimp_path_free (list);
+
+      return dir;
+    }
+
+  return g_strdup (gimp_directory ());
+}
+
+static void
+gfig_load_action_callback (GtkAction *action,
+                           gpointer   data)
+{
+  static GtkWidget *dialog = NULL;
+
+  if (! dialog)
+    {
+      gchar *dir;
+
+      dialog =
+        gtk_file_chooser_dialog_new (_("Load Gfig Object Collection"),
+                                     GTK_WINDOW (data),
+                                     GTK_FILE_CHOOSER_ACTION_OPEN,
+
+                                     _("_Cancel"), GTK_RESPONSE_CANCEL,
+                                     _("_Open"),   GTK_RESPONSE_OK,
+
+                                     NULL);
+
+      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                               GTK_RESPONSE_OK,
+                                               GTK_RESPONSE_CANCEL,
+                                               -1);
+
+      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
+
+      g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer) &dialog);
+
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (load_file_chooser_response),
+                        NULL);
+
+      dir = gfig_get_user_writable_dir ();
+      if (dir)
+        {
+          gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog),
+                                               dir);
+          g_free (dir);
+        }
+
+      gtk_widget_show (dialog);
+    }
+  else
+    {
+      gtk_window_present (GTK_WINDOW (dialog));
+    }
+}
+
+static void
+gfig_save_action_callback (GtkAction *action,
+                           gpointer   data)
+{
+  static GtkWidget *dialog = NULL;
+
+  if (!dialog)
+    {
+      gchar *dir;
+
+      dialog =
+        gtk_file_chooser_dialog_new (_("Save Gfig Drawing"),
+                                     GTK_WINDOW (data),
+                                     GTK_FILE_CHOOSER_ACTION_SAVE,
+
+                                     _("_Cancel"), GTK_RESPONSE_CANCEL,
+                                     _("_Save"),   GTK_RESPONSE_OK,
+
+                                     NULL);
+
+      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+                                               GTK_RESPONSE_OK,
+                                               GTK_RESPONSE_CANCEL,
+                                               -1);
+      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
+
+      gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
+                                                      TRUE);
+
+      g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer) &dialog);
+
+      /* FIXME: GFigObj should be a GObject and g_signal_connect_object()
+       *        should be used here.
+       */
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (save_file_chooser_response),
+                        gfig_context->current_obj);
+
+      dir = gfig_get_user_writable_dir ();
+      if (dir)
+        {
+          gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), dir);
+          g_free (dir);
+        }
+
+      gtk_widget_show (dialog);
+    }
+  else
+    {
+      gtk_window_present (GTK_WINDOW (dialog));
+    }
+}
+
+static void
+gfig_close_action_callback (GtkAction *action,
+                            gpointer   data)
+{
+  gtk_dialog_response (GTK_DIALOG (data), GTK_RESPONSE_OK);
+}
+
+static void
+gfig_undo_action_callback (GtkAction *action,
+                           gpointer   data)
+{
+  if (undo_level >= 0)
+    {
+      /* Free current objects an reinstate previous */
+      free_all_objs (gfig_context->current_obj->obj_list);
+      gfig_context->current_obj->obj_list = NULL;
+      tmp_bezier = tmp_line = obj_creating = NULL;
+      gfig_context->current_obj->obj_list = undo_table[undo_level];
+      undo_level--;
+      /* Update the screen */
+      gtk_widget_queue_draw (gfig_context->preview);
+      /* And preview */
+      gfig_context->current_obj->obj_status |= GFIG_MODIFIED;
+      if (gfig_context->current_obj->obj_list)
+        gfig_context->selected_obj = gfig_context->current_obj->obj_list->data;
+      else
+        gfig_context->selected_obj = NULL;
+    }
+
+  gfig_dialog_action_set_sensitive ("undo", undo_level >= 0);
+  gfig_paint_callback ();
+}
+
+static void
+gfig_clear_action_callback (GtkWidget *widget,
+                          gpointer   data)
+{
+  /* Make sure we can get back - if we have some objects to get back to */
+  if (!gfig_context->current_obj->obj_list)
+    return;
+
+  setup_undo ();
+  /* Free all objects */
+  free_all_objs (gfig_context->current_obj->obj_list);
+  gfig_context->current_obj->obj_list = NULL;
+  gfig_context->selected_obj = NULL;
+  obj_creating = NULL;
+  tmp_line = NULL;
+  tmp_bezier = NULL;
+  gtk_widget_queue_draw (gfig_context->preview);
+  gfig_paint_callback ();
+}
+
+void
+draw_item (cairo_t *cr, gboolean fill)
+{
+  cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0);
+
+  if (fill)
+    {
+      cairo_fill_preserve (cr);
+    }
+  else
+    {
+      cairo_set_line_width (cr, 3.0);
+      cairo_stroke_preserve (cr);
+    }
+
+  cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 1.0);
+  cairo_set_line_width (cr, 1.0);
+  cairo_stroke (cr);
+}
+
+/* Given a point x, y draw a circle */
+void
+draw_circle (GdkPoint *p,
+             gboolean  selected,
+             cairo_t  *cr)
+{
+  if (!selvals.opts.showcontrol)
+    return;
+
+  cairo_arc (cr,
+             gfig_scale_x (p->x) + .5,
+             gfig_scale_y (p->y) + .5,
+             SQ_SIZE / 2,
+             0, 2 * G_PI);
+
+  draw_item (cr, selected);
+}
+
+/* Given a point x, y draw a square around it */
+void
+draw_sqr (GdkPoint *p,
+          gboolean  selected,
+          cairo_t  *cr)
+{
+  if (!selvals.opts.showcontrol)
+    return;
+
+  cairo_rectangle (cr,
+                   gfig_scale_x (p->x) + .5 - SQ_SIZE / 2,
+                   gfig_scale_y (p->y) + .5 - SQ_SIZE / 2,
+                   SQ_SIZE,
+                   SQ_SIZE);
+
+  draw_item (cr, selected);
+}
+
+static void
+gfig_list_load_all (const gchar *path)
+{
+  /*  Make sure to clear any existing gfigs  */
+  gfig_context->current_obj = NULL;
+  gfig_list_free_all ();
+
+  if (! gfig_list)
+    {
+      GFigObj *gfig;
+
+      /* lets have at least one! */
+      gfig = gfig_new ();
+      gfig->draw_name = g_strdup (_("First Gfig"));
+      gfig_list_insert (gfig);
+    }
+
+  gfig_context->current_obj = gfig_list->data;  /* set to first entry */
+}
+
+static void
+gfig_list_free_all (void)
+{
+  g_list_free_full (gfig_list, (GDestroyNotify) gfig_free);
+  gfig_list = NULL;
+}
+
+static GtkUIManager *
+create_ui_manager (GtkWidget *window)
+{
+  static GtkActionEntry actions[] =
+  {
+    { "gfig-menubar", NULL, "GFig Menu" },
+
+    { "gfig-file-menu", NULL, "_File" },
+
+    { "open", GIMP_ICON_DOCUMENT_OPEN,
+      N_("_Open..."), "<control>O", NULL,
+      G_CALLBACK (gfig_load_action_callback) },
+
+    { "save", GIMP_ICON_DOCUMENT_SAVE,
+      N_("_Save..."), "<control>S", NULL,
+      G_CALLBACK (gfig_save_action_callback) },
+
+    { "close", GIMP_ICON_CLOSE,
+      N_("_Close"), "<control>C", NULL,
+      G_CALLBACK (gfig_close_action_callback) },
+
+    { "gfig-edit-menu", NULL, "_Edit" },
+
+    { "undo", GIMP_ICON_EDIT_UNDO,
+      N_("_Undo"), "<control>Z", NULL,
+      G_CALLBACK (gfig_undo_action_callback) },
+
+    { "clear", GIMP_ICON_EDIT_CLEAR,
+      N_("_Clear"), NULL, NULL,
+      G_CALLBACK (gfig_clear_action_callback) },
+
+    { "grid", GIMP_ICON_GRID,
+      N_("_Grid"), "<control>G", NULL,
+      G_CALLBACK (gfig_grid_action_callback) },
+
+    { "prefs", GIMP_ICON_PREFERENCES_SYSTEM,
+      N_("_Preferences..."), "<control>P", NULL,
+      G_CALLBACK (gfig_prefs_action_callback) },
+
+    { "raise", GIMP_ICON_GO_UP,
+      N_("_Raise"), "<control>U", N_("Raise selected object"),
+      G_CALLBACK (raise_selected_obj) },
+
+    { "lower", GIMP_ICON_GO_DOWN,
+      N_("_Lower"), "<control>D", N_("Lower selected object"),
+      G_CALLBACK (lower_selected_obj) },
+
+    { "top", GIMP_ICON_GO_TOP,
+      N_("Raise to _top"), "<control>T", N_("Raise selected object to top"),
+      G_CALLBACK (raise_selected_obj_to_top) },
+
+    { "bottom", GIMP_ICON_GO_BOTTOM,
+      N_("Lower to _bottom"), "<control>B", N_("Lower selected object to bottom"),
+      G_CALLBACK (lower_selected_obj_to_bottom) },
+
+    { "show_previous", GIMP_ICON_GO_PREVIOUS,
+      N_("_Previous"), "<control>H", N_("Show previous object"),
+      G_CALLBACK (select_button_clicked_lt) },
+
+    { "show_next", GIMP_ICON_GO_NEXT,
+      N_("_Next"), "<control>L", N_("Show next object"),
+      G_CALLBACK (select_button_clicked_gt) },
+
+    { "show_all", GFIG_STOCK_SHOW_ALL,
+      N_("Show _all"), "<control>A", N_("Show all objects"),
+      G_CALLBACK (select_button_clicked_eq) }
+  };
+  static GtkRadioActionEntry radio_actions[] =
+  {
+    { "line", GFIG_STOCK_LINE,
+      NULL, "L", N_("Create line"), LINE },
+
+    { "rectangle", GFIG_STOCK_RECTANGLE,
+      NULL, "R", N_("Create rectangle"), RECTANGLE },
+
+    { "circle", GFIG_STOCK_CIRCLE,
+      NULL, "C", N_("Create circle"), CIRCLE },
+
+    { "ellipse", GFIG_STOCK_ELLIPSE,
+      NULL, "E", N_("Create ellipse"), ELLIPSE },
+
+    { "arc", GFIG_STOCK_CURVE,
+      NULL, "A", N_("Create arc"), ARC },
+
+    { "polygon", GFIG_STOCK_POLYGON,
+      NULL, "P", N_("Create reg polygon"), POLY },
+
+    { "star", GFIG_STOCK_STAR,
+      NULL, "S", N_("Create star"), STAR },
+
+    { "spiral", GFIG_STOCK_SPIRAL,
+       NULL, "I", N_("Create spiral"), SPIRAL },
+
+    { "bezier", GFIG_STOCK_BEZIER,
+      NULL, "B", N_("Create bezier curve. "
+                    "Shift + Button ends object creation."), BEZIER },
+
+    { "move_obj", GFIG_STOCK_MOVE_OBJECT,
+      NULL, "M", N_("Move an object"), MOVE_OBJ },
+
+    { "move_point", GFIG_STOCK_MOVE_POINT,
+      NULL, "V", N_("Move a single point"), MOVE_POINT },
+
+    { "copy", GFIG_STOCK_COPY_OBJECT,
+      NULL, "Y", N_("Copy an object"), COPY_OBJ },
+
+    { "delete", GFIG_STOCK_DELETE_OBJECT,
+      NULL, "D", N_("Delete an object"), DEL_OBJ },
+
+    { "select", GFIG_STOCK_SELECT_OBJECT,
+      NULL, "A", N_("Select an object"), SELECT_OBJ }
+  };
+
+  GtkUIManager   *ui_manager = gtk_ui_manager_new ();
+
+  gfig_actions = gtk_action_group_new ("Actions");
+
+  gtk_action_group_set_translation_domain (gfig_actions, NULL);
+
+  gtk_action_group_add_actions (gfig_actions,
+                                actions,
+                                G_N_ELEMENTS (actions),
+                                window);
+  gtk_action_group_add_radio_actions (gfig_actions,
+                                      radio_actions,
+                                      G_N_ELEMENTS (radio_actions),
+                                      LINE,
+                                      G_CALLBACK (toggle_obj_type),
+                                      window);
+
+  gtk_window_add_accel_group (GTK_WINDOW (window),
+                              gtk_ui_manager_get_accel_group (ui_manager));
+  gtk_accel_group_lock (gtk_ui_manager_get_accel_group (ui_manager));
+
+  gtk_ui_manager_insert_action_group (ui_manager, gfig_actions, -1);
+  g_object_unref (gfig_actions);
+
+  gtk_ui_manager_add_ui_from_string (ui_manager,
+                                     "<ui>"
+                                     "  <menubar name=\"gfig-menubar\">"
+                                     "    <menu name=\"File\" action=\"gfig-file-menu\">"
+                                     "      <menuitem action=\"open\" />"
+                                     "      <menuitem action=\"save\" />"
+                                     "      <menuitem action=\"close\" />"
+                                     "    </menu>"
+                                     "    <menu name=\"Edit\" action=\"gfig-edit-menu\">"
+                                     "      <menuitem action=\"undo\" />"
+                                     "      <menuitem action=\"clear\" />"
+                                     "      <menuitem action=\"grid\" />"
+                                     "      <menuitem action=\"prefs\" />"
+                                     "    </menu>"
+                                     "  </menubar>"
+                                     "</ui>",
+                                     -1, NULL);
+  gtk_ui_manager_add_ui_from_string (ui_manager,
+                                     "<ui>"
+                                     "  <toolbar name=\"gfig-toolbar\">"
+                                     "    <toolitem action=\"line\" />"
+                                     "    <toolitem action=\"rectangle\" />"
+                                     "    <toolitem action=\"circle\" />"
+                                     "    <toolitem action=\"ellipse\" />"
+                                     "    <toolitem action=\"arc\" />"
+                                     "    <toolitem action=\"polygon\" />"
+                                     "    <toolitem action=\"star\" />"
+                                     "    <toolitem action=\"spiral\" />"
+                                     "    <toolitem action=\"bezier\" />"
+                                     "    <toolitem action=\"move_obj\" />"
+                                     "    <toolitem action=\"move_point\" />"
+                                     "    <toolitem action=\"copy\" />"
+                                     "    <toolitem action=\"delete\" />"
+                                     "    <toolitem action=\"select\" />"
+                                     "    <separator />"
+                                     "    <toolitem action=\"raise\" />"
+                                     "    <toolitem action=\"lower\" />"
+                                     "    <toolitem action=\"top\" />"
+                                     "    <toolitem action=\"bottom\" />"
+                                     "    <separator />"
+                                     "    <toolitem action=\"show_previous\" />"
+                                     "    <toolitem action=\"show_next\" />"
+                                     "    <toolitem action=\"show_all\" />"
+                                     "  </toolbar>"
+                                     "</ui>",
+                                     -1, NULL);
+
+  return ui_manager;
+}
+
+static void
+tool_option_no_option (GtkWidget *notebook)
+{
+  GtkWidget *label;
+
+  label = gtk_label_new (_("This tool has no options"));
+  gtk_widget_show (label);
+  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), label, NULL);
+}
+
+static void
+create_notebook_pages (GtkWidget *notebook)
+{
+  tool_option_no_option (notebook);   /* Line          */
+  tool_option_no_option (notebook);   /* Rectangle     */
+  tool_option_no_option (notebook);   /* Circle        */
+  tool_option_no_option (notebook);   /* Ellipse       */
+  tool_option_no_option (notebook);   /* Arc           */
+  tool_options_poly (notebook);       /* Polygon       */
+  tool_options_star (notebook);       /* Star          */
+  tool_options_spiral (notebook);     /* Spiral        */
+  tool_options_bezier (notebook);     /* Bezier        */
+  tool_option_no_option (notebook);   /* Dummy         */
+  tool_option_no_option (notebook);   /* Move Object   */
+  tool_option_no_option (notebook);   /* Move Point    */
+  tool_option_no_option (notebook);   /* Copy Object   */
+  tool_option_no_option (notebook);   /* Delete Object */
+}
+
+static void
+raise_selected_obj_to_top (GtkWidget *widget,
+                           gpointer   data)
+{
+  if (!gfig_context->selected_obj)
+    return;
+
+  if (g_list_find (gfig_context->current_obj->obj_list,
+                   gfig_context->selected_obj))
+    {
+      gfig_context->current_obj->obj_list =
+        g_list_remove (gfig_context->current_obj->obj_list,
+                       gfig_context->selected_obj);
+      gfig_context->current_obj->obj_list =
+        g_list_append (gfig_context->current_obj->obj_list,
+                       gfig_context->selected_obj);
+    }
+  else
+    {
+      g_message ("Trying to raise object that does not exist.");
+      return;
+    }
+
+  gfig_paint_callback ();
+}
+
+static void
+lower_selected_obj_to_bottom (GtkWidget *widget,
+                              gpointer   data)
+{
+  if (!gfig_context->selected_obj)
+    return;
+
+  if (g_list_find (gfig_context->current_obj->obj_list,
+                   gfig_context->selected_obj))
+    {
+      gfig_context->current_obj->obj_list =
+        g_list_remove (gfig_context->current_obj->obj_list,
+                       gfig_context->selected_obj);
+      gfig_context->current_obj->obj_list =
+        g_list_prepend (gfig_context->current_obj->obj_list,
+                        gfig_context->selected_obj);
+    }
+  else
+    {
+      g_message ("Trying to lower object that does not exist.");
+      return;
+    }
+
+  gfig_paint_callback ();
+}
+
+static void
+raise_selected_obj (GtkWidget *widget,
+                    gpointer   data)
+{
+  if (!gfig_context->selected_obj)
+    return;
+
+  if (g_list_find (gfig_context->current_obj->obj_list,
+                   gfig_context->selected_obj))
+    {
+      int position;
+
+      position = g_list_index (gfig_context->current_obj->obj_list,
+                               gfig_context->selected_obj);
+      gfig_context->current_obj->obj_list =
+        g_list_remove (gfig_context->current_obj->obj_list,
+                       gfig_context->selected_obj);
+      gfig_context->current_obj->obj_list =
+        g_list_insert (gfig_context->current_obj->obj_list,
+                       gfig_context->selected_obj,
+                       position + 1);
+    }
+  else
+    {
+      g_message ("Trying to raise object that does not exist.");
+      return;
+    }
+
+  gfig_paint_callback ();
+}
+
+
+static void
+lower_selected_obj (GtkWidget *widget,
+                    gpointer   data)
+{
+  if (!gfig_context->selected_obj)
+    return;
+
+  if (g_list_find (gfig_context->current_obj->obj_list,
+                   gfig_context->selected_obj))
+    {
+      int position;
+
+      position = g_list_index (gfig_context->current_obj->obj_list,
+                               gfig_context->selected_obj);
+      gfig_context->current_obj->obj_list =
+        g_list_remove (gfig_context->current_obj->obj_list,
+                       gfig_context->selected_obj);
+      gfig_context->current_obj->obj_list =
+        g_list_insert (gfig_context->current_obj->obj_list,
+                       gfig_context->selected_obj,
+                       MAX (0, position - 1));
+    }
+  else
+    {
+      g_message ("Trying to lower object that does not exist.");
+      return;
+    }
+
+  gfig_paint_callback ();
+}
+
+
+static void
+select_filltype_callback (GtkWidget *widget)
+{
+  gint value;
+
+  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value);
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (fill_type_notebook),
+                                 MIN (value, FILL_GRADIENT));
+
+  gfig_context_get_current_style ()->fill_type = (FillType) value;
+
+  gfig_paint_callback ();
+}
+
+static gboolean
+gfig_paint_timeout (gpointer data)
+{
+  gfig_paint_callback ();
+
+  paint_timeout = 0;
+
+  return FALSE;
+}
+
+static void
+gfig_paint_delayed (void)
+{
+  if (paint_timeout)
+    g_source_remove (paint_timeout);
+
+  paint_timeout =
+    g_timeout_add (UPDATE_DELAY, gfig_paint_timeout, NULL);
+}
+
+static void
+gfig_prefs_action_callback (GtkAction *widget,
+                            gpointer   data)
+{
+  static GtkWidget *dialog = NULL;
+
+  if (!dialog)
+    {
+      GtkWidget     *main_vbox;
+      GtkWidget     *table;
+      GtkWidget     *toggle;
+      GtkObject     *size_data;
+      GtkWidget     *scale;
+      GtkAdjustment *scale_data;
+
+      dialog = gimp_dialog_new (_("Options"), "gimp-gfig-options",
+                                GTK_WIDGET (data), 0, NULL, NULL,
+
+                                _("_Close"),  GTK_RESPONSE_CLOSE,
+
+                                NULL);
+
+      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
+
+      g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer) &dialog);
+
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (gtk_widget_destroy),
+                        NULL);
+
+      main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+      gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
+      gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+                          main_vbox, TRUE, TRUE, 0);
+      gtk_widget_show (main_vbox);
+
+      /* Put buttons in */
+      toggle = gtk_check_button_new_with_label (_("Show position"));
+      gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 6);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
+                                    selvals.showpos);
+      g_signal_connect (toggle, "toggled",
+                        G_CALLBACK (gimp_toggle_button_update),
+                        &selvals.showpos);
+      g_signal_connect_after (toggle, "toggled",
+                              G_CALLBACK (gfig_pos_enable),
+                              NULL);
+      gtk_widget_show (toggle);
+
+      toggle = gtk_check_button_new_with_label (_("Show control points"));
+      gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 6);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
+                                    selvals.opts.showcontrol);
+      g_signal_connect (toggle, "toggled",
+                        G_CALLBACK (gimp_toggle_button_update),
+                        &selvals.opts.showcontrol);
+      g_signal_connect (toggle, "toggled",
+                        G_CALLBACK (toggle_show_image),
+                        NULL);
+      gtk_widget_show (toggle);
+
+      gfig_opt_widget.showcontrol = toggle;
+      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.showcontrol),
+                                 (gpointer) &gfig_opt_widget.showcontrol);
+
+      toggle = gtk_check_button_new_with_label (_("Antialiasing"));
+      gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 6);
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), selopt.antia);
+      g_signal_connect (toggle, "toggled",
+                        G_CALLBACK (gimp_toggle_button_update),
+                        &selopt.antia);
+      g_signal_connect (toggle, "toggled",
+                        G_CALLBACK (gfig_paint_callback),
+                        NULL);
+      gtk_widget_show (toggle);
+
+      table = gtk_table_new (4, 4, FALSE);
+      gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+      gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+      gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 6);
+      gtk_widget_show (table);
+
+      size_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
+                                        _("Max undo:"), 100, 50,
+                                        selvals.maxundo,
+                                        MIN_UNDO, MAX_UNDO, 1, 2, 0,
+                                        TRUE, 0, 0,
+                                        NULL, NULL);
+      g_signal_connect (size_data, "value-changed",
+                        G_CALLBACK (gimp_int_adjustment_update),
+                        &selvals.maxundo);
+
+      page_menu_bg = gimp_int_combo_box_new (_("Transparent"), LAYER_TRANS_BG,
+                                             _("Background"),  LAYER_BG_BG,
+                                             _("Foreground"),  LAYER_FG_BG,
+                                             _("White"),       LAYER_WHITE_BG,
+                                             _("Copy"),        LAYER_COPY_BG,
+                                             NULL);
+      gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (page_menu_bg), selvals.onlayerbg);
+
+      g_signal_connect (page_menu_bg, "changed",
+                        G_CALLBACK (paint_combo_callback),
+                        GINT_TO_POINTER (PAINT_BGS_MENU));
+
+      gimp_help_set_help_data (page_menu_bg,
+                               _("Layer background type. Copy causes the "
+                                 "previous layer to be copied before the "
+                                 "draw is performed."),
+                               NULL);
+
+      gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
+                                 _("Background:"), 0.0, 0.5,
+                                 page_menu_bg, 2, FALSE);
+
+      toggle = gtk_check_button_new_with_label (_("Feather"));
+      gtk_table_attach (GTK_TABLE (table), toggle, 2, 3, 2, 3,
+                        GTK_FILL, GTK_FILL, 0, 0);
+      g_signal_connect (toggle, "toggled",
+                        G_CALLBACK (gimp_toggle_button_update),
+                        &selopt.feather);
+      g_signal_connect (toggle, "toggled",
+                        G_CALLBACK (gfig_paint_callback),
+                        NULL);
+      gtk_widget_show (toggle);
+
+      scale_data = (GtkAdjustment *)
+        gtk_adjustment_new (selopt.feather_radius, 0.0, 100.0, 1.0, 1.0, 0.0);
+      scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, scale_data);
+      gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
+
+      g_signal_connect (scale_data, "value-changed",
+                        G_CALLBACK (gimp_double_adjustment_update),
+                        &selopt.feather_radius);
+      g_signal_connect (scale_data, "value-changed",
+                        G_CALLBACK (gfig_paint_delayed),
+                        NULL);
+      gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
+                                 _("Radius:"), 0.0, 1.0, scale, 1, FALSE);
+
+      gtk_widget_show (dialog);
+    }
+  else
+    {
+      gtk_window_present (GTK_WINDOW (dialog));
+    }
+}
+
+static void
+gfig_grid_action_callback (GtkAction *action,
+                           gpointer   data)
+{
+  static GtkWidget *dialog = NULL;
+
+  if (!dialog)
+    {
+      GtkWidget *main_vbox;
+      GtkWidget *hbox;
+      GtkWidget *table;
+      GtkWidget *combo;
+      GtkObject *size_data;
+      GtkObject *sectors_data;
+      GtkObject *radius_data;
+
+      dialog = gimp_dialog_new (_("Grid"), "gimp-gfig-grid",
+                                GTK_WIDGET (data), 0, NULL, NULL,
+
+                                _("_Close"),  GTK_RESPONSE_CLOSE,
+
+                                NULL);
+
+      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
+
+      g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer) &dialog);
+
+      g_signal_connect (dialog, "response",
+                        G_CALLBACK (gtk_widget_destroy),
+                        NULL);
+
+      main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+      gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
+      gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+                          main_vbox, TRUE, TRUE, 0);
+      gtk_widget_show (main_vbox);
+
+      hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+      gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
+      gtk_widget_show (hbox);
+
+      table = gtk_table_new (3, 3, FALSE);
+      gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+      gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+      gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
+      gtk_widget_show (table);
+
+      size_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
+                                        _("Grid spacing:"), 100, 50,
+                                        selvals.opts.gridspacing,
+                                        MIN_GRID, MAX_GRID, 1, 10, 0,
+                                        TRUE, 0, 0,
+                                        NULL, NULL);
+      g_signal_connect (size_data, "value-changed",
+                        G_CALLBACK (gimp_int_adjustment_update),
+                        &selvals.opts.gridspacing);
+      g_signal_connect (size_data, "value-changed",
+                        G_CALLBACK (draw_grid_clear),
+                        NULL);
+
+      gfig_opt_widget.gridspacing = GTK_ADJUSTMENT (size_data);
+      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.gridspacing),
+                                 (gpointer) &gfig_opt_widget.gridspacing);
+
+      sectors_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 3,
+                                        _("Polar grid sectors desired:"), 1, 5,
+                                        selvals.opts.grid_sectors_desired,
+                                        5, 360, 5, 1, 0,
+                                        TRUE, 0, 0,
+                                        NULL, NULL);
+      g_signal_connect (sectors_data, "value-changed",
+                        G_CALLBACK (gimp_int_adjustment_update),
+                        &selvals.opts.grid_sectors_desired);
+      g_signal_connect (sectors_data, "value-changed",
+                        G_CALLBACK (draw_grid_clear),
+                        NULL);
+
+      gfig_opt_widget.grid_sectors_desired = GTK_ADJUSTMENT (sectors_data);
+      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.grid_sectors_desired),
+                                 (gpointer) &gfig_opt_widget.grid_sectors_desired);
+
+
+      gfig_opt_widget.gridspacing = GTK_ADJUSTMENT (size_data);
+      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.gridspacing),
+                                 (gpointer) &gfig_opt_widget.gridspacing);
+
+      radius_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 4,
+                                        _("Polar grid radius interval:"), 1, 5,
+                                        selvals.opts.grid_radius_interval,
+                                        5, 50, 5, 1, 0,
+                                        TRUE, 0, 0,
+                                        NULL, NULL);
+      g_signal_connect (radius_data, "value-changed",
+                        G_CALLBACK (gimp_double_adjustment_update),
+                        &selvals.opts.grid_radius_interval);
+      g_signal_connect (radius_data, "value-changed",
+                        G_CALLBACK (draw_grid_clear),
+                        NULL);
+
+      gfig_opt_widget.grid_radius_interval = GTK_ADJUSTMENT (radius_data);
+      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.grid_radius_interval),
+                                 (gpointer) &gfig_opt_widget.grid_radius_interval);
+
+      combo = gimp_int_combo_box_new (_("Rectangle"), RECT_GRID,
+                                      _("Polar"),     POLAR_GRID,
+                                      _("Isometric"), ISO_GRID,
+                                      NULL);
+      gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), selvals.opts.gridtype);
+
+      g_signal_connect (combo, "changed",
+                        G_CALLBACK (gridtype_combo_callback),
+                        GINT_TO_POINTER (GRID_TYPE_MENU));
+
+      gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
+                                 _("Grid type:"), 0.0, 0.5,
+                                 combo, 2, FALSE);
+
+      gfig_opt_widget.gridtypemenu = combo;
+      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.gridtypemenu),
+                                 (gpointer) &gfig_opt_widget.gridtypemenu);
+
+      combo = gimp_int_combo_box_new (_("Normal"),    GFIG_NORMAL_GC,
+                                      _("Black"),     GFIG_BLACK_GC,
+                                      _("White"),     GFIG_WHITE_GC,
+                                      _("Grey"),      GFIG_GREY_GC,
+                                      _("Darker"),    GFIG_DARKER_GC,
+                                      _("Lighter"),   GFIG_LIGHTER_GC,
+                                      _("Very dark"), GFIG_VERY_DARK_GC,
+                                      NULL);
+      gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), grid_gc_type);
+
+      g_signal_connect (combo, "changed",
+                        G_CALLBACK (gridtype_combo_callback),
+                        GINT_TO_POINTER (GRID_RENDER_MENU));
+
+      gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
+                                 _("Grid color:"), 0.0, 0.5,
+                                 combo, 2, FALSE);
+
+      gtk_widget_show (dialog);
+    }
+  else
+    {
+      gtk_window_present (GTK_WINDOW (dialog));
+    }
+}
+
+void
+options_update (GFigObj *old_obj)
+{
+  /* Save old vals */
+  if (selvals.opts.gridspacing != old_obj->opts.gridspacing)
+    {
+      old_obj->opts.gridspacing = selvals.opts.gridspacing;
+    }
+  if (selvals.opts.grid_sectors_desired != old_obj->opts.grid_sectors_desired)
+    {
+      old_obj->opts.grid_sectors_desired = selvals.opts.grid_sectors_desired;
+    }
+  if (selvals.opts.grid_radius_interval != old_obj->opts.grid_radius_interval)
+    {
+      old_obj->opts.grid_radius_interval = selvals.opts.grid_radius_interval;
+    }
+  if (selvals.opts.gridtype != old_obj->opts.gridtype)
+    {
+      old_obj->opts.gridtype = selvals.opts.gridtype;
+    }
+  if (selvals.opts.drawgrid != old_obj->opts.drawgrid)
+    {
+      old_obj->opts.drawgrid = selvals.opts.drawgrid;
+    }
+  if (selvals.opts.snap2grid != old_obj->opts.snap2grid)
+    {
+      old_obj->opts.snap2grid = selvals.opts.snap2grid;
+    }
+  if (selvals.opts.lockongrid != old_obj->opts.lockongrid)
+    {
+      old_obj->opts.lockongrid = selvals.opts.lockongrid;
+    }
+  if (selvals.opts.showcontrol != old_obj->opts.showcontrol)
+    {
+      old_obj->opts.showcontrol = selvals.opts.showcontrol;
+    }
+
+  /* New vals */
+  if (selvals.opts.gridspacing != gfig_context->current_obj->opts.gridspacing)
+    {
+      if (gfig_opt_widget.gridspacing)
+        gtk_adjustment_set_value (gfig_opt_widget.gridspacing,
+                                  gfig_context->current_obj->opts.gridspacing);
+    }
+  if (selvals.opts.grid_sectors_desired != gfig_context->current_obj->opts.grid_sectors_desired)
+    {
+      if (gfig_opt_widget.grid_sectors_desired)
+        gtk_adjustment_set_value (gfig_opt_widget.grid_sectors_desired,
+                                  gfig_context->current_obj->opts.grid_sectors_desired);
+    }
+  if (selvals.opts.grid_radius_interval != gfig_context->current_obj->opts.grid_radius_interval)
+    {
+      if (gfig_opt_widget.grid_radius_interval)
+        gtk_adjustment_set_value (gfig_opt_widget.grid_radius_interval,
+                                  gfig_context->current_obj->opts.grid_radius_interval);
+    }
+  if (selvals.opts.gridtype != gfig_context->current_obj->opts.gridtype)
+    {
+      if (gfig_opt_widget.gridtypemenu)
+        gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (gfig_opt_widget.gridtypemenu),
+                                       gfig_context->current_obj->opts.gridtype);
+    }
+  if (selvals.opts.drawgrid != gfig_context->current_obj->opts.drawgrid)
+    {
+      if (gfig_opt_widget.drawgrid)
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gfig_opt_widget.drawgrid),
+                                      gfig_context->current_obj->opts.drawgrid);
+    }
+  if (selvals.opts.snap2grid != gfig_context->current_obj->opts.snap2grid)
+    {
+      if (gfig_opt_widget.snap2grid)
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gfig_opt_widget.snap2grid),
+                                      gfig_context->current_obj->opts.snap2grid);
+    }
+  if (selvals.opts.lockongrid != gfig_context->current_obj->opts.lockongrid)
+    {
+      if (gfig_opt_widget.lockongrid)
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gfig_opt_widget.lockongrid),
+                                      gfig_context->current_obj->opts.lockongrid);
+    }
+  if (selvals.opts.showcontrol != gfig_context->current_obj->opts.showcontrol)
+    {
+      if (gfig_opt_widget.showcontrol)
+        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gfig_opt_widget.showcontrol),
+                                      gfig_context->current_obj->opts.showcontrol);
+    }
+}
+
+static void
+save_file_chooser_response (GtkFileChooser *chooser,
+                            gint            response_id,
+                            GFigObj        *obj)
+{
+  if (response_id == GTK_RESPONSE_OK)
+    {
+      gchar   *filename;
+
+      filename = gtk_file_chooser_get_filename (chooser);
+
+      obj->filename = filename;
+
+      gfig_context->current_obj = obj;
+      gfig_save_callbk ();
+    }
+
+  gtk_widget_destroy (GTK_WIDGET (chooser));
+}
+
+static GfigObject *
+gfig_select_obj_by_number (gint count)
+{
+  GList      *objs;
+  GfigObject *object = NULL;
+  gint        k;
+
+  gfig_context->selected_obj = NULL;
+
+  for (objs = gfig_context->current_obj->obj_list, k = 0;
+       objs;
+       objs = g_list_next (objs), k++)
+    {
+      if (k == obj_show_single)
+        {
+          object = objs->data;
+          gfig_context->selected_obj = object;
+          gfig_style_set_context_from_style (&object->style);
+          break;
+        }
+    }
+
+  return object;
+}
+
+static void
+select_button_clicked (gint type)
+{
+  gint   count = 0;
+
+  if (gfig_context->current_obj)
+    {
+      count = g_list_length (gfig_context->current_obj->obj_list);
+    }
+
+  switch (type)
+    {
+    case OBJ_SELECT_LT:
+      obj_show_single--;
+      if (obj_show_single < 0)
+        obj_show_single = count - 1;
+      break;
+
+    case OBJ_SELECT_GT:
+      obj_show_single++;
+      if (obj_show_single >= count)
+        obj_show_single = 0;
+      break;
+
+    case OBJ_SELECT_EQ:
+      obj_show_single = -1; /* Reset to show all */
+      break;
+
+    default:
+      break;
+    }
+
+  if (obj_show_single >= 0)
+    gfig_select_obj_by_number (obj_show_single);
+
+  draw_grid_clear ();
+  gfig_paint_callback ();
+}
+
+static void
+select_button_clicked_lt (void)
+{
+  select_button_clicked (OBJ_SELECT_LT);
+}
+
+static void
+select_button_clicked_gt (void)
+{
+  select_button_clicked (OBJ_SELECT_GT);
+}
+
+static void
+select_button_clicked_eq (void)
+{
+  select_button_clicked (OBJ_SELECT_EQ);
+}
+
+/* Special case for now - options on poly/star/spiral button */
+
+GtkWidget *
+num_sides_widget (const gchar *d_title,
+                  gint        *num_sides,
+                  gint        *which_way,
+                  gint         adj_min,
+                  gint         adj_max)
+{
+  GtkWidget *table;
+  GtkObject *size_data;
+
+  table = gtk_table_new (which_way ? 2 : 1, 3, FALSE);
+  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
+  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
+  gtk_container_set_border_width (GTK_CONTAINER (table), 12);
+  gtk_widget_show (table);
+
+  size_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
+                                    _("Sides:"), 0, 0,
+                                    *num_sides, adj_min, adj_max, 1, 10, 0,
+                                    TRUE, 0, 0,
+                                    NULL, NULL);
+  g_signal_connect (size_data, "value-changed",
+                    G_CALLBACK (gimp_int_adjustment_update),
+                    num_sides);
+
+  if (which_way)
+    {
+      GtkWidget *combo = gimp_int_combo_box_new (_("Right"),      0,
+                                                 _("Left"), 1,
+                                                 NULL);
+
+      gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), *which_way);
+
+      g_signal_connect (combo, "changed",
+                        G_CALLBACK (gimp_int_combo_box_get_active),
+                        which_way);
+
+      gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
+                                 _("Orientation:"), 0.0, 0.5,
+                                 combo, 1, FALSE);
+    }
+  return table;
+}
+
+void
+gfig_paint (BrushType brush_type,
+            gint32    drawable_ID,
+            gint      seg_count,
+            gdouble   line_pnts[])
+{
+  switch (brush_type)
+    {
+    case BRUSH_BRUSH_TYPE:
+      gimp_paintbrush (drawable_ID,
+                       selvals.brushfade,
+                       seg_count, line_pnts,
+                       GIMP_PAINT_CONSTANT,
+                       selvals.brushgradient);
+      break;
+
+    case BRUSH_PENCIL_TYPE:
+      gimp_pencil (drawable_ID,
+                   seg_count, line_pnts);
+      break;
+
+    case BRUSH_AIRBRUSH_TYPE:
+      gimp_airbrush (drawable_ID,
+                     selvals.airbrushpressure,
+                     seg_count, line_pnts);
+      break;
+
+    case BRUSH_PATTERN_TYPE:
+      gimp_clone (drawable_ID,
+                  drawable_ID,
+                  GIMP_CLONE_PATTERN,
+                  0.0, 0.0,
+                  seg_count, line_pnts);
+      break;
+    }
+}
+
+
+static void
+paint_combo_callback (GtkWidget *widget,
+                      gpointer   data)
+{
+  gint mtype = GPOINTER_TO_INT (data);
+  gint value;
+
+  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value);
+
+  switch (mtype)
+    {
+    case PAINT_BGS_MENU:
+      selvals.onlayerbg = (LayersBGType) value;
+      break;
+
+    default:
+      g_return_if_reached ();
+      break;
+    }
+
+  gfig_paint_callback ();
+}
+
+
+static void
+gridtype_combo_callback (GtkWidget *widget,
+                         gpointer   data)
+{
+  gint mtype = GPOINTER_TO_INT (data);
+  gint value;
+
+  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value);
+
+  switch (mtype)
+    {
+    case GRID_TYPE_MENU:
+      selvals.opts.gridtype = value;
+      break;
+
+    case GRID_RENDER_MENU:
+      grid_gc_type = value;
+      break;
+
+    default:
+      g_return_if_reached ();
+      break;
+    }
+
+  draw_grid_clear ();
+}
+
+/*
+ *  The edit gfig name attributes dialog
+ *  Modified from Gimp source - layer edit.
+ */
+
+typedef struct _GfigListOptions
+{
+  GtkWidget *query_box;
+  GtkWidget *name_entry;
+  GtkWidget *list_entry;
+  GFigObj   *obj;
+  gboolean   created;
+} GfigListOptions;
+
+static void
+load_file_chooser_response (GtkFileChooser *chooser,
+                            gint            response_id,
+                            gpointer        data)
+{
+  if (response_id == GTK_RESPONSE_OK)
+    {
+      gchar   *filename;
+      GFigObj *gfig;
+      GFigObj *current_saved;
+
+      filename = gtk_file_chooser_get_filename (chooser);
+
+      if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
+        {
+          /* Hack - current object MUST be NULL to prevent setup_undo ()
+           * from kicking in.
+           */
+          current_saved = gfig_context->current_obj;
+          gfig_context->current_obj = NULL;
+          gfig = gfig_load (filename, filename);
+          gfig_context->current_obj = current_saved;
+
+          if (gfig)
+            {
+              /* Read only ?*/
+              if (access (filename, W_OK))
+                gfig->obj_status |= GFIG_READONLY;
+
+              gfig_list_insert (gfig);
+              new_obj_2edit (gfig);
+            }
+        }
+
+      g_free (filename);
+    }
+
+  gtk_widget_destroy (GTK_WIDGET (chooser));
+  gfig_paint_callback ();
+}
+
+void
+paint_layer_fill (gdouble x1, gdouble y1, gdouble x2, gdouble y2)
+{
+  GimpFillType fill_type = GIMP_FILL_FOREGROUND;
+  Style *current_style;
+
+  current_style = gfig_context_get_current_style ();
+
+  gimp_context_push ();
+
+  gimp_context_set_paint_mode (GIMP_LAYER_MODE_NORMAL_LEGACY);
+  gimp_context_set_opacity (100.0);
+  gimp_context_set_gradient_repeat_mode (GIMP_REPEAT_NONE);
+  gimp_context_set_gradient_reverse (FALSE);
+
+  switch (current_style->fill_type)
+    {
+    case FILL_NONE:
+      return;
+
+    case FILL_COLOR:
+      fill_type = GIMP_FILL_BACKGROUND;
+      break;
+
+    case FILL_PATTERN:
+      fill_type = GIMP_FILL_PATTERN;
+      break;
+
+    case FILL_GRADIENT:
+      gimp_drawable_edit_gradient_fill (gfig_context->drawable_id,
+                                        GIMP_GRADIENT_SHAPEBURST_DIMPLED,
+                                        0.0,       /* offset             */
+                                        FALSE,     /* supersampling      */
+                                        0,         /* max_depth          */
+                                        0.0,       /* threshold          */
+                                        FALSE,     /* dither             */
+                                        0.0, 0.0,  /* (x1, y1) - ignored */
+                                        0.0, 0.0); /* (x2, y2) - ignored */
+      return;
+    case FILL_VERTICAL:
+      gimp_drawable_edit_gradient_fill (gfig_context->drawable_id,
+                                        GIMP_GRADIENT_LINEAR,
+                                        0.0,
+                                        FALSE,
+                                        0,
+                                        0.0,
+                                        FALSE,
+                                        x1, y1,
+                                        x1, y2);
+      return;
+    case FILL_HORIZONTAL:
+      gimp_drawable_edit_gradient_fill (gfig_context->drawable_id,
+                                        GIMP_GRADIENT_LINEAR,
+                                        0.0,
+                                        FALSE,
+                                        0,
+                                        0.0,
+                                        FALSE,
+                                        x1, y1,
+                                        x2, y1);
+      return;
+    }
+
+  gimp_context_set_opacity (current_style->fill_opacity);
+
+  gimp_drawable_edit_fill (gfig_context->drawable_id,
+                           fill_type);
+
+  gimp_context_pop ();
+}
+
+void
+gfig_paint_callback (void)
+{
+  GList      *objs;
+  gint        ccount = 0;
+  GfigObject *object;
+
+  if (!gfig_context->enable_repaint || !gfig_context->current_obj)
+    return;
+
+  objs = gfig_context->current_obj->obj_list;
+
+  gimp_drawable_fill (gfig_context->drawable_id, GIMP_FILL_TRANSPARENT);
+
+  while (objs)
+    {
+      if (ccount == obj_show_single || obj_show_single == -1)
+        {
+          FillType saved_filltype;
+
+          object = objs->data;
+
+          gfig_style_apply (&object->style);
+
+          saved_filltype = gfig_context_get_current_style ()->fill_type;
+          gfig_context_get_current_style ()->fill_type = object->style.fill_type;
+          object->class->paintfunc (object);
+          gfig_context_get_current_style ()->fill_type = saved_filltype;
+        }
+
+      objs = g_list_next (objs);
+
+      ccount++;
+    }
+
+  gimp_displays_flush ();
+
+  if (back_pixbuf)
+    {
+      g_object_unref (back_pixbuf);
+      back_pixbuf = NULL;
+    }
+
+  gtk_widget_queue_draw (gfig_context->preview);
+}
+
+/* Draw the grid on the screen
+ */
+
+void
+draw_grid_clear (void)
+{
+  /* wipe slate and start again */
+  gtk_widget_queue_draw (gfig_context->preview);
+}
+
+static void
+toggle_show_image (void)
+{
+  /* wipe slate and start again */
+  draw_grid_clear ();
+}
+
+static void
+toggle_obj_type (GtkRadioAction *action,
+                 GtkRadioAction *current,
+                 gpointer        data)
+{
+  static GdkCursor *p_cursors[DEL_OBJ + 1];
+  GdkCursorType     ctype = GDK_LAST_CURSOR;
+  DobjType          new_type;
+
+  new_type = gtk_radio_action_get_current_value (action);
+  if (selvals.otype != new_type)
+    {
+      /* Mem leak */
+      obj_creating = NULL;
+      tmp_line = NULL;
+      tmp_bezier = NULL;
+
+      if (new_type < MOVE_OBJ) /* Eeeeek */
+        {
+          obj_show_single = -1; /* Cancel select preview */
+        }
+      /* Update draw areas */
+      gtk_widget_queue_draw (gfig_context->preview);
+    }
+
+  selvals.otype = new_type;
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (tool_options_notebook),
+                                 new_type - 1);
+
+  switch (selvals.otype)
+    {
+    case LINE:
+    case RECTANGLE:
+    case CIRCLE:
+    case ELLIPSE:
+    case ARC:
+    case POLY:
+    case STAR:
+    case SPIRAL:
+    case BEZIER:
+    default:
+      ctype = GDK_CROSSHAIR;
+      break;
+    case MOVE_OBJ:
+    case MOVE_POINT:
+    case COPY_OBJ:
+    case MOVE_COPY_OBJ:
+      ctype = GDK_DIAMOND_CROSS;
+      break;
+    case DEL_OBJ:
+      ctype = GDK_PIRATE;
+      break;
+    }
+
+  if (!p_cursors[selvals.otype])
+    {
+      GdkDisplay *display = gtk_widget_get_display (gfig_context->preview);
+
+      p_cursors[selvals.otype] = gdk_cursor_new_for_display (display, ctype);
+    }
+
+  gdk_window_set_cursor (gtk_widget_get_window (gfig_context->preview),
+                         p_cursors[selvals.otype]);
+}
+
+/* This could belong in a separate file ... but makes it easier to lump into
+ * one when compiling the plugin.
+ */
+
+/* Given a number of float co-ords adjust for scaling back to org size */
+/* Size is number of PAIRS of points */
+/* FP + int variants */
+
+static void
+scale_to_orginal_x (gdouble *list)
+{
+  *list *= scale_x_factor;
+}
+
+gint
+gfig_scale_x (gint x)
+{
+  if (!selvals.scaletoimage)
+    return (gint) (x * (1 / scale_x_factor));
+  else
+    return x;
+}
+
+static void
+scale_to_orginal_y (gdouble *list)
+{
+  *list *= scale_y_factor;
+}
+
+gint
+gfig_scale_y (gint y)
+{
+  if (!selvals.scaletoimage)
+    return (gint) (y * (1 / scale_y_factor));
+  else
+    return y;
+}
+
+/* Pairs x followed by y */
+void
+scale_to_original_xy (gdouble *list,
+                      gint     size)
+{
+  gint i;
+
+  for (i = 0; i < size * 2; i += 2)
+    {
+      scale_to_orginal_x (&list[i]);
+      scale_to_orginal_y (&list[i + 1]);
+    }
+}
+
+/* Pairs x followed by y */
+void
+scale_to_xy (gdouble *list,
+             gint     size)
+{
+  gint i;
+
+  for (i = 0; i < size * 2; i += 2)
+    {
+      list[i] *= (org_scale_x_factor / scale_x_factor);
+      list[i + 1] *= (org_scale_y_factor / scale_y_factor);
+    }
+}
+
+void
+gfig_draw_arc (gint x, gint y, gint width, gint height, gint angle1,
+               gint angle2, cairo_t *cr)
+{
+  cairo_save (cr);
+
+  cairo_translate (cr, gfig_scale_x (x), gfig_scale_y (y));
+  cairo_scale (cr, gfig_scale_x (width), gfig_scale_y (height));
+
+  if (angle1 < angle2)
+    cairo_arc (cr, 0., 0., 1., angle1 * G_PI / 180, angle2 * G_PI / 180);
+  else
+    cairo_arc_negative (cr, 0., 0., 1., angle1 * G_PI / 180, angle2 * G_PI / 180);
+
+  cairo_restore (cr);
+
+  draw_item (cr, FALSE);
+}
+
+void
+gfig_draw_line (gint x0, gint y0, gint x1, gint y1, cairo_t *cr)
+{
+  cairo_move_to (cr, gfig_scale_x (x0) + .5, gfig_scale_y (y0) + .5);
+  cairo_line_to (cr, gfig_scale_x (x1) + .5, gfig_scale_y (y1) + .5);
+
+  draw_item (cr, FALSE);
+}