← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to plug-ins/gfig/gfig-dialog.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/gfig/gfig-dialog.c
24
24
 
25
25
#include "config.h"
26
26
 
27
 
#include <stdio.h>
28
27
#include <stdlib.h>
 
28
#include <string.h>
29
29
#include <errno.h>
30
30
 
31
31
#ifdef HAVE_UNISTD_H
32
32
#include <unistd.h>
33
33
#endif
34
34
 
35
 
#include <string.h>
36
 
 
37
 
#include <gtk/gtk.h>
 
35
#include <glib.h>
38
36
 
39
37
#ifdef G_OS_WIN32
40
38
#include <libgimpbase/gimpwin32-io.h>
57
55
#include "gfig-line.h"
58
56
#include "gfig-poly.h"
59
57
#include "gfig-preview.h"
 
58
#include "gfig-rectangle.h"
60
59
#include "gfig-spiral.h"
61
60
#include "gfig-star.h"
62
61
#include "gfig-stock.h"
63
62
 
64
 
#define BRUSH_PREVIEW_SZ 32
65
 
#define SEL_BUTTON_WIDTH 100
66
 
#define SEL_BUTTON_HEIGHT 20
67
 
 
68
 
#define PREVIEW_MASK  (GDK_EXPOSURE_MASK       | \
69
 
                       GDK_POINTER_MOTION_MASK | \
70
 
                       GDK_BUTTON_PRESS_MASK   | \
71
 
                       GDK_BUTTON_RELEASE_MASK | \
72
 
                       GDK_BUTTON_MOTION_MASK  | \
73
 
                       GDK_KEY_PRESS_MASK      | \
74
 
                       GDK_KEY_RELEASE_MASK)
75
 
 
76
 
#define GRID_TYPE_MENU   1
77
 
#define GRID_RENDER_MENU 2
78
 
#define GRID_IGNORE      0
79
 
#define GRID_HIGHTLIGHT  1
80
 
#define GRID_RESTORE     2
81
 
 
82
 
#define PAINT_LAYERS_MENU 1
83
 
#define PAINT_BGS_MENU    2
84
 
#define PAINT_TYPE_MENU   3
85
 
 
86
 
#define SELECT_TYPE_MENU      1
87
 
#define SELECT_ARCTYPE_MENU   2
88
 
#define SELECT_TYPE_MENU_FILL 3
89
 
#define SELECT_TYPE_MENU_WHEN 4
90
 
 
91
 
#define OBJ_SELECT_GT 1
92
 
#define OBJ_SELECT_LT 2
93
 
#define OBJ_SELECT_EQ 4
 
63
#define SEL_BUTTON_WIDTH  100
 
64
#define SEL_BUTTON_HEIGHT  20
 
65
 
 
66
#define GRID_TYPE_MENU      1
 
67
#define GRID_RENDER_MENU    2
 
68
 
 
69
#define PAINT_BGS_MENU      2
 
70
#define PAINT_TYPE_MENU     3
 
71
 
 
72
#define OBJ_SELECT_GT       1
 
73
#define OBJ_SELECT_LT       2
 
74
#define OBJ_SELECT_EQ       4
 
75
 
 
76
/* Globals */
 
77
gint   undo_level;  /* Last slot filled in -1 = no undo */
 
78
GList *undo_table[MAX_UNDO];
94
79
 
95
80
/* Values when first invoked */
96
81
SelectItVals selvals =
101
86
    FALSE,                /* drawgrid                      */
102
87
    FALSE,                /* snap2grid                     */
103
88
    FALSE,                /* lockongrid                    */
104
 
    TRUE                  /* show control points           */
 
89
    TRUE,                 /* show control points           */
 
90
    0.0,                  /* grid_radius_min               */
 
91
    10.0,                 /* grid_radius_interval          */
 
92
    0.0,                  /* grid_rotation                 */
 
93
    5.0,                  /* grid_granularity              */
 
94
    120                   /* grid_sectors_desired          */
105
95
  },
106
96
  FALSE,                  /* show image                    */
107
97
  MIN_UNDO + (MAX_UNDO - MIN_UNDO)/2,  /* Max level of undos */
134
124
typedef struct
135
125
{
136
126
  GtkAdjustment *gridspacing;
 
127
  GtkAdjustment *grid_sectors_desired;
 
128
  GtkAdjustment *grid_radius_interval;
137
129
  GtkWidget     *gridtypemenu;
138
130
  GtkWidget     *drawgrid;
139
131
  GtkWidget     *snap2grid;
160
152
static void       gfig_list_load_all         (const gchar *path);
161
153
static void       gfig_list_free_all         (void);
162
154
static void       create_notebook_pages      (GtkWidget *notebook);
163
 
static void       select_combo_callback      (GtkWidget *widget,
164
 
                                              gpointer   data);
 
155
static void       select_filltype_callback   (GtkWidget *widget);
165
156
static void       gfig_grid_action_callback  (GtkAction *action,
166
157
                                              gpointer   data);
167
158
static void       gfig_prefs_action_callback (GtkAction *action,
221
212
  GtkWidget    *hbox;
222
213
  GtkUIManager *ui_manager;
223
214
  GtkWidget    *empty_label;
 
215
  gchar        *path;
224
216
 
225
 
  gimp_ui_init ("gfig", TRUE);
 
217
  gimp_ui_init (PLUG_IN_BINARY, TRUE);
226
218
 
227
219
  img_width  = gimp_drawable_width (gfig_context->drawable_id);
228
220
  img_height = gimp_drawable_height (gfig_context->drawable_id);
252
244
    }
253
245
  else
254
246
    {
255
 
      newlayer = gimp_layer_new (gfig_context->image_id, "GFig", img_width, img_height,
256
 
                                 GIMP_RGBA_IMAGE, 100., GIMP_NORMAL_MODE);
 
247
      newlayer = gimp_layer_new (gfig_context->image_id, "GFig",
 
248
                                 img_width, img_height,
 
249
                                 GIMP_RGBA_IMAGE, 100.0, GIMP_NORMAL_MODE);
257
250
      gimp_drawable_fill (newlayer, GIMP_TRANSPARENT_FILL);
258
251
      gimp_image_add_layer (gfig_context->image_id, newlayer, -1);
259
252
      gfig_context->drawable_id = newlayer;
264
257
 
265
258
  gfig_stock_init ();
266
259
 
267
 
  gfig_path = gimp_gimprc_query ("gfig-path");
268
 
 
269
 
  if (! gfig_path)
270
 
    {
271
 
      gchar *gimprc = gimp_personal_rc_file ("gimprc");
272
 
      gchar *full_path;
273
 
      gchar *esc_path;
274
 
 
275
 
      full_path =
276
 
        g_strconcat ("${gimp_dir}", G_DIR_SEPARATOR_S, "gfig",
277
 
                     G_SEARCHPATH_SEPARATOR_S,
278
 
                     "${gimp_data_dir}", G_DIR_SEPARATOR_S, "gfig",
279
 
                     NULL);
280
 
      esc_path = g_strescape (full_path, NULL);
 
260
  path = gimp_gimprc_query ("gfig-path");
 
261
 
 
262
  if (path)
 
263
    {
 
264
      gfig_path = g_filename_from_utf8 (path, -1, NULL, NULL, NULL);
 
265
      g_free (path);
 
266
    }
 
267
  else
 
268
    {
 
269
      gchar *gimprc    = gimp_personal_rc_file ("gimprc");
 
270
      gchar *full_path = gimp_config_build_data_path ("gfig");
 
271
      gchar *esc_path  = g_strescape (full_path, NULL);
281
272
      g_free (full_path);
282
273
 
283
274
      g_message (_("No %s in gimprc:\n"
292
283
    }
293
284
 
294
285
  /* Start building the dialog up */
295
 
  top_level_dlg = gimp_dialog_new (_("Gfig"), "gfig",
 
286
  top_level_dlg = gimp_dialog_new (_("Gfig"), PLUG_IN_BINARY,
296
287
                                   NULL, 0,
297
 
                                   gimp_standard_help_func, HELP_ID,
 
288
                                   gimp_standard_help_func, PLUG_IN_PROC,
298
289
 
299
290
                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
300
291
                                   GTK_STOCK_CLOSE,  GTK_RESPONSE_OK,
301
292
 
302
293
                                   NULL);
303
294
 
 
295
  gtk_dialog_set_alternative_button_order (GTK_DIALOG (top_level_dlg),
 
296
                                           GTK_RESPONSE_OK,
 
297
                                           GTK_RESPONSE_CANCEL,
 
298
                                           -1);
 
299
 
304
300
  g_signal_connect (top_level_dlg, "response",
305
301
                    G_CALLBACK (gfig_response),
306
302
                    top_level_dlg);
338
334
  gtk_widget_show (right_vbox);
339
335
 
340
336
  /* Tool options notebook */
341
 
  frame = gimp_frame_new ( _("Tool options"));
 
337
  frame = gimp_frame_new ( _("Tool Options"));
342
338
  gtk_box_pack_start (GTK_BOX (right_vbox), frame, FALSE, FALSE, 0);
343
339
  gtk_widget_show (frame);
344
340
 
375
371
                    vbox);
376
372
 
377
373
  /* foreground color button in Stroke frame*/
378
 
  gfig_context->fg_color = g_new (GimpRGB, 1);
 
374
  gfig_context->fg_color = g_new0 (GimpRGB, 1);
379
375
  gfig_context->fg_color_button = gimp_color_button_new ("Foreground",
380
376
                                                    SEL_BUTTON_WIDTH,
381
377
                                                    SEL_BUTTON_HEIGHT,
392
388
 
393
389
  /* brush selector in Stroke frame */
394
390
  gfig_context->brush_select
395
 
    = gimp_brush_select_widget_new ("Brush",
 
391
    = gimp_brush_select_button_new ("Brush",
396
392
                                    gfig_context->default_style.brush_name,
397
 
                                    -1, -1, -1,
398
 
                                    gfig_brush_changed_callback,
399
 
                                    NULL);
 
393
                                    -1.0, -1, -1);
 
394
  g_signal_connect (gfig_context->brush_select, "brush-set",
 
395
                    G_CALLBACK (gfig_brush_changed_callback), NULL);
400
396
  gtk_box_pack_start (GTK_BOX (vbox), gfig_context->brush_select,
401
397
                      FALSE, FALSE, 0);
402
398
  gtk_widget_show (gfig_context->brush_select);
416
412
 
417
413
  /* fill style combo box in Style frame  */
418
414
  gfig_context->fillstyle_combo = combo
419
 
    = gimp_int_combo_box_new (_("No fill"),       FILL_NONE,
420
 
                              _("Color fill"),    FILL_COLOR,
421
 
                              _("Pattern fill"),  FILL_PATTERN,
422
 
                              _("Gradient fill"), FILL_GRADIENT,
 
415
    = gimp_int_combo_box_new (_("No fill"),             FILL_NONE,
 
416
                              _("Color fill"),          FILL_COLOR,
 
417
                              _("Pattern fill"),        FILL_PATTERN,
 
418
                              _("Shape gradient"),      FILL_GRADIENT,
 
419
                              _("Vertical gradient"),   FILL_VERTICAL,
 
420
                              _("Horizontal gradient"), FILL_HORIZONTAL,
423
421
                              NULL);
424
422
  gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), 0);
425
423
  g_signal_connect (combo, "changed",
426
 
                    G_CALLBACK (select_combo_callback),
427
 
                    GINT_TO_POINTER (SELECT_TYPE_MENU_FILL));
 
424
                    G_CALLBACK (select_filltype_callback),
 
425
                    NULL);
428
426
  gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0);
429
427
  gtk_widget_show (combo);
430
428
 
441
439
                            empty_label, NULL);
442
440
 
443
441
  /* A page for the fill color button */
444
 
  gfig_context->bg_color = g_new (GimpRGB, 1);
 
442
  gfig_context->bg_color = g_new0 (GimpRGB, 1);
445
443
  gfig_context->bg_color_button = gimp_color_button_new ("Background",
446
444
                                           SEL_BUTTON_WIDTH, SEL_BUTTON_HEIGHT,
447
445
                                           gfig_context->bg_color,
457
455
 
458
456
  /* A page for the pattern selector */
459
457
  gfig_context->pattern_select
460
 
    = gimp_pattern_select_widget_new ("Pattern", gfig_context->default_style.pattern,
461
 
                                      gfig_pattern_changed_callback,
462
 
                                      NULL);
 
458
    = gimp_pattern_select_button_new ("Pattern", gfig_context->default_style.pattern);
 
459
  g_signal_connect (gfig_context->pattern_select, "pattern-set",
 
460
                    G_CALLBACK (gfig_pattern_changed_callback), NULL);
463
461
  gtk_widget_show (gfig_context->pattern_select);
464
462
  gtk_notebook_append_page (GTK_NOTEBOOK (fill_type_notebook),
465
463
                            gfig_context->pattern_select, NULL);
466
464
 
467
465
  /* A page for the gradient selector */
468
466
  gfig_context->gradient_select
469
 
    = gimp_gradient_select_widget_new ("Gradient", gfig_context->default_style.gradient,
470
 
                                       gfig_gradient_changed_callback,
471
 
                                       NULL);
 
467
    = gimp_gradient_select_button_new ("Gradient", gfig_context->default_style.gradient);
 
468
  g_signal_connect (gfig_context->gradient_select, "gradient-set",
 
469
                    G_CALLBACK (gfig_gradient_changed_callback), NULL);
472
470
  gtk_widget_show (gfig_context->gradient_select);
473
471
  gtk_notebook_append_page (GTK_NOTEBOOK (fill_type_notebook),
474
472
                            gfig_context->gradient_select, NULL);
492
490
  gtk_widget_show (toggle);
493
491
 
494
492
  /* "snap to grid" checkbutton at bottom of style frame */
495
 
  toggle = gtk_check_button_new_with_label (_("Snap to grid"));
 
493
  toggle = gtk_check_button_new_with_label (Q_("checkbutton|Snap to grid"));
496
494
  gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
497
495
  g_signal_connect (toggle, "toggled",
498
496
                    G_CALLBACK (gimp_toggle_button_update),
636
634
      gchar *dir;
637
635
 
638
636
      dialog =
639
 
        gtk_file_chooser_dialog_new (_("Load Gfig object collection"),
 
637
        gtk_file_chooser_dialog_new (_("Load Gfig Object Collection"),
640
638
                                     GTK_WINDOW (data),
641
639
                                     GTK_FILE_CHOOSER_ACTION_OPEN,
642
640
 
645
643
 
646
644
                                     NULL);
647
645
 
 
646
      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 
647
                                               GTK_RESPONSE_OK,
 
648
                                               GTK_RESPONSE_CANCEL,
 
649
                                               -1);
 
650
 
648
651
      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
649
652
 
650
653
      g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer) &dialog);
689
692
 
690
693
                                     NULL);
691
694
 
 
695
      gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 
696
                                               GTK_RESPONSE_OK,
 
697
                                               GTK_RESPONSE_CANCEL,
 
698
                                               -1);
 
699
      gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 
700
 
 
701
      gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
 
702
                                                      TRUE);
 
703
 
692
704
      g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer) &dialog);
693
705
 
694
706
      /* FIXME: GFigObj should be a GObject and g_signal_connect_object()
810
822
  gfig_context->current_obj = NULL;
811
823
  gfig_list_free_all ();
812
824
 
813
 
 
814
825
  if (! gfig_list)
815
826
    {
816
827
      GFigObj *gfig;
904
915
    { "line", GFIG_STOCK_LINE,
905
916
      NULL, "L", N_("Create line"), LINE },
906
917
 
 
918
    { "rectangle", GFIG_STOCK_RECTANGLE,
 
919
      NULL, "R", N_("Create rectangle"), RECTANGLE },
 
920
 
907
921
    { "circle", GFIG_STOCK_CIRCLE,
908
922
      NULL, "C", N_("Create circle"), CIRCLE },
909
923
 
987
1001
                                     "<ui>"
988
1002
                                     "  <toolbar name=\"gfig-toolbar\">"
989
1003
                                     "    <toolitem action=\"line\" />"
 
1004
                                     "    <toolitem action=\"rectangle\" />"
990
1005
                                     "    <toolitem action=\"circle\" />"
991
1006
                                     "    <toolitem action=\"ellipse\" />"
992
1007
                                     "    <toolitem action=\"arc\" />"
1029
1044
create_notebook_pages (GtkWidget *notebook)
1030
1045
{
1031
1046
  tool_option_no_option (notebook);   /* Line          */
 
1047
  tool_option_no_option (notebook);   /* Rectangle     */
1032
1048
  tool_option_no_option (notebook);   /* Circle        */
1033
1049
  tool_option_no_option (notebook);   /* Ellipse       */
1034
1050
  tool_option_no_option (notebook);   /* Arc           */
1160
1176
 
1161
1177
 
1162
1178
static void
1163
 
select_combo_callback (GtkWidget *widget,
1164
 
                       gpointer   data)
 
1179
select_filltype_callback (GtkWidget *widget)
1165
1180
{
1166
 
  gint mtype = GPOINTER_TO_INT (data);
1167
1181
  gint value;
1168
1182
 
1169
1183
  gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value);
1170
 
  gtk_notebook_set_current_page (GTK_NOTEBOOK (fill_type_notebook), value);
1171
 
 
1172
 
  switch (mtype)
1173
 
    {
1174
 
    case SELECT_TYPE_MENU:
1175
 
      selopt.type = (SelectionType) value;
1176
 
      break;
1177
 
 
1178
 
    case SELECT_ARCTYPE_MENU:
1179
 
      selopt.as_pie = (ArcType) value;
1180
 
      break;
1181
 
 
1182
 
    case SELECT_TYPE_MENU_FILL:
1183
 
      gfig_context_get_current_style ()->fill_type = (FillType) value;
1184
 
      break;
1185
 
 
1186
 
    default:
1187
 
      g_return_if_reached ();
1188
 
      break;
1189
 
    }
 
1184
  gtk_notebook_set_current_page (GTK_NOTEBOOK (fill_type_notebook),
 
1185
                                 MIN (value, FILL_GRADIENT));
 
1186
 
 
1187
  gfig_context_get_current_style ()->fill_type = (FillType) value;
1190
1188
 
1191
1189
  gfig_paint_callback ();
1192
1190
}
1278
1276
                                        MIN_UNDO, MAX_UNDO, 1, 2, 0,
1279
1277
                                        TRUE, 0, 0,
1280
1278
                                        NULL, NULL);
1281
 
      g_signal_connect (size_data, "value_changed",
 
1279
      g_signal_connect (size_data, "value-changed",
1282
1280
                        G_CALLBACK (gimp_int_adjustment_update),
1283
1281
                        &selvals.maxundo);
1284
1282
 
1321
1319
      gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
1322
1320
      gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
1323
1321
 
1324
 
      g_signal_connect (scale_data, "value_changed",
 
1322
      g_signal_connect (scale_data, "value-changed",
1325
1323
                        G_CALLBACK (gimp_double_adjustment_update),
1326
1324
                        &selopt.feather_radius);
1327
 
      g_signal_connect (scale_data, "value_changed",
 
1325
      g_signal_connect (scale_data, "value-changed",
1328
1326
                        G_CALLBACK (gfig_paint_callback),
1329
1327
                        NULL);
1330
1328
      gimp_table_attach_aligned (GTK_TABLE (table), 0, 2,
1351
1349
      GtkWidget *table;
1352
1350
      GtkWidget *combo;
1353
1351
      GtkObject *size_data;
 
1352
      GtkObject *sectors_data;
 
1353
      GtkObject *radius_data;
1354
1354
 
1355
1355
      dialog = gimp_dialog_new (_("Grid"), "gfig-grid",
1356
1356
                                GTK_WIDGET (data), 0, NULL, NULL,
1388
1388
                                        MIN_GRID, MAX_GRID, 1, 10, 0,
1389
1389
                                        TRUE, 0, 0,
1390
1390
                                        NULL, NULL);
1391
 
      g_signal_connect (size_data, "value_changed",
 
1391
      g_signal_connect (size_data, "value-changed",
1392
1392
                        G_CALLBACK (gimp_int_adjustment_update),
1393
1393
                        &selvals.opts.gridspacing);
1394
 
      g_signal_connect (size_data, "value_changed",
1395
 
                        G_CALLBACK (draw_grid_clear),
1396
 
                        NULL);
1397
 
 
1398
 
      gfig_opt_widget.gridspacing = GTK_ADJUSTMENT (size_data);
1399
 
      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.gridspacing),
1400
 
                                 (gpointer) &gfig_opt_widget.gridspacing);
 
1394
      g_signal_connect (size_data, "value-changed",
 
1395
                        G_CALLBACK (draw_grid_clear),
 
1396
                        NULL);
 
1397
 
 
1398
      gfig_opt_widget.gridspacing = GTK_ADJUSTMENT (size_data);
 
1399
      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.gridspacing),
 
1400
                                 (gpointer) &gfig_opt_widget.gridspacing);
 
1401
 
 
1402
      sectors_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 3,
 
1403
                                        _("Polar grid sectors desired:"), 1, 5,
 
1404
                                        selvals.opts.grid_sectors_desired,
 
1405
                                        5, 360, 5, 1, 0,
 
1406
                                        TRUE, 0, 0,
 
1407
                                        NULL, NULL);
 
1408
      g_signal_connect (sectors_data, "value-changed",
 
1409
                        G_CALLBACK (gimp_int_adjustment_update),
 
1410
                        &selvals.opts.grid_sectors_desired);
 
1411
      g_signal_connect (sectors_data, "value-changed",
 
1412
                        G_CALLBACK (draw_grid_clear),
 
1413
                        NULL);
 
1414
 
 
1415
      gfig_opt_widget.grid_sectors_desired = GTK_ADJUSTMENT (sectors_data);
 
1416
      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.grid_sectors_desired),
 
1417
                                 (gpointer) &gfig_opt_widget.grid_sectors_desired);
 
1418
 
 
1419
 
 
1420
      gfig_opt_widget.gridspacing = GTK_ADJUSTMENT (size_data);
 
1421
      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.gridspacing),
 
1422
                                 (gpointer) &gfig_opt_widget.gridspacing);
 
1423
 
 
1424
      radius_data = gimp_scale_entry_new (GTK_TABLE (table), 0, 4,
 
1425
                                        _("Polar grid radius interval:"), 1, 5,
 
1426
                                        selvals.opts.grid_radius_interval,
 
1427
                                        5, 50, 5, 1, 0,
 
1428
                                        TRUE, 0, 0,
 
1429
                                        NULL, NULL);
 
1430
      g_signal_connect (radius_data, "value-changed",
 
1431
                        G_CALLBACK (gimp_double_adjustment_update),
 
1432
                        &selvals.opts.grid_radius_interval);
 
1433
      g_signal_connect (radius_data, "value-changed",
 
1434
                        G_CALLBACK (draw_grid_clear),
 
1435
                        NULL);
 
1436
 
 
1437
      gfig_opt_widget.grid_radius_interval = GTK_ADJUSTMENT (radius_data);
 
1438
      g_object_add_weak_pointer (G_OBJECT (gfig_opt_widget.grid_radius_interval),
 
1439
                                 (gpointer) &gfig_opt_widget.grid_radius_interval);
1401
1440
 
1402
1441
      combo = gimp_int_combo_box_new (_("Rectangle"), RECT_GRID,
1403
1442
                                      _("Polar"),     POLAR_GRID,
1451
1490
    {
1452
1491
      old_obj->opts.gridspacing = selvals.opts.gridspacing;
1453
1492
    }
 
1493
  if (selvals.opts.grid_sectors_desired != old_obj->opts.grid_sectors_desired)
 
1494
    {
 
1495
      old_obj->opts.grid_sectors_desired = selvals.opts.grid_sectors_desired;
 
1496
    }
 
1497
  if (selvals.opts.grid_radius_interval != old_obj->opts.grid_radius_interval)
 
1498
    {
 
1499
      old_obj->opts.grid_radius_interval = selvals.opts.grid_radius_interval;
 
1500
    }
1454
1501
  if (selvals.opts.gridtype != old_obj->opts.gridtype)
1455
1502
    {
1456
1503
      old_obj->opts.gridtype = selvals.opts.gridtype;
1479
1526
        gtk_adjustment_set_value (gfig_opt_widget.gridspacing,
1480
1527
                                  gfig_context->current_obj->opts.gridspacing);
1481
1528
    }
 
1529
  if (selvals.opts.grid_sectors_desired != gfig_context->current_obj->opts.grid_sectors_desired)
 
1530
    {
 
1531
      if (gfig_opt_widget.grid_sectors_desired)
 
1532
        gtk_adjustment_set_value (gfig_opt_widget.grid_sectors_desired,
 
1533
                                  gfig_context->current_obj->opts.grid_sectors_desired);
 
1534
    }
 
1535
  if (selvals.opts.grid_radius_interval != gfig_context->current_obj->opts.grid_radius_interval)
 
1536
    {
 
1537
      if (gfig_opt_widget.grid_radius_interval)
 
1538
        gtk_adjustment_set_value (gfig_opt_widget.grid_radius_interval,
 
1539
                                  gfig_context->current_obj->opts.grid_radius_interval);
 
1540
    }
1482
1541
  if (selvals.opts.gridtype != gfig_context->current_obj->opts.gridtype)
1483
1542
    {
1484
1543
      if (gfig_opt_widget.gridtypemenu)
1639
1698
                                    *num_sides, adj_min, adj_max, 1, 10, 0,
1640
1699
                                    TRUE, 0, 0,
1641
1700
                                    NULL, NULL);
1642
 
  g_signal_connect (size_data, "value_changed",
 
1701
  g_signal_connect (size_data, "value-changed",
1643
1702
                    G_CALLBACK (gimp_int_adjustment_update),
1644
1703
                    num_sides);
1645
1704
 
1806
1865
}
1807
1866
 
1808
1867
void
1809
 
paint_layer_fill (void)
 
1868
paint_layer_fill (gdouble x1, gdouble y1, gdouble x2, gdouble y2)
1810
1869
{
1811
 
  GimpBucketFillMode fill_mode;
 
1870
  GimpBucketFillMode fill_mode = FILL_NONE;
1812
1871
  Style *current_style;
1813
1872
 
1814
1873
  current_style = gfig_context_get_current_style ();
1842
1901
                       0.0, 0.0,          /* (x1, y1) - ignored */
1843
1902
                       0.0, 0.0);         /* (x2, y2) - ignored */
1844
1903
      return;
1845
 
    default:
 
1904
    case FILL_VERTICAL:
 
1905
      gimp_edit_blend (gfig_context->drawable_id,
 
1906
                       GIMP_CUSTOM_MODE,
 
1907
                       GIMP_NORMAL_MODE,
 
1908
                       GIMP_GRADIENT_LINEAR,
 
1909
                       100.0,
 
1910
                       0.0,
 
1911
                       GIMP_REPEAT_NONE,
 
1912
                       FALSE,
 
1913
                       FALSE,
 
1914
                       0,
 
1915
                       0.0,
 
1916
                       FALSE,
 
1917
                       x1, y1,
 
1918
                       x1, y2);
 
1919
      return;
 
1920
    case FILL_HORIZONTAL:
 
1921
      gimp_edit_blend (gfig_context->drawable_id,
 
1922
                       GIMP_CUSTOM_MODE,
 
1923
                       GIMP_NORMAL_MODE,
 
1924
                       GIMP_GRADIENT_LINEAR,
 
1925
                       100.0,
 
1926
                       0.0,
 
1927
                       GIMP_REPEAT_NONE,
 
1928
                       FALSE,
 
1929
                       FALSE,
 
1930
                       0,
 
1931
                       0.0,
 
1932
                       FALSE,
 
1933
                       x1, y1,
 
1934
                       x2, y1);
1846
1935
      return;
1847
1936
    }
1848
1937
 
1953
2042
  switch (selvals.otype)
1954
2043
    {
1955
2044
    case LINE:
 
2045
    case RECTANGLE:
1956
2046
    case CIRCLE:
1957
2047
    case ELLIPSE:
1958
2048
    case ARC: