← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/tools/gimptoolcontrol.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/gimptoolcontrol.c
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995-2002 Spencer Kimball, Peter Mattis and others
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
25
25
#include "gimptoolcontrol.h"
26
26
 
27
27
 
28
 
static void gimp_tool_control_class_init (GimpToolControlClass *klass);
29
 
static void gimp_tool_control_init       (GimpToolControl      *tool);
30
 
 
31
 
 
32
 
static GimpObjectClass *parent_class = NULL;
33
 
 
34
 
 
35
 
GType
36
 
gimp_tool_control_get_type (void)
37
 
{
38
 
  static GType tool_control_type = 0;
39
 
 
40
 
  if (! tool_control_type)
41
 
    {
42
 
      static const GTypeInfo tool_control_info =
43
 
      {
44
 
        sizeof (GimpToolControlClass),
45
 
        (GBaseInitFunc) NULL,
46
 
        (GBaseFinalizeFunc) NULL,
47
 
        (GClassInitFunc) gimp_tool_control_class_init,
48
 
        NULL,           /* class_finalize */
49
 
        NULL,           /* class_data     */
50
 
        sizeof (GimpToolControl),
51
 
        0,              /* n_preallocs    */
52
 
        (GInstanceInitFunc) gimp_tool_control_init,
53
 
      };
54
 
 
55
 
      tool_control_type = g_type_register_static (GIMP_TYPE_OBJECT,
56
 
                                                  "GimpToolControl",
57
 
                                                  &tool_control_info, 0);
58
 
    }
59
 
 
60
 
  return tool_control_type;
61
 
}
 
28
static void gimp_tool_control_finalize (GObject *object);
 
29
 
 
30
 
 
31
G_DEFINE_TYPE (GimpToolControl, gimp_tool_control, GIMP_TYPE_OBJECT)
 
32
 
 
33
#define parent_class gimp_tool_control_parent_class
 
34
 
62
35
 
63
36
static void
64
37
gimp_tool_control_class_init (GimpToolControlClass *klass)
65
38
{
66
 
  parent_class = g_type_class_peek_parent (klass);
 
39
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
40
 
 
41
  object_class->finalize = gimp_tool_control_finalize;
67
42
}
68
43
 
69
44
static void
72
47
  control->active                 = FALSE;
73
48
  control->paused_count           = 0;
74
49
 
75
 
  control->toggled                = FALSE;
76
 
 
 
50
  control->preserve               = TRUE;
77
51
  control->scroll_lock            = FALSE;
 
52
  control->handle_empty_image     = FALSE;
 
53
 
 
54
  control->dirty_mask             = GIMP_DIRTY_NONE;
 
55
  control->motion_mode            = GIMP_MOTION_MODE_HINT;
 
56
 
78
57
  control->auto_snap_to           = TRUE;
79
58
  control->snap_offset_x          = 0;
80
59
  control->snap_offset_y          = 0;
81
60
  control->snap_width             = 0;
82
61
  control->snap_height            = 0;
83
62
 
84
 
  control->preserve               = TRUE;
85
 
  control->dirty_mask             = GIMP_DIRTY_NONE;
86
 
  control->handle_empty_image     = FALSE;
87
 
  control->motion_mode            = GIMP_MOTION_MODE_HINT;
 
63
  control->toggled                = FALSE;
88
64
 
89
65
  control->cursor                 = GIMP_CURSOR_MOUSE;
90
66
  control->tool_cursor            = GIMP_TOOL_CURSOR_NONE;
91
67
  control->cursor_modifier        = GIMP_CURSOR_MODIFIER_NONE;
92
68
 
93
 
  control->toggle_cursor          = GIMP_CURSOR_MOUSE;
94
 
  control->toggle_tool_cursor     = GIMP_TOOL_CURSOR_NONE;
95
 
  control->toggle_cursor_modifier = GIMP_CURSOR_MODIFIER_NONE;
96
 
}
97
 
 
98
 
void
99
 
gimp_tool_control_pause (GimpToolControl *control)
100
 
{
101
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
102
 
 
103
 
  control->paused_count++;
104
 
}
105
 
 
106
 
void
107
 
gimp_tool_control_resume (GimpToolControl *control)
108
 
{
109
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
110
 
 
111
 
  control->paused_count--;
112
 
}
113
 
 
114
 
gboolean
115
 
gimp_tool_control_is_paused (GimpToolControl *control)
116
 
{
117
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
118
 
 
119
 
  return control->paused_count > 0;
120
 
}
 
69
  control->toggle_cursor          = -1;
 
70
  control->toggle_tool_cursor     = -1;
 
71
  control->toggle_cursor_modifier = -1;
 
72
 
 
73
  control->action_value_1         = NULL;
 
74
  control->action_value_2         = NULL;
 
75
  control->action_value_3         = NULL;
 
76
  control->action_value_4         = NULL;
 
77
 
 
78
  control->action_object_1        = NULL;
 
79
  control->action_object_2        = NULL;
 
80
}
 
81
 
 
82
static void
 
83
gimp_tool_control_finalize (GObject *object)
 
84
{
 
85
  GimpToolControl *control = GIMP_TOOL_CONTROL (object);
 
86
 
 
87
  g_free (control->action_value_1);
 
88
  g_free (control->action_value_2);
 
89
  g_free (control->action_value_3);
 
90
  g_free (control->action_value_4);
 
91
  g_free (control->action_object_1);
 
92
  g_free (control->action_object_2);
 
93
 
 
94
  G_OBJECT_CLASS (parent_class)->finalize (object);
 
95
}
 
96
 
 
97
 
 
98
/*  public functions  */
121
99
 
122
100
void
123
101
gimp_tool_control_activate (GimpToolControl *control)
150
128
}
151
129
 
152
130
void
153
 
gimp_tool_control_set_toggle (GimpToolControl *control,
154
 
                              gboolean         toggled)
155
 
{
156
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
157
 
 
158
 
  control->toggled = toggled ? TRUE : FALSE;
159
 
}
160
 
 
161
 
void
162
 
gimp_tool_control_set_handles_empty_image (GimpToolControl *control,
163
 
                                           gboolean         handle_empty)
 
131
gimp_tool_control_pause (GimpToolControl *control)
 
132
{
 
133
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
134
 
 
135
  control->paused_count++;
 
136
}
 
137
 
 
138
void
 
139
gimp_tool_control_resume (GimpToolControl *control)
 
140
{
 
141
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
142
 
 
143
  control->paused_count--;
 
144
}
 
145
 
 
146
gboolean
 
147
gimp_tool_control_is_paused (GimpToolControl *control)
 
148
{
 
149
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
 
150
 
 
151
  return control->paused_count > 0;
 
152
}
 
153
 
 
154
void
 
155
gimp_tool_control_set_preserve (GimpToolControl *control,
 
156
                                gboolean         preserve)
 
157
{
 
158
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
159
 
 
160
  control->preserve = preserve ? TRUE : FALSE;
 
161
}
 
162
 
 
163
gboolean
 
164
gimp_tool_control_get_preserve (GimpToolControl *control)
 
165
{
 
166
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
 
167
 
 
168
  return control->preserve;
 
169
}
 
170
 
 
171
void
 
172
gimp_tool_control_set_scroll_lock (GimpToolControl *control,
 
173
                                   gboolean         scroll_lock)
 
174
{
 
175
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
176
 
 
177
  control->scroll_lock = scroll_lock ? TRUE : FALSE;
 
178
}
 
179
 
 
180
gboolean
 
181
gimp_tool_control_get_scroll_lock (GimpToolControl *control)
 
182
{
 
183
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
 
184
 
 
185
  return control->scroll_lock;
 
186
}
 
187
 
 
188
void
 
189
gimp_tool_control_set_handle_empty_image (GimpToolControl *control,
 
190
                                          gboolean         handle_empty)
164
191
{
165
192
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
166
193
 
167
194
  control->handle_empty_image = handle_empty ? TRUE : FALSE;
168
195
}
169
196
 
 
197
gboolean
 
198
gimp_tool_control_get_handle_empty_image (GimpToolControl *control)
 
199
{
 
200
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
 
201
 
 
202
  return control->handle_empty_image;
 
203
}
 
204
 
 
205
void
 
206
gimp_tool_control_set_wants_click (GimpToolControl *control,
 
207
                                   gboolean         wants_click)
 
208
{
 
209
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
210
 
 
211
  control->wants_click = wants_click ? TRUE : FALSE;
 
212
}
 
213
 
 
214
gboolean
 
215
gimp_tool_control_get_wants_click (GimpToolControl *control)
 
216
{
 
217
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
 
218
 
 
219
  return control->wants_click;
 
220
}
 
221
 
 
222
void
 
223
gimp_tool_control_set_dirty_mask (GimpToolControl *control,
 
224
                                  GimpDirtyMask    dirty_mask)
 
225
{
 
226
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
227
 
 
228
  control->dirty_mask = dirty_mask;
 
229
}
 
230
 
 
231
GimpDirtyMask
 
232
gimp_tool_control_get_dirty_mask (GimpToolControl *control)
 
233
{
 
234
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), GIMP_DIRTY_NONE);
 
235
 
 
236
  return control->dirty_mask;
 
237
}
 
238
 
 
239
void
 
240
gimp_tool_control_set_motion_mode (GimpToolControl *control,
 
241
                                   GimpMotionMode   motion_mode)
 
242
{
 
243
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
244
 
 
245
  control->motion_mode = motion_mode;
 
246
}
 
247
 
 
248
GimpMotionMode
 
249
gimp_tool_control_get_motion_mode (GimpToolControl *control)
 
250
{
 
251
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), GIMP_MOTION_MODE_HINT);
 
252
 
 
253
  return control->motion_mode;
 
254
}
 
255
 
170
256
void
171
257
gimp_tool_control_set_snap_to (GimpToolControl *control,
172
258
                               gboolean         snap_to)
176
262
  control->auto_snap_to = snap_to ? TRUE : FALSE;
177
263
}
178
264
 
 
265
gboolean
 
266
gimp_tool_control_get_snap_to (GimpToolControl *control)
 
267
{
 
268
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
 
269
 
 
270
  return control->auto_snap_to;
 
271
}
 
272
 
179
273
void
180
274
gimp_tool_control_set_snap_offsets (GimpToolControl *control,
181
275
                                    gint             offset_x,
192
286
}
193
287
 
194
288
void
195
 
gimp_tool_control_set_motion_mode (GimpToolControl *control,
196
 
                                   GimpMotionMode   motion_mode)
197
 
{
198
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
199
 
 
200
 
  control->motion_mode = motion_mode;
201
 
}
202
 
 
203
 
void
204
 
gimp_tool_control_set_preserve (GimpToolControl *control,
205
 
                                gboolean         preserve)
206
 
{
207
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
208
 
 
209
 
  control->preserve = preserve ? TRUE : FALSE;
210
 
}
211
 
 
212
 
void
213
 
gimp_tool_control_set_dirty_mask (GimpToolControl *control,
214
 
                                  GimpDirtyMask    dirty_mask)
215
 
{
216
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
217
 
 
218
 
  control->dirty_mask = dirty_mask;
 
289
gimp_tool_control_get_snap_offsets (GimpToolControl *control,
 
290
                                    gint            *offset_x,
 
291
                                    gint            *offset_y,
 
292
                                    gint            *width,
 
293
                                    gint            *height)
 
294
{
 
295
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
296
 
 
297
  if (offset_x) *offset_x = control->snap_offset_x;
 
298
  if (offset_y) *offset_y = control->snap_offset_y;
 
299
  if (width)    *width    = control->snap_width;
 
300
  if (height)   *height   = control->snap_height;
 
301
}
 
302
 
 
303
void
 
304
gimp_tool_control_set_toggled (GimpToolControl *control,
 
305
                               gboolean         toggled)
 
306
{
 
307
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
308
 
 
309
  control->toggled = toggled ? TRUE : FALSE;
 
310
}
 
311
 
 
312
gboolean
 
313
gimp_tool_control_get_toggled (GimpToolControl *control)
 
314
{
 
315
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
 
316
 
 
317
  return control->toggled;
219
318
}
220
319
 
221
320
void
238
337
 
239
338
void
240
339
gimp_tool_control_set_cursor_modifier (GimpToolControl    *control,
241
 
                                       GimpCursorModifier  cmodifier)
 
340
                                       GimpCursorModifier  modifier)
242
341
{
243
342
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
244
343
 
245
 
  control->cursor_modifier = cmodifier;
 
344
  control->cursor_modifier = modifier;
246
345
}
247
346
 
248
347
void
265
364
 
266
365
void
267
366
gimp_tool_control_set_toggle_cursor_modifier (GimpToolControl    *control,
268
 
                                              GimpCursorModifier  cmodifier)
269
 
{
270
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
271
 
 
272
 
  control->toggle_cursor_modifier = cmodifier;
273
 
}
274
 
 
275
 
void
276
 
gimp_tool_control_set_scroll_lock (GimpToolControl *control,
277
 
                                   gboolean         scroll_lock)
278
 
{
279
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
280
 
 
281
 
  control->scroll_lock = scroll_lock ? TRUE : FALSE;
282
 
}
283
 
 
284
 
 
285
 
GimpMotionMode
286
 
gimp_tool_control_motion_mode (GimpToolControl *control)
287
 
{
288
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), GIMP_MOTION_MODE_HINT);
289
 
 
290
 
  return control->motion_mode;
291
 
}
292
 
 
293
 
gboolean
294
 
gimp_tool_control_handles_empty_image (GimpToolControl *control)
295
 
{
296
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
297
 
 
298
 
  return control->handle_empty_image;
299
 
}
300
 
 
301
 
gboolean
302
 
gimp_tool_control_auto_snap_to (GimpToolControl *control)
303
 
{
304
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
305
 
 
306
 
  return control->auto_snap_to;
307
 
}
308
 
 
309
 
void
310
 
gimp_tool_control_snap_offsets (GimpToolControl *control,
311
 
                                gint            *offset_x,
312
 
                                gint            *offset_y,
313
 
                                gint            *width,
314
 
                                gint            *height)
315
 
{
316
 
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
317
 
 
318
 
  if (offset_x) *offset_x = control->snap_offset_x;
319
 
  if (offset_y) *offset_y = control->snap_offset_y;
320
 
  if (width)    *width    = control->snap_width;
321
 
  if (height)   *height   = control->snap_height;
322
 
}
323
 
 
324
 
gboolean
325
 
gimp_tool_control_preserve (GimpToolControl *control)
326
 
{
327
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
328
 
 
329
 
  return control->preserve;
330
 
}
331
 
 
332
 
GimpDirtyMask
333
 
gimp_tool_control_dirty_mask (GimpToolControl *control)
334
 
{
335
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), GIMP_DIRTY_NONE);
336
 
 
337
 
  return control->dirty_mask;
338
 
}
339
 
 
340
 
gboolean
341
 
gimp_tool_control_scroll_lock (GimpToolControl *control)
342
 
{
343
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
344
 
 
345
 
  return control->scroll_lock;
346
 
}
347
 
 
348
 
gboolean
349
 
gimp_tool_control_is_toggled (GimpToolControl *control)
350
 
{
351
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
352
 
 
353
 
  return control->toggled;
 
367
                                              GimpCursorModifier  modifier)
 
368
{
 
369
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
370
 
 
371
  control->toggle_cursor_modifier = modifier;
354
372
}
355
373
 
356
374
GimpCursorType
358
376
{
359
377
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
360
378
 
 
379
  if (control->toggled && control->toggle_cursor != -1)
 
380
    return control->toggle_cursor;
 
381
 
361
382
  return control->cursor;
362
383
}
363
384
 
364
 
GimpCursorType
365
 
gimp_tool_control_get_toggle_cursor (GimpToolControl *control)
366
 
{
367
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
368
 
 
369
 
  return control->toggle_cursor;
370
 
}
371
 
 
372
385
GimpToolCursorType
373
386
gimp_tool_control_get_tool_cursor (GimpToolControl *control)
374
387
{
375
388
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
376
389
 
 
390
  if (control->toggled && control->toggle_tool_cursor != -1)
 
391
    return control->toggle_tool_cursor;
 
392
 
377
393
  return control->tool_cursor;
378
394
}
379
395
 
380
 
GimpToolCursorType
381
 
gimp_tool_control_get_toggle_tool_cursor (GimpToolControl *control)
382
 
{
383
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
384
 
 
385
 
  return control->toggle_tool_cursor;
386
 
}
387
 
 
388
396
GimpCursorModifier
389
397
gimp_tool_control_get_cursor_modifier (GimpToolControl *control)
390
398
{
391
399
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
392
400
 
 
401
  if (control->toggled && control->toggle_cursor_modifier != -1)
 
402
    return control->toggle_cursor_modifier;
 
403
 
393
404
  return control->cursor_modifier;
394
405
}
395
406
 
396
 
GimpCursorModifier
397
 
gimp_tool_control_get_toggle_cursor_modifier (GimpToolControl *control)
398
 
{
399
 
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), FALSE);
400
 
 
401
 
  return control->toggle_cursor_modifier;
 
407
void
 
408
gimp_tool_control_set_action_value_1 (GimpToolControl *control,
 
409
                                      const gchar     *action)
 
410
{
 
411
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
412
 
 
413
  if (action != control->action_value_1)
 
414
    {
 
415
      g_free (control->action_value_1);
 
416
      control->action_value_1 = g_strdup (action);
 
417
    }
 
418
}
 
419
 
 
420
const gchar *
 
421
gimp_tool_control_get_action_value_1 (GimpToolControl *control)
 
422
{
 
423
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), NULL);
 
424
 
 
425
  return control->action_value_1;
 
426
}
 
427
 
 
428
void
 
429
gimp_tool_control_set_action_value_2 (GimpToolControl *control,
 
430
                                      const gchar     *action)
 
431
{
 
432
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
433
 
 
434
  if (action != control->action_value_2)
 
435
    {
 
436
      g_free (control->action_value_2);
 
437
      control->action_value_2 = g_strdup (action);
 
438
    }
 
439
}
 
440
 
 
441
const gchar *
 
442
gimp_tool_control_get_action_value_2 (GimpToolControl *control)
 
443
{
 
444
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), NULL);
 
445
 
 
446
  return control->action_value_2;
 
447
}
 
448
 
 
449
void
 
450
gimp_tool_control_set_action_value_3 (GimpToolControl *control,
 
451
                                      const gchar     *action)
 
452
{
 
453
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
454
 
 
455
  if (action != control->action_value_3)
 
456
    {
 
457
      g_free (control->action_value_3);
 
458
      control->action_value_3 = g_strdup (action);
 
459
    }
 
460
}
 
461
 
 
462
const gchar *
 
463
gimp_tool_control_get_action_value_3 (GimpToolControl *control)
 
464
{
 
465
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), NULL);
 
466
 
 
467
  return control->action_value_3;
 
468
}
 
469
 
 
470
void
 
471
gimp_tool_control_set_action_value_4 (GimpToolControl *control,
 
472
                                      const gchar     *action)
 
473
{
 
474
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
475
 
 
476
  if (action != control->action_value_4)
 
477
    {
 
478
      g_free (control->action_value_4);
 
479
      control->action_value_4 = g_strdup (action);
 
480
    }
 
481
}
 
482
 
 
483
const gchar *
 
484
gimp_tool_control_get_action_value_4 (GimpToolControl *control)
 
485
{
 
486
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), NULL);
 
487
 
 
488
  return control->action_value_4;
 
489
}
 
490
 
 
491
void
 
492
gimp_tool_control_set_action_object_1 (GimpToolControl *control,
 
493
                                       const gchar     *action)
 
494
{
 
495
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
496
 
 
497
  if (action != control->action_object_1)
 
498
    {
 
499
      g_free (control->action_object_1);
 
500
      control->action_object_1 = g_strdup (action);
 
501
    }
 
502
}
 
503
 
 
504
const gchar *
 
505
gimp_tool_control_get_action_object_1 (GimpToolControl *control)
 
506
{
 
507
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), NULL);
 
508
 
 
509
  return control->action_object_1;
 
510
}
 
511
 
 
512
void
 
513
gimp_tool_control_set_action_object_2 (GimpToolControl *control,
 
514
                                       const gchar     *action)
 
515
{
 
516
  g_return_if_fail (GIMP_IS_TOOL_CONTROL (control));
 
517
 
 
518
  if (action != control->action_object_2)
 
519
    {
 
520
      g_free (control->action_object_2);
 
521
      control->action_object_2 = g_strdup (action);
 
522
    }
 
523
}
 
524
 
 
525
const gchar *
 
526
gimp_tool_control_get_action_object_2 (GimpToolControl *control)
 
527
{
 
528
  g_return_val_if_fail (GIMP_IS_TOOL_CONTROL (control), NULL);
 
529
 
 
530
  return control->action_object_2;
402
531
}