summaryrefslogtreecommitdiffstats
path: root/plug-ins/gfig/gfig-dialog.c
diff options
context:
space:
mode:
Diffstat (limited to 'plug-ins/gfig/gfig-dialog.c')
-rw-r--r--plug-ins/gfig/gfig-dialog.c2193
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);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-21 11:19:18 +0000