← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/tools/gimptransformoptions.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:
app/tools/gimptransformoptions.c
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
20
20
 
21
21
#include <gtk/gtk.h>
22
22
 
23
 
#include "libgimpmath/gimpmath.h"
 
23
#include "libgimpconfig/gimpconfig.h"
24
24
#include "libgimpwidgets/gimpwidgets.h"
25
25
 
26
26
#include "tools-types.h"
27
27
 
28
 
#include "config/gimpconfig-params.h"
29
28
#include "config/gimpcoreconfig.h"
30
29
 
31
30
#include "core/gimp.h"
32
31
#include "core/gimptoolinfo.h"
33
32
 
34
 
#include "widgets/gimppropwidgets.h"
35
33
#include "widgets/gimpwidgets-utils.h"
36
34
 
37
35
#include "gimprotatetool.h"
54
52
  PROP_PREVIEW_TYPE,
55
53
  PROP_GRID_TYPE,
56
54
  PROP_GRID_SIZE,
57
 
  PROP_CONSTRAIN_1,
58
 
  PROP_CONSTRAIN_2
 
55
  PROP_CONSTRAIN
59
56
};
60
57
 
61
58
 
62
 
static void   gimp_transform_options_class_init (GimpTransformOptionsClass *options_class);
63
 
 
64
59
static void   gimp_transform_options_set_property   (GObject         *object,
65
60
                                                     guint            property_id,
66
61
                                                     const GValue    *value,
75
70
static void   gimp_transform_options_preview_notify (GimpTransformOptions *options,
76
71
                                                     GParamSpec           *pspec,
77
72
                                                     GtkWidget            *density_box);
78
 
static void   gimp_scale_options_constrain_callback (GtkWidget            *widget,
79
 
                                                     GObject              *config);
80
 
static void   gimp_scale_options_constrain_notify   (GimpTransformOptions *options,
81
 
                                                     GParamSpec           *pspec,
82
 
                                                     GtkWidget            *vbox);
83
 
 
84
 
 
85
 
static GimpToolOptionsClass *parent_class = NULL;
86
 
 
87
 
 
88
 
GType
89
 
gimp_transform_options_get_type (void)
90
 
{
91
 
  static GType type = 0;
92
 
 
93
 
  if (! type)
94
 
    {
95
 
      static const GTypeInfo info =
96
 
      {
97
 
        sizeof (GimpTransformOptionsClass),
98
 
        (GBaseInitFunc) NULL,
99
 
        (GBaseFinalizeFunc) NULL,
100
 
        (GClassInitFunc) gimp_transform_options_class_init,
101
 
        NULL,           /* class_finalize */
102
 
        NULL,           /* class_data     */
103
 
        sizeof (GimpTransformOptions),
104
 
        0,              /* n_preallocs    */
105
 
        (GInstanceInitFunc) NULL
106
 
      };
107
 
 
108
 
      type = g_type_register_static (GIMP_TYPE_TOOL_OPTIONS,
109
 
                                     "GimpTransformOptions",
110
 
                                     &info, 0);
111
 
    }
112
 
 
113
 
  return type;
114
 
}
 
73
 
 
74
 
 
75
G_DEFINE_TYPE (GimpTransformOptions, gimp_transform_options,
 
76
               GIMP_TYPE_TOOL_OPTIONS)
 
77
 
 
78
#define parent_class gimp_transform_options_parent_class
 
79
 
115
80
 
116
81
static void
117
82
gimp_transform_options_class_init (GimpTransformOptionsClass *klass)
119
84
  GObjectClass         *object_class  = G_OBJECT_CLASS (klass);
120
85
  GimpToolOptionsClass *options_class = GIMP_TOOL_OPTIONS_CLASS (klass);
121
86
 
122
 
  parent_class = g_type_class_peek_parent (klass);
123
 
 
124
87
  object_class->set_property = gimp_transform_options_set_property;
125
88
  object_class->get_property = gimp_transform_options_get_property;
126
89
 
130
93
                                 "type", NULL,
131
94
                                 GIMP_TYPE_TRANSFORM_TYPE,
132
95
                                 GIMP_TRANSFORM_TYPE_LAYER,
133
 
                                 0);
 
96
                                 GIMP_PARAM_STATIC_STRINGS);
134
97
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_DIRECTION,
135
98
                                 "direction", NULL,
136
99
                                 GIMP_TYPE_TRANSFORM_DIRECTION,
137
100
                                 GIMP_TRANSFORM_FORWARD,
138
 
                                 0);
 
101
                                 GIMP_PARAM_STATIC_STRINGS);
139
102
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_INTERPOLATION,
140
103
                                 "interpolation", NULL,
141
104
                                 GIMP_TYPE_INTERPOLATION_TYPE,
142
105
                                 GIMP_INTERPOLATION_LINEAR,
143
 
                                 0);
 
106
                                 GIMP_PARAM_STATIC_STRINGS);
144
107
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SUPERSAMPLE,
145
108
                                    "supersample", NULL,
146
109
                                    FALSE,
147
 
                                    0);
 
110
                                    GIMP_PARAM_STATIC_STRINGS);
148
111
 
149
112
#if 0
150
113
  GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_RECURSION_LEVEL,
151
114
                                "recursion-level", NULL,
152
115
                                1, 5, 3,
153
 
                                0);
 
116
                                GIMP_PARAM_STATIC_STRINGS);
154
117
#endif
155
118
 
156
119
  g_object_class_install_property (object_class, PROP_RECURSION_LEVEL,
157
120
                                   g_param_spec_int ("recursion-level",
158
121
                                                     NULL, NULL,
159
122
                                                     1, 5, 3,
160
 
                                                     G_PARAM_READWRITE |
 
123
                                                     GIMP_PARAM_READWRITE |
161
124
                                                     G_PARAM_CONSTRUCT));
162
125
 
163
 
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CLIP,
164
 
                                    "clip", NULL,
165
 
                                    FALSE,
166
 
                                    0);
 
126
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_CLIP,
 
127
                                 "clip", NULL,
 
128
                                 GIMP_TYPE_TRANSFORM_RESIZE,
 
129
                                 GIMP_TRANSFORM_RESIZE_ADJUST,
 
130
                                 GIMP_PARAM_STATIC_STRINGS);
167
131
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_PREVIEW_TYPE,
168
132
                                 "preview-type", NULL,
169
133
                                 GIMP_TYPE_TRANSFORM_PREVIEW_TYPE,
170
134
                                 GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE,
171
 
                                 0);
 
135
                                 GIMP_PARAM_STATIC_STRINGS);
172
136
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRID_TYPE,
173
137
                                 "grid-type", NULL,
174
138
                                 GIMP_TYPE_TRANSFORM_GRID_TYPE,
175
139
                                 GIMP_TRANSFORM_GRID_TYPE_N_LINES,
176
 
                                 0);
 
140
                                 GIMP_PARAM_STATIC_STRINGS);
177
141
  GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_GRID_SIZE,
178
142
                                "grid-size", NULL,
179
143
                                1, 128, 15,
180
 
                                0);
181
 
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_1,
182
 
                                    "constrain-1", NULL,
183
 
                                    FALSE,
184
 
                                    0);
185
 
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN_2,
186
 
                                    "constrain-2", NULL,
187
 
                                    FALSE,
188
 
                                    0);
 
144
                                GIMP_PARAM_STATIC_STRINGS);
 
145
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CONSTRAIN,
 
146
                                    "constrain", NULL,
 
147
                                    FALSE,
 
148
                                    GIMP_PARAM_STATIC_STRINGS);
 
149
}
 
150
 
 
151
static void
 
152
gimp_transform_options_init (GimpTransformOptions *options)
 
153
{
189
154
}
190
155
 
191
156
static void
214
179
      options->recursion_level = g_value_get_int (value);
215
180
      break;
216
181
    case PROP_CLIP:
217
 
      options->clip = g_value_get_boolean (value);
 
182
      options->clip = g_value_get_enum (value);
218
183
      break;
219
184
    case PROP_PREVIEW_TYPE:
220
185
      options->preview_type = g_value_get_enum (value);
225
190
    case PROP_GRID_SIZE:
226
191
      options->grid_size = g_value_get_int (value);
227
192
      break;
228
 
    case PROP_CONSTRAIN_1:
229
 
      options->constrain_1 = g_value_get_boolean (value);
230
 
      break;
231
 
    case PROP_CONSTRAIN_2:
232
 
      options->constrain_2 = g_value_get_boolean (value);
 
193
    case PROP_CONSTRAIN:
 
194
      options->constrain = g_value_get_boolean (value);
233
195
      break;
234
196
    default:
235
197
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
263
225
      g_value_set_int (value, options->recursion_level);
264
226
      break;
265
227
    case PROP_CLIP:
266
 
      g_value_set_boolean (value, options->clip);
 
228
      g_value_set_enum (value, options->clip);
267
229
      break;
268
230
    case PROP_PREVIEW_TYPE:
269
231
      g_value_set_enum (value, options->preview_type);
274
236
    case PROP_GRID_SIZE:
275
237
      g_value_set_int (value, options->grid_size);
276
238
      break;
277
 
    case PROP_CONSTRAIN_1:
278
 
      g_value_set_boolean (value, options->constrain_1);
279
 
      break;
280
 
    case PROP_CONSTRAIN_2:
281
 
      g_value_set_boolean (value, options->constrain_2);
 
239
    case PROP_CONSTRAIN:
 
240
      g_value_set_boolean (value, options->constrain);
282
241
      break;
283
242
    default:
284
243
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
306
265
{
307
266
  GObject              *config  = G_OBJECT (tool_options);
308
267
  GimpTransformOptions *options = GIMP_TRANSFORM_OPTIONS (tool_options);
309
 
  GtkWidget            *vbox;
 
268
  GtkWidget            *vbox    = gimp_tool_options_gui (tool_options);
310
269
  GtkWidget            *hbox;
311
270
  GtkWidget            *label;
312
271
  GtkWidget            *frame;
313
272
  GtkWidget            *table;
314
273
  GtkWidget            *combo;
315
274
  GtkWidget            *button;
316
 
 
317
 
  vbox = gimp_tool_options_gui (tool_options);
 
275
  const gchar          *constrain = NULL;
318
276
 
319
277
  hbox = gimp_prop_enum_stock_box_new (config, "type", "gimp", 0, 0);
320
278
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
321
279
  gtk_widget_show (hbox);
322
280
 
323
 
  label = gtk_label_new (_("Affect:"));
 
281
  label = gtk_label_new (_("Transform:"));
324
282
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
325
283
  gtk_box_reorder_child (GTK_BOX (hbox), label, 0);
326
284
  gtk_widget_show (label);
327
285
 
328
286
  frame = gimp_prop_enum_radio_frame_new (config, "direction",
329
 
                                          _("Transform Direction"), 0, 0);
 
287
                                          _("Direction"), 0, 0);
330
288
  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
331
289
  gtk_widget_show (frame);
332
290
 
333
291
  /*  the interpolation menu  */
334
 
  hbox = gtk_hbox_new (FALSE, 4);
 
292
  hbox = gtk_hbox_new (FALSE, 6);
335
293
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
336
294
  gtk_widget_show (hbox);
337
295
 
349
307
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
350
308
  gtk_widget_show (button);
351
309
 
352
 
  /*  the clip resulting image toggle button  */
353
 
  button = gimp_prop_check_button_new (config, "clip", _("Clip result"));
354
 
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
355
 
  gtk_widget_show (button);
 
310
  /*  the clipping menu  */
 
311
  hbox = gtk_hbox_new (FALSE, 6);
 
312
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
313
  gtk_widget_show (hbox);
 
314
 
 
315
  label = gtk_label_new (_("Clipping:"));
 
316
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
317
  gtk_widget_show (label);
 
318
 
 
319
  combo = gimp_prop_enum_combo_box_new (config, "clip", 0, 0);
 
320
  gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
 
321
  gtk_widget_show (combo);
356
322
 
357
323
  /*  the preview frame  */
358
324
  frame = gimp_frame_new (NULL);
360
326
  gtk_widget_show (frame);
361
327
 
362
328
  /*  the preview type menu  */
363
 
  hbox = gtk_hbox_new (FALSE, 4);
 
329
  hbox = gtk_hbox_new (FALSE, 6);
364
330
  gtk_frame_set_label_widget (GTK_FRAME (frame), hbox);
365
331
  gtk_widget_show (hbox);
366
332
 
373
339
  gtk_widget_show (combo);
374
340
 
375
341
  /*  the grid type menu  */
376
 
  button = gtk_vbox_new (FALSE, 4);
 
342
  button = gtk_vbox_new (FALSE, 6);
377
343
  gtk_container_add (GTK_CONTAINER (frame), button);
378
344
  gtk_widget_show (button);
379
345
 
403
369
                             1.0, 8.0, 0,
404
370
                             FALSE, 0.0, 0.0);
405
371
 
406
 
  if (tool_options->tool_info->tool_type == GIMP_TYPE_ROTATE_TOOL ||
407
 
      tool_options->tool_info->tool_type == GIMP_TYPE_SCALE_TOOL)
408
 
    {
409
 
      GtkWidget *vbox2;
410
 
      GtkWidget *vbox3;
411
 
 
412
 
      /*  the constraints frame  */
413
 
      frame = gimp_frame_new (_("Constraints"));
414
 
      gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
415
 
      gtk_widget_show (frame);
416
 
 
417
 
      vbox2 = gtk_vbox_new (FALSE, 2);
418
 
      gtk_container_add (GTK_CONTAINER (frame), vbox2);
419
 
      gtk_widget_show (vbox2);
420
 
 
421
 
      if (tool_options->tool_info->tool_type == GIMP_TYPE_ROTATE_TOOL)
422
 
        {
423
 
          gchar *str;
424
 
 
425
 
          str = g_strdup_printf (_("15 degrees  %s"),
426
 
                                 gimp_get_mod_string (GDK_CONTROL_MASK));
427
 
 
428
 
          button = gimp_prop_check_button_new (config, "constrain-1", str);
429
 
          gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
430
 
          gtk_widget_show (button);
431
 
 
432
 
          g_free (str);
433
 
        }
434
 
      else if (tool_options->tool_info->tool_type == GIMP_TYPE_SCALE_TOOL)
435
 
        {
436
 
          GtkWidget *button;
437
 
          gchar     *str1;
438
 
          gchar     *str2;
439
 
          gchar     *str3;
440
 
          gint       initial;
441
 
 
442
 
          initial = ((options->constrain_1 ? 1 : 0) +
443
 
                     (options->constrain_2 ? 2 : 0));
444
 
 
445
 
          str1 = g_strdup_printf (_("Keep height  %s"),
446
 
                                  gimp_get_mod_string (GDK_CONTROL_MASK));
447
 
          str2 = g_strdup_printf (_("Keep width  %s"),
448
 
                                  gimp_get_mod_string (GDK_MOD1_MASK));
449
 
          str3 = g_strdup_printf (_("Keep aspect  %s"),
450
 
                                  gimp_get_mod_string (GDK_CONTROL_MASK |
451
 
                                                       GDK_MOD1_MASK));
452
 
 
453
 
          vbox3 = gimp_int_radio_group_new (FALSE, NULL,
454
 
                                            G_CALLBACK (gimp_scale_options_constrain_callback),
455
 
                                            config, initial,
456
 
 
457
 
                                            _("None"), 0, &button,
458
 
                                            str1,      1, NULL,
459
 
                                            str2,      2, NULL,
460
 
                                            str3,      3, NULL,
461
 
 
462
 
                                            NULL);
463
 
 
464
 
          gtk_box_pack_start (GTK_BOX (vbox2), vbox3, FALSE, FALSE, 0);
465
 
          gtk_widget_show (vbox3);
466
 
 
467
 
          g_signal_connect_object (config, "notify::constrain-1",
468
 
                                   G_CALLBACK (gimp_scale_options_constrain_notify),
469
 
                                   G_OBJECT (button), 0);
470
 
          g_signal_connect_object (config, "notify::constrain-2",
471
 
                                   G_CALLBACK (gimp_scale_options_constrain_notify),
472
 
                                   G_OBJECT (button), 0);
473
 
 
474
 
          g_free (str1);
475
 
          g_free (str2);
476
 
          g_free (str3);
477
 
        }
 
372
  if (tool_options->tool_info->tool_type == GIMP_TYPE_ROTATE_TOOL)
 
373
    {
 
374
      constrain = (_("15 degrees  (%s)"));
 
375
    }
 
376
  else if (tool_options->tool_info->tool_type == GIMP_TYPE_SCALE_TOOL)
 
377
    {
 
378
      constrain = (_("Keep aspect  (%s)"));
 
379
    }
 
380
 
 
381
  if (constrain)
 
382
    {
 
383
      gchar *label = g_strdup_printf (constrain,
 
384
                                      gimp_get_mod_string (GDK_CONTROL_MASK));
 
385
 
 
386
      button = gimp_prop_check_button_new (config, "constrain", label);
 
387
      gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
388
      gtk_widget_show (button);
 
389
 
 
390
      g_free (label);
478
391
    }
479
392
 
480
393
  return vbox;
494
407
                            options->preview_type ==
495
408
                            GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID);
496
409
}
497
 
 
498
 
static void
499
 
gimp_scale_options_constrain_callback (GtkWidget *widget,
500
 
                                       GObject   *config)
501
 
{
502
 
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
503
 
    {
504
 
      gint      value;
505
 
      gboolean  c0;
506
 
      gboolean  c1;
507
 
 
508
 
      value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget),
509
 
                                                  "gimp-item-data"));
510
 
 
511
 
      c0 = c1 = FALSE;
512
 
 
513
 
      if (value == 1 || value == 3)
514
 
        c0 = TRUE;
515
 
      if (value == 2 || value == 3)
516
 
        c1 = TRUE;
517
 
 
518
 
      g_object_set (config,
519
 
                    "constrain-1", c0,
520
 
                    "constrain-2", c1,
521
 
                    NULL);
522
 
    }
523
 
}
524
 
 
525
 
static void
526
 
gimp_scale_options_constrain_notify (GimpTransformOptions *options,
527
 
                                     GParamSpec           *pspec,
528
 
                                     GtkWidget            *button)
529
 
{
530
 
  gint value;
531
 
 
532
 
  value = ((options->constrain_1 ? 1 : 0) +
533
 
           (options->constrain_2 ? 2 : 0));
534
 
 
535
 
  gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), value);
536
 
}