← Back to branch summary

~ubuntu-branches/ubuntu/breezy/gimp/breezy

« back to all changes in this revision

Viewing changes to app/tools/gimptransformoptions.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2005-10-04 19:04:46 UTC
  • Revision ID: james.westby@ubuntu.com-20051004190446-ukh32kwk56s4sjhu
Tags: upstream-2.2.8
Import upstream version 2.2.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/tools/gimptransformoptions.c
 
1
/* The GIMP -- an image manipulation program
 
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation; either version 2 of the License, or
 
7
 * (at your option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
17
 */
 
18
 
 
19
#include "config.h"
 
20
 
 
21
#include <gtk/gtk.h>
 
22
 
 
23
#include "libgimpmath/gimpmath.h"
 
24
#include "libgimpwidgets/gimpwidgets.h"
 
25
 
 
26
#include "tools-types.h"
 
27
 
 
28
#include "config/gimpconfig-params.h"
 
29
#include "config/gimpcoreconfig.h"
 
30
 
 
31
#include "core/gimp.h"
 
32
#include "core/gimptoolinfo.h"
 
33
 
 
34
#include "widgets/gimppropwidgets.h"
 
35
#include "widgets/gimpwidgets-utils.h"
 
36
 
 
37
#include "gimprotatetool.h"
 
38
#include "gimpscaletool.h"
 
39
#include "gimptooloptions-gui.h"
 
40
#include "gimptransformoptions.h"
 
41
 
 
42
#include "gimp-intl.h"
 
43
 
 
44
 
 
45
enum
 
46
{
 
47
  PROP_0,
 
48
  PROP_TYPE,
 
49
  PROP_DIRECTION,
 
50
  PROP_INTERPOLATION,
 
51
  PROP_SUPERSAMPLE,
 
52
  PROP_RECURSION_LEVEL,
 
53
  PROP_CLIP,
 
54
  PROP_PREVIEW_TYPE,
 
55
  PROP_GRID_TYPE,
 
56
  PROP_GRID_SIZE,
 
57
  PROP_CONSTRAIN_1,
 
58
  PROP_CONSTRAIN_2
 
59
};
 
60
 
 
61
 
 
62
static void   gimp_transform_options_class_init (GimpTransformOptionsClass *options_class);
 
63
 
 
64
static void   gimp_transform_options_set_property   (GObject         *object,
 
65
                                                     guint            property_id,
 
66
                                                     const GValue    *value,
 
67
                                                     GParamSpec      *pspec);
 
68
static void   gimp_transform_options_get_property   (GObject         *object,
 
69
                                                     guint            property_id,
 
70
                                                     GValue          *value,
 
71
                                                     GParamSpec      *pspec);
 
72
 
 
73
static void   gimp_transform_options_reset          (GimpToolOptions *tool_options);
 
74
 
 
75
static void   gimp_transform_options_preview_notify (GimpTransformOptions *options,
 
76
                                                     GParamSpec           *pspec,
 
77
                                                     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
}
 
115
 
 
116
static void
 
117
gimp_transform_options_class_init (GimpTransformOptionsClass *klass)
 
118
{
 
119
  GObjectClass         *object_class  = G_OBJECT_CLASS (klass);
 
120
  GimpToolOptionsClass *options_class = GIMP_TOOL_OPTIONS_CLASS (klass);
 
121
 
 
122
  parent_class = g_type_class_peek_parent (klass);
 
123
 
 
124
  object_class->set_property = gimp_transform_options_set_property;
 
125
  object_class->get_property = gimp_transform_options_get_property;
 
126
 
 
127
  options_class->reset       = gimp_transform_options_reset;
 
128
 
 
129
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_TYPE,
 
130
                                 "type", NULL,
 
131
                                 GIMP_TYPE_TRANSFORM_TYPE,
 
132
                                 GIMP_TRANSFORM_TYPE_LAYER,
 
133
                                 0);
 
134
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_DIRECTION,
 
135
                                 "direction", NULL,
 
136
                                 GIMP_TYPE_TRANSFORM_DIRECTION,
 
137
                                 GIMP_TRANSFORM_FORWARD,
 
138
                                 0);
 
139
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_INTERPOLATION,
 
140
                                 "interpolation", NULL,
 
141
                                 GIMP_TYPE_INTERPOLATION_TYPE,
 
142
                                 GIMP_INTERPOLATION_LINEAR,
 
143
                                 0);
 
144
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_SUPERSAMPLE,
 
145
                                    "supersample", NULL,
 
146
                                    FALSE,
 
147
                                    0);
 
148
 
 
149
#if 0
 
150
  GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_RECURSION_LEVEL,
 
151
                                "recursion-level", NULL,
 
152
                                1, 5, 3,
 
153
                                0);
 
154
#endif
 
155
 
 
156
  g_object_class_install_property (object_class, PROP_RECURSION_LEVEL,
 
157
                                   g_param_spec_int ("recursion-level",
 
158
                                                     NULL, NULL,
 
159
                                                     1, 5, 3,
 
160
                                                     G_PARAM_READWRITE |
 
161
                                                     G_PARAM_CONSTRUCT));
 
162
 
 
163
  GIMP_CONFIG_INSTALL_PROP_BOOLEAN (object_class, PROP_CLIP,
 
164
                                    "clip", NULL,
 
165
                                    FALSE,
 
166
                                    0);
 
167
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_PREVIEW_TYPE,
 
168
                                 "preview-type", NULL,
 
169
                                 GIMP_TYPE_TRANSFORM_PREVIEW_TYPE,
 
170
                                 GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE,
 
171
                                 0);
 
172
  GIMP_CONFIG_INSTALL_PROP_ENUM (object_class, PROP_GRID_TYPE,
 
173
                                 "grid-type", NULL,
 
174
                                 GIMP_TYPE_TRANSFORM_GRID_TYPE,
 
175
                                 GIMP_TRANSFORM_GRID_TYPE_N_LINES,
 
176
                                 0);
 
177
  GIMP_CONFIG_INSTALL_PROP_INT (object_class, PROP_GRID_SIZE,
 
178
                                "grid-size", NULL,
 
179
                                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);
 
189
}
 
190
 
 
191
static void
 
192
gimp_transform_options_set_property (GObject      *object,
 
193
                                     guint         property_id,
 
194
                                     const GValue *value,
 
195
                                     GParamSpec   *pspec)
 
196
{
 
197
  GimpTransformOptions *options = GIMP_TRANSFORM_OPTIONS (object);
 
198
 
 
199
  switch (property_id)
 
200
    {
 
201
    case PROP_TYPE:
 
202
      options->type = g_value_get_enum (value);
 
203
      break;
 
204
    case PROP_DIRECTION:
 
205
      options->direction = g_value_get_enum (value);
 
206
      break;
 
207
    case PROP_INTERPOLATION:
 
208
      options->interpolation = g_value_get_enum (value);
 
209
      break;
 
210
    case PROP_SUPERSAMPLE:
 
211
      options->supersample = g_value_get_boolean (value);
 
212
      break;
 
213
    case PROP_RECURSION_LEVEL:
 
214
      options->recursion_level = g_value_get_int (value);
 
215
      break;
 
216
    case PROP_CLIP:
 
217
      options->clip = g_value_get_boolean (value);
 
218
      break;
 
219
    case PROP_PREVIEW_TYPE:
 
220
      options->preview_type = g_value_get_enum (value);
 
221
      break;
 
222
    case PROP_GRID_TYPE:
 
223
      options->grid_type = g_value_get_enum (value);
 
224
      break;
 
225
    case PROP_GRID_SIZE:
 
226
      options->grid_size = g_value_get_int (value);
 
227
      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);
 
233
      break;
 
234
    default:
 
235
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
236
      break;
 
237
    }
 
238
}
 
239
 
 
240
static void
 
241
gimp_transform_options_get_property (GObject    *object,
 
242
                                     guint       property_id,
 
243
                                     GValue     *value,
 
244
                                     GParamSpec *pspec)
 
245
{
 
246
  GimpTransformOptions *options = GIMP_TRANSFORM_OPTIONS (object);
 
247
 
 
248
  switch (property_id)
 
249
    {
 
250
    case PROP_TYPE:
 
251
      g_value_set_enum (value, options->type);
 
252
      break;
 
253
    case PROP_DIRECTION:
 
254
      g_value_set_enum (value, options->direction);
 
255
      break;
 
256
    case PROP_INTERPOLATION:
 
257
      g_value_set_enum (value, options->interpolation);
 
258
      break;
 
259
    case PROP_SUPERSAMPLE:
 
260
      g_value_set_boolean (value, options->supersample);
 
261
      break;
 
262
    case PROP_RECURSION_LEVEL:
 
263
      g_value_set_int (value, options->recursion_level);
 
264
      break;
 
265
    case PROP_CLIP:
 
266
      g_value_set_boolean (value, options->clip);
 
267
      break;
 
268
    case PROP_PREVIEW_TYPE:
 
269
      g_value_set_enum (value, options->preview_type);
 
270
      break;
 
271
    case PROP_GRID_TYPE:
 
272
      g_value_set_enum (value, options->grid_type);
 
273
      break;
 
274
    case PROP_GRID_SIZE:
 
275
      g_value_set_int (value, options->grid_size);
 
276
      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);
 
282
      break;
 
283
    default:
 
284
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
285
      break;
 
286
    }
 
287
}
 
288
 
 
289
static void
 
290
gimp_transform_options_reset (GimpToolOptions *tool_options)
 
291
{
 
292
  GParamSpec *pspec;
 
293
 
 
294
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (tool_options),
 
295
                                        "interpolation");
 
296
 
 
297
  if (pspec)
 
298
    G_PARAM_SPEC_ENUM (pspec)->default_value =
 
299
      tool_options->tool_info->gimp->config->interpolation_type;
 
300
 
 
301
  GIMP_TOOL_OPTIONS_CLASS (parent_class)->reset (tool_options);
 
302
}
 
303
 
 
304
GtkWidget *
 
305
gimp_transform_options_gui (GimpToolOptions *tool_options)
 
306
{
 
307
  GObject              *config  = G_OBJECT (tool_options);
 
308
  GimpTransformOptions *options = GIMP_TRANSFORM_OPTIONS (tool_options);
 
309
  GtkWidget            *vbox;
 
310
  GtkWidget            *hbox;
 
311
  GtkWidget            *label;
 
312
  GtkWidget            *frame;
 
313
  GtkWidget            *table;
 
314
  GtkWidget            *combo;
 
315
  GtkWidget            *button;
 
316
 
 
317
  vbox = gimp_tool_options_gui (tool_options);
 
318
 
 
319
  hbox = gimp_prop_enum_stock_box_new (config, "type", "gimp", 0, 0);
 
320
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
321
  gtk_widget_show (hbox);
 
322
 
 
323
  label = gtk_label_new (_("Affect:"));
 
324
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
325
  gtk_box_reorder_child (GTK_BOX (hbox), label, 0);
 
326
  gtk_widget_show (label);
 
327
 
 
328
  frame = gimp_prop_enum_radio_frame_new (config, "direction",
 
329
                                          _("Transform Direction"), 0, 0);
 
330
  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
 
331
  gtk_widget_show (frame);
 
332
 
 
333
  /*  the interpolation menu  */
 
334
  hbox = gtk_hbox_new (FALSE, 4);
 
335
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 
336
  gtk_widget_show (hbox);
 
337
 
 
338
  label = gtk_label_new (_("Interpolation:"));
 
339
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
340
  gtk_widget_show (label);
 
341
 
 
342
  combo = gimp_prop_enum_combo_box_new (config, "interpolation", 0, 0);
 
343
  gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
 
344
  gtk_widget_show (combo);
 
345
 
 
346
  /*  the supersample toggle button  */
 
347
  button = gimp_prop_check_button_new (config, "supersample",
 
348
                                       _("Supersampling"));
 
349
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
 
350
  gtk_widget_show (button);
 
351
 
 
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);
 
356
 
 
357
  /*  the preview frame  */
 
358
  frame = gimp_frame_new (NULL);
 
359
  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
 
360
  gtk_widget_show (frame);
 
361
 
 
362
  /*  the preview type menu  */
 
363
  hbox = gtk_hbox_new (FALSE, 4);
 
364
  gtk_frame_set_label_widget (GTK_FRAME (frame), hbox);
 
365
  gtk_widget_show (hbox);
 
366
 
 
367
  label = gtk_label_new (_("Preview:"));
 
368
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
 
369
  gtk_widget_show (label);
 
370
 
 
371
  combo = gimp_prop_enum_combo_box_new (config, "preview-type", 0, 0);
 
372
  gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
 
373
  gtk_widget_show (combo);
 
374
 
 
375
  /*  the grid type menu  */
 
376
  button = gtk_vbox_new (FALSE, 4);
 
377
  gtk_container_add (GTK_CONTAINER (frame), button);
 
378
  gtk_widget_show (button);
 
379
 
 
380
  combo = gimp_prop_enum_combo_box_new (config, "grid-type", 0, 0);
 
381
  gtk_box_pack_start (GTK_BOX (button), combo, FALSE, FALSE, 0);
 
382
  gtk_widget_show (combo);
 
383
 
 
384
  /*  the grid density scale  */
 
385
  table = gtk_table_new (1, 3, FALSE);
 
386
  gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2);
 
387
  gtk_box_pack_start (GTK_BOX (button), table, FALSE, FALSE, 0);
 
388
  gtk_widget_show (table);
 
389
 
 
390
  gtk_widget_set_sensitive (button,
 
391
                            options->preview_type ==
 
392
                            GIMP_TRANSFORM_PREVIEW_TYPE_GRID ||
 
393
                            options->preview_type ==
 
394
                            GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID);
 
395
 
 
396
  g_signal_connect (config, "notify::preview-type",
 
397
                    G_CALLBACK (gimp_transform_options_preview_notify),
 
398
                    button);
 
399
 
 
400
  gimp_prop_scale_entry_new (config, "grid-size",
 
401
                             GTK_TABLE (table), 0, 0,
 
402
                             NULL,
 
403
                             1.0, 8.0, 0,
 
404
                             FALSE, 0.0, 0.0);
 
405
 
 
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
        }
 
478
    }
 
479
 
 
480
  return vbox;
 
481
}
 
482
 
 
483
 
 
484
/*  private functions  */
 
485
 
 
486
static void
 
487
gimp_transform_options_preview_notify (GimpTransformOptions *options,
 
488
                                       GParamSpec           *pspec,
 
489
                                       GtkWidget            *density_box)
 
490
{
 
491
  gtk_widget_set_sensitive (density_box,
 
492
                            options->preview_type ==
 
493
                            GIMP_TRANSFORM_PREVIEW_TYPE_GRID ||
 
494
                            options->preview_type ==
 
495
                            GIMP_TRANSFORM_PREVIEW_TYPE_IMAGE_GRID);
 
496
}
 
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
}