← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/actions/layers-commands.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/actions/layers-commands.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
36
36
#include "core/gimpimage.h"
37
37
#include "core/gimpimage-merge.h"
38
38
#include "core/gimpimage-undo.h"
 
39
#include "core/gimpimage-undo-push.h"
39
40
#include "core/gimpitemundo.h"
40
41
#include "core/gimplayer.h"
41
42
#include "core/gimplayer-floating-sel.h"
42
43
#include "core/gimplayermask.h"
43
 
#include "core/gimplist.h"
44
44
#include "core/gimptoolinfo.h"
45
45
#include "core/gimpundostack.h"
46
46
#include "core/gimpprogress.h"
47
47
 
48
48
#include "text/gimptext.h"
 
49
#include "text/gimptext-vectors.h"
49
50
#include "text/gimptextlayer.h"
50
51
 
 
52
#include "vectors/gimpvectors-warp.h"
 
53
 
51
54
#include "widgets/gimpaction.h"
52
55
#include "widgets/gimpdock.h"
53
56
#include "widgets/gimphelp-ids.h"
122
125
                                            GimpViewable          *viewable,
123
126
                                            gint                   width,
124
127
                                            gint                   height,
 
128
                                            GimpUnit               unit,
125
129
                                            gint                   offset_x,
126
130
                                            gint                   offset_y,
 
131
                                            GimpItemSet            unused,
127
132
                                            gpointer               data);
128
133
 
129
134
static gint   layers_mode_index            (GimpLayerModeEffects   layer_mode);
131
136
 
132
137
/*  private variables  */
133
138
 
134
 
static GimpFillType     layer_fill_type     = GIMP_TRANSPARENT_FILL;
135
 
static gchar           *layer_name          = NULL;
136
 
static GimpAddMaskType  layer_add_mask_type = GIMP_ADD_WHITE_MASK;
137
 
static gboolean         layer_mask_invert   = FALSE;
 
139
static GimpFillType           layer_fill_type     = GIMP_TRANSPARENT_FILL;
 
140
static gchar                 *layer_name          = NULL;
 
141
static GimpUnit               layer_resize_unit   = GIMP_UNIT_PIXEL;
 
142
static GimpUnit               layer_scale_unit    = GIMP_UNIT_PIXEL;
 
143
static GimpInterpolationType  layer_scale_interp  = -1;
 
144
static GimpAddMaskType        layer_add_mask_type = GIMP_ADD_WHITE_MASK;
 
145
static gboolean               layer_mask_invert   = FALSE;
138
146
 
139
147
 
140
148
/*  public functions  */
143
151
layers_text_tool_cmd_callback (GtkAction *action,
144
152
                               gpointer   data)
145
153
{
146
 
  GimpImage *gimage;
 
154
  GimpImage *image;
147
155
  GimpLayer *layer;
148
156
  GtkWidget *widget;
149
157
  GimpTool  *active_tool;
150
 
  return_if_no_layer (gimage, layer, data);
 
158
  return_if_no_layer (image, layer, data);
151
159
  return_if_no_widget (widget, data);
152
160
 
153
161
  if (! gimp_drawable_is_text_layer (GIMP_DRAWABLE (layer)))
156
164
      return;
157
165
    }
158
166
 
159
 
  active_tool = tool_manager_get_active (gimage->gimp);
 
167
  active_tool = tool_manager_get_active (image->gimp);
160
168
 
161
169
  if (! GIMP_IS_TEXT_TOOL (active_tool))
162
170
    {
163
 
      GimpToolInfo *tool_info;
164
 
 
165
 
      tool_info = (GimpToolInfo *)
166
 
        gimp_container_get_child_by_name (gimage->gimp->tool_info_list,
167
 
                                          "gimp-text-tool");
 
171
      GimpToolInfo *tool_info = gimp_get_tool_info (image->gimp,
 
172
                                                    "gimp-text-tool");
168
173
 
169
174
      if (GIMP_IS_TOOL_INFO (tool_info))
170
175
        {
171
176
          gimp_context_set_tool (action_data_get_context (data), tool_info);
172
 
          active_tool = tool_manager_get_active (gimage->gimp);
 
177
          active_tool = tool_manager_get_active (image->gimp);
173
178
        }
174
179
    }
175
180
 
179
184
 
180
185
void
181
186
layers_edit_attributes_cmd_callback (GtkAction *action,
182
 
                                     gpointer   data)
 
187
                                     gpointer   data)
183
188
{
184
189
  LayerOptionsDialog *dialog;
185
 
  GimpImage          *gimage;
 
190
  GimpImage          *image;
186
191
  GimpLayer          *layer;
187
192
  GtkWidget          *widget;
188
 
  return_if_no_layer (gimage, layer, data);
 
193
  return_if_no_layer (image, layer, data);
189
194
  return_if_no_widget (widget, data);
190
195
 
191
196
  dialog = layer_options_dialog_new (gimp_item_get_image (GIMP_ITEM (layer)),
 
197
                                     layer,
192
198
                                     action_data_get_context (data),
193
 
                                     layer, widget,
 
199
                                     widget,
194
200
                                     gimp_object_get_name (GIMP_OBJECT (layer)),
195
201
                                     layer_fill_type,
196
202
                                     _("Layer Attributes"),
197
203
                                     "gimp-layer-edit",
198
 
                                     GIMP_STOCK_EDIT,
 
204
                                     GTK_STOCK_EDIT,
199
205
                                     _("Edit Layer Attributes"),
200
206
                                     GIMP_HELP_LAYER_EDIT);
201
207
 
208
214
 
209
215
void
210
216
layers_new_cmd_callback (GtkAction *action,
211
 
                         gpointer   data)
 
217
                         gpointer   data)
212
218
{
213
219
  LayerOptionsDialog *dialog;
214
 
  GimpImage          *gimage;
 
220
  GimpImage          *image;
215
221
  GtkWidget          *widget;
216
222
  GimpLayer          *floating_sel;
217
 
  return_if_no_image (gimage, data);
 
223
  return_if_no_image (image, data);
218
224
  return_if_no_widget (widget, data);
219
225
 
220
226
  /*  If there is a floating selection, the new command transforms
221
227
   *  the current fs into a new layer
222
228
   */
223
 
  if ((floating_sel = gimp_image_floating_sel (gimage)))
 
229
  if ((floating_sel = gimp_image_floating_sel (image)))
224
230
    {
225
231
      floating_sel_to_layer (floating_sel);
226
 
      gimp_image_flush (gimage);
 
232
      gimp_image_flush (image);
227
233
      return;
228
234
    }
229
235
 
230
 
  dialog = layer_options_dialog_new (gimage, action_data_get_context (data),
231
 
                                     NULL, widget,
 
236
  dialog = layer_options_dialog_new (image, NULL,
 
237
                                     action_data_get_context (data),
 
238
                                     widget,
232
239
                                     layer_name ? layer_name : _("New Layer"),
233
240
                                     layer_fill_type,
234
241
                                     _("New Layer"),
248
255
layers_new_last_vals_cmd_callback (GtkAction *action,
249
256
                                   gpointer   data)
250
257
{
251
 
  GimpImage            *gimage;
 
258
  GimpImage            *image;
252
259
  GimpLayer            *floating_sel;
253
260
  GimpLayer            *new_layer;
254
261
  gint                  width, height;
255
262
  gint                  off_x, off_y;
256
263
  gdouble               opacity;
257
264
  GimpLayerModeEffects  mode;
258
 
  return_if_no_image (gimage, data);
 
265
  return_if_no_image (image, data);
259
266
 
260
267
  /*  If there is a floating selection, the new command transforms
261
268
   *  the current fs into a new layer
262
269
   */
263
 
  if ((floating_sel = gimp_image_floating_sel (gimage)))
 
270
  if ((floating_sel = gimp_image_floating_sel (image)))
264
271
    {
265
272
      floating_sel_to_layer (floating_sel);
266
 
      gimp_image_flush (gimage);
 
273
      gimp_image_flush (image);
267
274
      return;
268
275
    }
269
276
 
279
286
    }
280
287
  else
281
288
    {
282
 
      width   = gimp_image_get_width (gimage);
283
 
      height  = gimp_image_get_height (gimage);
 
289
      width   = gimp_image_get_width (image);
 
290
      height  = gimp_image_get_height (image);
284
291
      off_x   = 0;
285
292
      off_y   = 0;
286
293
      opacity = 1.0;
287
294
      mode    = GIMP_NORMAL_MODE;
288
295
    }
289
296
 
290
 
  gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_EDIT_PASTE,
 
297
  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE,
291
298
                               _("New Layer"));
292
299
 
293
 
  new_layer = gimp_layer_new (gimage, width, height,
294
 
                              gimp_image_base_type_with_alpha (gimage),
 
300
  new_layer = gimp_layer_new (image, width, height,
 
301
                              gimp_image_base_type_with_alpha (image),
295
302
                              layer_name ? layer_name : _("New Layer"),
296
303
                              opacity, mode);
297
304
 
300
307
                              layer_fill_type);
301
308
  gimp_item_translate (GIMP_ITEM (new_layer), off_x, off_y, FALSE);
302
309
 
303
 
  gimp_image_add_layer (gimage, new_layer, -1);
304
 
 
305
 
  gimp_image_undo_group_end (gimage);
306
 
 
307
 
  gimp_image_flush (gimage);
 
310
  gimp_image_add_layer (image, new_layer, -1);
 
311
 
 
312
  gimp_image_undo_group_end (image);
 
313
 
 
314
  gimp_image_flush (image);
308
315
}
309
316
 
310
317
void
312
319
                            gint       value,
313
320
                            gpointer   data)
314
321
{
315
 
  GimpImage *gimage;
 
322
  GimpImage *image;
316
323
  GimpLayer *layer;
317
324
  GimpLayer *new_layer;
318
 
  return_if_no_image (gimage, data);
 
325
  return_if_no_image (image, data);
319
326
 
320
 
  layer = gimp_image_get_active_layer (gimage);
 
327
  layer = gimp_image_get_active_layer (image);
321
328
 
322
329
  new_layer = (GimpLayer *) action_select_object ((GimpActionSelectType) value,
323
 
                                                  gimage->layers,
 
330
                                                  image->layers,
324
331
                                                  (GimpObject *) layer);
325
332
 
326
333
  if (new_layer && new_layer != layer)
327
334
    {
328
 
      gimp_image_set_active_layer (gimage, new_layer);
329
 
      gimp_image_flush (gimage);
 
335
      gimp_image_set_active_layer (image, new_layer);
 
336
      gimp_image_flush (image);
330
337
    }
331
338
}
332
339
 
333
340
void
334
341
layers_raise_cmd_callback (GtkAction *action,
335
 
                           gpointer   data)
 
342
                           gpointer   data)
336
343
{
337
 
  GimpImage *gimage;
 
344
  GimpImage *image;
338
345
  GimpLayer *layer;
339
 
  return_if_no_layer (gimage, layer, data);
 
346
  return_if_no_layer (image, layer, data);
340
347
 
341
 
  gimp_image_raise_layer (gimage, layer);
342
 
  gimp_image_flush (gimage);
 
348
  gimp_image_raise_layer (image, layer);
 
349
  gimp_image_flush (image);
343
350
}
344
351
 
345
352
void
346
353
layers_raise_to_top_cmd_callback (GtkAction *action,
347
 
                                  gpointer   data)
 
354
                                  gpointer   data)
348
355
{
349
 
  GimpImage *gimage;
 
356
  GimpImage *image;
350
357
  GimpLayer *layer;
351
 
  return_if_no_layer (gimage, layer, data);
 
358
  return_if_no_layer (image, layer, data);
352
359
 
353
 
  gimp_image_raise_layer_to_top (gimage, layer);
354
 
  gimp_image_flush (gimage);
 
360
  gimp_image_raise_layer_to_top (image, layer);
 
361
  gimp_image_flush (image);
355
362
}
356
363
 
357
364
void
358
365
layers_lower_cmd_callback (GtkAction *action,
359
 
                           gpointer   data)
 
366
                           gpointer   data)
360
367
{
361
 
  GimpImage *gimage;
 
368
  GimpImage *image;
362
369
  GimpLayer *layer;
363
 
  return_if_no_layer (gimage, layer, data);
 
370
  return_if_no_layer (image, layer, data);
364
371
 
365
 
  gimp_image_lower_layer (gimage, layer);
366
 
  gimp_image_flush (gimage);
 
372
  gimp_image_lower_layer (image, layer);
 
373
  gimp_image_flush (image);
367
374
}
368
375
 
369
376
void
370
377
layers_lower_to_bottom_cmd_callback (GtkAction *action,
371
 
                                     gpointer   data)
 
378
                                     gpointer   data)
372
379
{
373
 
  GimpImage *gimage;
 
380
  GimpImage *image;
374
381
  GimpLayer *layer;
375
 
  return_if_no_layer (gimage, layer, data);
 
382
  return_if_no_layer (image, layer, data);
376
383
 
377
 
  gimp_image_lower_layer_to_bottom (gimage, layer);
378
 
  gimp_image_flush (gimage);
 
384
  gimp_image_lower_layer_to_bottom (image, layer);
 
385
  gimp_image_flush (image);
379
386
}
380
387
 
381
388
void
382
389
layers_duplicate_cmd_callback (GtkAction *action,
383
 
                               gpointer   data)
 
390
                               gpointer   data)
384
391
{
385
 
  GimpImage *gimage;
 
392
  GimpImage *image;
386
393
  GimpLayer *layer;
387
394
  GimpLayer *new_layer;
388
 
  return_if_no_layer (gimage, layer, data);
 
395
  return_if_no_layer (image, layer, data);
389
396
 
390
397
  new_layer =
391
398
    GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (layer),
392
399
                                     G_TYPE_FROM_INSTANCE (layer),
393
400
                                     TRUE));
394
 
  gimp_image_add_layer (gimage, new_layer, -1);
 
401
  gimp_image_add_layer (image, new_layer, -1);
395
402
 
396
 
  gimp_image_flush (gimage);
 
403
  gimp_image_flush (image);
397
404
}
398
405
 
399
406
void
400
407
layers_anchor_cmd_callback (GtkAction *action,
401
 
                            gpointer   data)
 
408
                            gpointer   data)
402
409
{
403
 
  GimpImage *gimage;
 
410
  GimpImage *image;
404
411
  GimpLayer *layer;
405
 
  return_if_no_layer (gimage, layer, data);
 
412
  return_if_no_layer (image, layer, data);
406
413
 
407
414
  if (gimp_layer_is_floating_sel (layer))
408
415
    {
409
416
      floating_sel_anchor (layer);
410
 
      gimp_image_flush (gimage);
 
417
      gimp_image_flush (image);
411
418
    }
412
419
}
413
420
 
414
421
void
415
422
layers_merge_down_cmd_callback (GtkAction *action,
416
 
                                gpointer   data)
 
423
                                gpointer   data)
417
424
{
418
 
  GimpImage *gimage;
 
425
  GimpImage *image;
419
426
  GimpLayer *layer;
420
 
  return_if_no_layer (gimage, layer, data);
 
427
  return_if_no_layer (image, layer, data);
421
428
 
422
 
  gimp_image_merge_down (gimage, layer, action_data_get_context (data),
 
429
  gimp_image_merge_down (image, layer, action_data_get_context (data),
423
430
                         GIMP_EXPAND_AS_NECESSARY);
424
 
  gimp_image_flush (gimage);
 
431
  gimp_image_flush (image);
425
432
}
426
433
 
427
434
void
428
435
layers_delete_cmd_callback (GtkAction *action,
429
 
                            gpointer   data)
 
436
                            gpointer   data)
430
437
{
431
 
  GimpImage *gimage;
 
438
  GimpImage *image;
432
439
  GimpLayer *layer;
433
 
  return_if_no_layer (gimage, layer, data);
 
440
  return_if_no_layer (image, layer, data);
434
441
 
435
442
  if (gimp_layer_is_floating_sel (layer))
436
443
    floating_sel_remove (layer);
437
444
  else
438
 
    gimp_image_remove_layer (gimage, layer);
 
445
    gimp_image_remove_layer (image, layer);
439
446
 
440
 
  gimp_image_flush (gimage);
 
447
  gimp_image_flush (image);
441
448
}
442
449
 
443
450
void
444
451
layers_text_discard_cmd_callback (GtkAction *action,
445
452
                                  gpointer   data)
446
453
{
447
 
  GimpImage *gimage;
 
454
  GimpImage *image;
448
455
  GimpLayer *layer;
449
 
  return_if_no_layer (gimage, layer, data);
 
456
  return_if_no_layer (image, layer, data);
450
457
 
451
458
  if (GIMP_IS_TEXT_LAYER (layer))
452
459
    gimp_text_layer_discard (GIMP_TEXT_LAYER (layer));
453
460
}
454
461
 
455
462
void
 
463
layers_text_to_vectors_cmd_callback (GtkAction *action,
 
464
                                     gpointer   data)
 
465
{
 
466
  GimpImage *image;
 
467
  GimpLayer *layer;
 
468
  return_if_no_layer (image, layer, data);
 
469
 
 
470
  if (GIMP_IS_TEXT_LAYER (layer))
 
471
    {
 
472
      GimpVectors *vectors;
 
473
      gint         x, y;
 
474
 
 
475
      vectors = gimp_text_vectors_new (image, GIMP_TEXT_LAYER (layer)->text);
 
476
 
 
477
      gimp_item_offsets (GIMP_ITEM (layer), &x, &y);
 
478
      gimp_item_translate (GIMP_ITEM (vectors), x, y, FALSE);
 
479
 
 
480
      gimp_image_add_vectors (image, vectors, -1);
 
481
      gimp_image_set_active_vectors (image, vectors);
 
482
 
 
483
      gimp_image_flush (image);
 
484
    }
 
485
}
 
486
 
 
487
void
 
488
layers_text_along_vectors_cmd_callback (GtkAction *action,
 
489
                                        gpointer   data)
 
490
{
 
491
  GimpImage   *image;
 
492
  GimpLayer   *layer;
 
493
  GimpVectors *vectors;
 
494
  return_if_no_layer (image, layer, data);
 
495
  return_if_no_vectors (image, vectors, data);
 
496
 
 
497
  if (GIMP_IS_TEXT_LAYER (layer))
 
498
    {
 
499
      GimpVectors *new_vectors;
 
500
 
 
501
      new_vectors = gimp_text_vectors_new (image, GIMP_TEXT_LAYER (layer)->text);
 
502
 
 
503
      gimp_vectors_warp_vectors (vectors, new_vectors,
 
504
                                 0.5 * gimp_item_height (GIMP_ITEM (layer)));
 
505
 
 
506
      gimp_item_set_visible (GIMP_ITEM (new_vectors), TRUE, FALSE);
 
507
 
 
508
      gimp_image_add_vectors (image, new_vectors, -1);
 
509
      gimp_image_set_active_vectors (image, new_vectors);
 
510
 
 
511
      gimp_image_flush (image);
 
512
    }
 
513
}
 
514
 
 
515
void
456
516
layers_resize_cmd_callback (GtkAction *action,
457
 
                            gpointer   data)
 
517
                            gpointer   data)
458
518
{
459
 
  GimpDisplay *gdisp;
460
 
  GimpImage   *gimage;
461
 
  GimpLayer   *layer;
462
 
  GtkWidget   *widget;
463
 
  GtkWidget   *dialog;
464
 
  return_if_no_layer (gimage, layer, data);
 
519
  GimpImage *image;
 
520
  GimpLayer *layer;
 
521
  GtkWidget *widget;
 
522
  GtkWidget *dialog;
 
523
  return_if_no_layer (image, layer, data);
465
524
  return_if_no_widget (widget, data);
466
525
 
467
 
  gdisp = GIMP_IS_DISPLAY (data) ? data : NULL;
 
526
  if (layer_resize_unit != GIMP_UNIT_PERCENT && GIMP_IS_DISPLAY (data))
 
527
    layer_resize_unit = GIMP_DISPLAY_SHELL (GIMP_DISPLAY (data)->shell)->unit;
468
528
 
469
529
  dialog = resize_dialog_new (GIMP_VIEWABLE (layer),
 
530
                              action_data_get_context (data),
470
531
                              _("Set Layer Boundary Size"), "gimp-layer-resize",
471
532
                              widget,
472
533
                              gimp_standard_help_func, GIMP_HELP_LAYER_RESIZE,
473
 
                              (gdisp ?
474
 
                               GIMP_DISPLAY_SHELL (gdisp->shell)->unit :
475
 
                               GIMP_UNIT_PIXEL),
 
534
                              layer_resize_unit,
476
535
                              layers_resize_layer_callback,
477
536
                              action_data_get_context (data));
478
537
 
481
540
 
482
541
void
483
542
layers_resize_to_image_cmd_callback (GtkAction *action,
484
 
                                     gpointer   data)
 
543
                                     gpointer   data)
485
544
{
486
 
  GimpImage *gimage;
 
545
  GimpImage *image;
487
546
  GimpLayer *layer;
488
 
  return_if_no_layer (gimage, layer, data);
 
547
  return_if_no_layer (image, layer, data);
489
548
 
490
549
  gimp_layer_resize_to_image (layer, action_data_get_context (data));
491
 
  gimp_image_flush (gimage);
 
550
  gimp_image_flush (image);
492
551
}
493
552
 
494
553
void
495
554
layers_scale_cmd_callback (GtkAction *action,
496
 
                           gpointer   data)
 
555
                           gpointer   data)
497
556
{
498
 
  GimpImage   *gimage;
499
 
  GimpLayer   *layer;
500
 
  GtkWidget   *widget;
501
 
  GimpDisplay *gdisp;
502
 
  GtkWidget   *dialog;
503
 
  GimpUnit     unit;
504
 
  return_if_no_layer (gimage, layer, data);
 
557
  GimpImage *image;
 
558
  GimpLayer *layer;
 
559
  GtkWidget *widget;
 
560
  GtkWidget *dialog;
 
561
  return_if_no_layer (image, layer, data);
505
562
  return_if_no_widget (widget, data);
506
563
 
507
 
  gdisp = action_data_get_display (data);
 
564
  if (layer_scale_unit != GIMP_UNIT_PERCENT && GIMP_IS_DISPLAY (data))
 
565
    layer_scale_unit = GIMP_DISPLAY_SHELL (GIMP_DISPLAY (data)->shell)->unit;
508
566
 
509
 
  unit = gdisp ? GIMP_DISPLAY_SHELL (gdisp->shell)->unit : GIMP_UNIT_PIXEL;
 
567
  if (layer_scale_interp == -1)
 
568
    layer_scale_interp = image->gimp->config->interpolation_type;
510
569
 
511
570
  dialog = scale_dialog_new (GIMP_VIEWABLE (layer),
 
571
                             action_data_get_context (data),
512
572
                             _("Scale Layer"), "gimp-layer-scale",
513
573
                             widget,
514
574
                             gimp_standard_help_func, GIMP_HELP_LAYER_SCALE,
515
 
                             unit, gimage->gimp->config->interpolation_type,
 
575
                             layer_scale_unit,
 
576
                             layer_scale_interp,
516
577
                             layers_scale_layer_callback,
517
 
                             gdisp);
 
578
                             GIMP_IS_DISPLAY (data) ? data : NULL);
518
579
 
519
580
  gtk_widget_show (dialog);
520
581
}
523
584
layers_crop_cmd_callback (GtkAction *action,
524
585
                          gpointer   data)
525
586
{
526
 
  GimpImage *gimage;
 
587
  GimpImage *image;
527
588
  GimpLayer *layer;
 
589
  GtkWidget *widget;
528
590
  gint       x1, y1, x2, y2;
529
591
  gint       off_x, off_y;
530
 
  return_if_no_layer (gimage, layer, data);
 
592
  return_if_no_layer (image, layer, data);
 
593
  return_if_no_widget (widget, data);
531
594
 
532
 
  if (! gimp_channel_bounds (gimp_image_get_mask (gimage),
 
595
  if (! gimp_channel_bounds (gimp_image_get_mask (image),
533
596
                             &x1, &y1, &x2, &y2))
534
597
    {
535
 
      g_message (_("Cannot crop because the current selection is empty."));
 
598
      gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING,
 
599
                    _("Cannot crop because the current selection is empty."));
536
600
      return;
537
601
    }
538
602
 
541
605
  off_x -= x1;
542
606
  off_y -= y1;
543
607
 
544
 
  gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_ITEM_RESIZE,
 
608
  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_RESIZE,
545
609
                               _("Crop Layer"));
546
610
 
547
611
  gimp_item_resize (GIMP_ITEM (layer), action_data_get_context (data),
548
612
                    x2 - x1, y2 - y1, off_x, off_y);
549
613
 
550
 
  gimp_image_undo_group_end (gimage);
 
614
  gimp_image_undo_group_end (image);
551
615
 
552
 
  gimp_image_flush (gimage);
 
616
  gimp_image_flush (image);
553
617
}
554
618
 
555
619
void
557
621
                              gpointer   data)
558
622
{
559
623
  LayerAddMaskDialog *dialog;
560
 
  GimpImage          *gimage;
 
624
  GimpImage          *image;
561
625
  GimpLayer          *layer;
562
626
  GtkWidget          *widget;
563
 
  return_if_no_layer (gimage, layer, data);
 
627
  return_if_no_layer (image, layer, data);
564
628
  return_if_no_widget (widget, data);
565
629
 
566
 
  dialog = layer_add_mask_dialog_new (layer, widget,
 
630
  dialog = layer_add_mask_dialog_new (layer, action_data_get_context (data),
 
631
                                      widget,
567
632
                                      layer_add_mask_type, layer_mask_invert);
568
633
 
569
634
  g_signal_connect (dialog->dialog, "response",
578
643
                                gint       value,
579
644
                                gpointer   data)
580
645
{
581
 
  GimpImage         *gimage;
 
646
  GimpImage         *image;
582
647
  GimpLayer         *layer;
583
648
  GimpMaskApplyMode  mode;
584
 
  return_if_no_layer (gimage, layer, data);
 
649
  return_if_no_layer (image, layer, data);
585
650
 
586
651
  mode = (GimpMaskApplyMode) value;
587
652
 
588
653
  if (gimp_layer_get_mask (layer))
589
654
    {
590
655
      gimp_layer_apply_mask (layer, mode, TRUE);
591
 
      gimp_image_flush (gimage);
 
656
      gimp_image_flush (image);
592
657
    }
593
658
}
594
659
 
596
661
layers_mask_edit_cmd_callback (GtkAction *action,
597
662
                               gpointer   data)
598
663
{
599
 
  GimpImage     *gimage;
 
664
  GimpImage     *image;
600
665
  GimpLayer     *layer;
601
666
  GimpLayerMask *mask;
602
 
  return_if_no_layer (gimage, layer, data);
 
667
  return_if_no_layer (image, layer, data);
603
668
 
604
669
  mask = gimp_layer_get_mask (layer);
605
670
 
610
675
      active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
611
676
 
612
677
      gimp_layer_mask_set_edit (mask, active);
613
 
      gimp_image_flush (gimage);
 
678
      gimp_image_flush (image);
614
679
    }
615
680
}
616
681
 
618
683
layers_mask_show_cmd_callback (GtkAction *action,
619
684
                               gpointer   data)
620
685
{
621
 
  GimpImage     *gimage;
 
686
  GimpImage     *image;
622
687
  GimpLayer     *layer;
623
688
  GimpLayerMask *mask;
624
 
  return_if_no_layer (gimage, layer, data);
 
689
  return_if_no_layer (image, layer, data);
625
690
 
626
691
  mask = gimp_layer_get_mask (layer);
627
692
 
631
696
 
632
697
      active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
633
698
 
634
 
      gimp_layer_mask_set_show (mask, active);
635
 
      gimp_image_flush (gimage);
 
699
      gimp_layer_mask_set_show (mask, active, TRUE);
 
700
      gimp_image_flush (image);
636
701
    }
637
702
}
638
703
 
640
705
layers_mask_disable_cmd_callback (GtkAction *action,
641
706
                                  gpointer   data)
642
707
{
643
 
  GimpImage     *gimage;
 
708
  GimpImage     *image;
644
709
  GimpLayer     *layer;
645
710
  GimpLayerMask *mask;
646
 
  return_if_no_layer (gimage, layer, data);
 
711
  return_if_no_layer (image, layer, data);
647
712
 
648
713
  mask = gimp_layer_get_mask (layer);
649
714
 
653
718
 
654
719
      active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
655
720
 
656
 
      gimp_layer_mask_set_apply (mask, ! active);
657
 
      gimp_image_flush (gimage);
 
721
      gimp_layer_mask_set_apply (mask, ! active, TRUE);
 
722
      gimp_image_flush (image);
658
723
    }
659
724
}
660
725
 
664
729
                                       gpointer   data)
665
730
{
666
731
  GimpChannelOps  op;
667
 
  GimpImage      *gimage;
 
732
  GimpImage      *image;
668
733
  GimpLayer      *layer;
669
734
  GimpLayerMask  *mask;
670
 
  return_if_no_layer (gimage, layer, data);
 
735
  return_if_no_layer (image, layer, data);
671
736
 
672
737
  op = (GimpChannelOps) value;
673
738
 
679
744
 
680
745
      gimp_item_offsets (GIMP_ITEM (mask), &off_x, &off_y);
681
746
 
682
 
      gimp_channel_select_channel (gimp_image_get_mask (gimage),
 
747
      gimp_channel_select_channel (gimp_image_get_mask (image),
683
748
                                   _("Layer Mask to Selection"),
684
749
                                   GIMP_CHANNEL (mask),
685
750
                                   off_x, off_y,
686
751
                                   op, FALSE, 0.0, 0.0);
687
 
      gimp_image_flush (gimage);
 
752
      gimp_image_flush (image);
688
753
    }
689
754
}
690
755
 
692
757
layers_alpha_add_cmd_callback (GtkAction *action,
693
758
                               gpointer   data)
694
759
{
695
 
  GimpImage *gimage;
 
760
  GimpImage *image;
696
761
  GimpLayer *layer;
697
 
  return_if_no_layer (gimage, layer, data);
 
762
  return_if_no_layer (image, layer, data);
698
763
 
699
764
  if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
700
765
    {
701
766
      gimp_layer_add_alpha (layer);
702
 
      gimp_image_flush (gimage);
 
767
      gimp_image_flush (image);
 
768
    }
 
769
}
 
770
 
 
771
void
 
772
layers_alpha_remove_cmd_callback (GtkAction *action,
 
773
                                  gpointer   data)
 
774
{
 
775
  GimpImage *image;
 
776
  GimpLayer *layer;
 
777
  return_if_no_layer (image, layer, data);
 
778
 
 
779
  if (gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
 
780
    {
 
781
      gimp_layer_flatten (layer, action_data_get_context (data));
 
782
      gimp_image_flush (image);
703
783
    }
704
784
}
705
785
 
709
789
                                        gpointer   data)
710
790
{
711
791
  GimpChannelOps  op;
712
 
  GimpImage      *gimage;
 
792
  GimpImage      *image;
713
793
  GimpLayer      *layer;
714
 
  return_if_no_layer (gimage, layer, data);
 
794
  return_if_no_layer (image, layer, data);
715
795
 
716
796
  op = (GimpChannelOps) value;
717
797
 
718
 
  gimp_channel_select_alpha (gimp_image_get_mask (gimage),
 
798
  gimp_channel_select_alpha (gimp_image_get_mask (image),
719
799
                             GIMP_DRAWABLE (layer),
720
800
                             op, FALSE, 0.0, 0.0);
721
 
  gimp_image_flush (gimage);
 
801
  gimp_image_flush (image);
722
802
}
723
803
 
724
804
void
726
806
                             gint       value,
727
807
                             gpointer   data)
728
808
{
729
 
  GimpImage      *gimage;
 
809
  GimpImage      *image;
730
810
  GimpLayer      *layer;
731
811
  gdouble         opacity;
732
812
  GimpUndo       *undo;
733
813
  gboolean        push_undo = TRUE;
734
 
  return_if_no_layer (gimage, layer, data);
 
814
  return_if_no_layer (image, layer, data);
735
815
 
736
 
  undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
 
816
  undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
737
817
                                       GIMP_UNDO_LAYER_OPACITY);
738
818
 
739
819
  if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
742
822
  opacity = action_select_value ((GimpActionSelectType) value,
743
823
                                 gimp_layer_get_opacity (layer),
744
824
                                 0.0, 1.0,
745
 
                                 0.01, 0.1, FALSE);
 
825
                                 1.0 / 255.0, 0.01, 0.1, 0.0, FALSE);
746
826
  gimp_layer_set_opacity (layer, opacity, push_undo);
747
 
  gimp_image_flush (gimage);
 
827
  gimp_image_flush (image);
748
828
}
749
829
 
750
830
void
752
832
                          gint       value,
753
833
                          gpointer   data)
754
834
{
755
 
  GimpImage            *gimage;
 
835
  GimpImage            *image;
756
836
  GimpLayer            *layer;
757
837
  GimpLayerModeEffects  layer_mode;
758
838
  gint                  index;
759
839
  GimpUndo             *undo;
760
840
  gboolean              push_undo = TRUE;
761
 
  return_if_no_layer (gimage, layer, data);
 
841
  return_if_no_layer (image, layer, data);
762
842
 
763
 
  undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
 
843
  undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
764
844
                                       GIMP_UNDO_LAYER_MODE);
765
845
 
766
846
  if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
771
851
  index = action_select_value ((GimpActionSelectType) value,
772
852
                               layers_mode_index (layer_mode),
773
853
                               0, G_N_ELEMENTS (layer_modes) - 1,
774
 
                               1.0, 1.0, FALSE);
 
854
                               0.0, 1.0, 1.0, 0.0, FALSE);
775
855
  gimp_layer_set_mode (layer, layer_modes[index], push_undo);
776
 
  gimp_image_flush (gimage);
 
856
  gimp_image_flush (image);
777
857
}
778
858
 
779
859
void
780
 
layers_preserve_trans_cmd_callback (GtkAction *action,
781
 
                                    gpointer   data)
 
860
layers_lock_alpha_cmd_callback (GtkAction *action,
 
861
                                gpointer   data)
782
862
{
783
 
  GimpImage *gimage;
 
863
  GimpImage *image;
784
864
  GimpLayer *layer;
785
 
  gboolean   preserve;
786
 
  return_if_no_layer (gimage, layer, data);
787
 
 
788
 
  preserve = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
789
 
 
790
 
  if (preserve != gimp_layer_get_preserve_trans (layer))
 
865
  gboolean   lock_alpha;
 
866
  return_if_no_layer (image, layer, data);
 
867
 
 
868
  lock_alpha = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
 
869
 
 
870
  if (lock_alpha != gimp_layer_get_lock_alpha (layer))
791
871
    {
792
872
      GimpUndo *undo;
793
873
      gboolean  push_undo = TRUE;
794
874
 
795
 
      undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
796
 
                                           GIMP_UNDO_LAYER_PRESERVE_TRANS);
 
875
      undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
 
876
                                           GIMP_UNDO_LAYER_LOCK_ALPHA);
797
877
 
798
878
      if (undo && GIMP_ITEM_UNDO (undo)->item == GIMP_ITEM (layer))
799
879
        push_undo = FALSE;
800
880
 
801
 
      gimp_layer_set_preserve_trans (layer, preserve, push_undo);
802
 
      gimp_image_flush (gimage);
 
881
      gimp_layer_set_lock_alpha (layer, lock_alpha, push_undo);
 
882
      gimp_image_flush (image);
803
883
    }
804
884
}
805
885
 
829
909
        RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (dialog->size_se),
830
910
                                          1));
831
911
 
832
 
      layer = gimp_layer_new (dialog->gimage,
 
912
      layer = gimp_layer_new (dialog->image,
833
913
                              dialog->xsize,
834
914
                              dialog->ysize,
835
 
                              gimp_image_base_type_with_alpha (dialog->gimage),
 
915
                              gimp_image_base_type_with_alpha (dialog->image),
836
916
                              layer_name,
837
917
                              GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
838
918
 
841
921
          gimp_drawable_fill_by_type (GIMP_DRAWABLE (layer),
842
922
                                      dialog->context,
843
923
                                      layer_fill_type);
844
 
          gimp_image_add_layer (dialog->gimage, layer, -1);
 
924
          gimp_image_add_layer (dialog->image, layer, -1);
845
925
 
846
 
          gimp_image_flush (dialog->gimage);
 
926
          gimp_image_flush (dialog->image);
847
927
        }
848
928
      else
849
929
        {
850
 
          g_message ("new_layer_query_response: "
851
 
                     "could not allocate new layer");
 
930
          g_warning ("%s: could not allocate new layer", G_STRFUNC);
852
931
        }
853
932
    }
854
933
 
870
949
      if (strcmp (new_name, gimp_object_get_name (GIMP_OBJECT (layer))))
871
950
        {
872
951
          gimp_item_rename (GIMP_ITEM (layer), new_name);
873
 
          gimp_image_flush (dialog->gimage);
 
952
          gimp_image_flush (dialog->image);
874
953
        }
875
954
 
876
955
      if (dialog->rename_toggle &&
893
972
{
894
973
  if (response_id == GTK_RESPONSE_OK)
895
974
    {
896
 
      GimpLayer     *layer  = dialog->layer;
897
 
      GimpImage     *gimage = gimp_item_get_image (GIMP_ITEM (layer));
 
975
      GimpLayer     *layer = dialog->layer;
 
976
      GimpImage     *image = gimp_item_get_image (GIMP_ITEM (layer));
898
977
      GimpLayerMask *mask;
899
978
 
 
979
      if (dialog->add_mask_type == GIMP_ADD_CHANNEL_MASK &&
 
980
          ! dialog->channel)
 
981
        {
 
982
          gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING,
 
983
                        _("Please select a channel first"));
 
984
          return;
 
985
        }
 
986
 
900
987
      layer_add_mask_type = dialog->add_mask_type;
901
988
      layer_mask_invert   = dialog->invert;
902
989
 
903
 
      gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_LAYER_ADD_MASK,
 
990
      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_LAYER_ADD_MASK,
904
991
                                   _("Add Layer Mask"));
905
992
 
906
993
      if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
907
994
        gimp_layer_add_alpha (layer);
908
995
 
909
 
      mask = gimp_layer_create_mask (layer, layer_add_mask_type);
 
996
      mask = gimp_layer_create_mask (layer, layer_add_mask_type,
 
997
                                     dialog->channel);
910
998
 
911
999
      if (layer_mask_invert)
912
1000
        gimp_channel_invert (GIMP_CHANNEL (mask), FALSE);
913
1001
 
914
1002
      gimp_layer_add_mask (layer, mask, TRUE);
915
1003
 
916
 
      gimp_image_undo_group_end (gimage);
 
1004
      gimp_image_undo_group_end (image);
917
1005
 
918
 
      gimp_image_flush (gimage);
 
1006
      gimp_image_flush (image);
919
1007
    }
920
1008
 
921
1009
  gtk_widget_destroy (dialog->dialog);
933
1021
                             GimpUnit               resolution_unit,/* unused */
934
1022
                             gpointer               data)
935
1023
{
936
 
  GimpDisplay *gdisp = GIMP_DISPLAY (data);
 
1024
  GimpDisplay *display = GIMP_DISPLAY (data);
 
1025
 
 
1026
  layer_scale_unit   = unit;
 
1027
  layer_scale_interp = interpolation;
937
1028
 
938
1029
  if (width > 0 && height > 0)
939
1030
    {
943
1034
 
944
1035
      gtk_widget_destroy (dialog);
945
1036
 
946
 
      if (width == gimp_item_width (item) && height == gimp_item_height (item))
 
1037
      if (width  == gimp_item_width (item) &&
 
1038
          height == gimp_item_height (item))
947
1039
        return;
948
1040
 
949
 
      if (gdisp)
 
1041
      if (display)
950
1042
        {
951
 
          progress = GIMP_PROGRESS (gdisp);
 
1043
          progress = GIMP_PROGRESS (display);
952
1044
        }
953
1045
      else
954
1046
        {
956
1048
          progress = GIMP_PROGRESS (progress_dialog);
957
1049
        }
958
1050
 
959
 
      progress = gimp_progress_start (progress, _("Scaling..."), FALSE);
 
1051
      progress = gimp_progress_start (progress, _("Scaling"), FALSE);
960
1052
 
961
1053
      gimp_item_scale_by_origin (item,
962
1054
                                 width, height, interpolation,
972
1064
    }
973
1065
  else
974
1066
    {
975
 
      g_message (_("Invalid width or height. Both must be positive."));
 
1067
      g_warning ("Scale Error: "
 
1068
                 "Both width and height must be greater than zero.");
976
1069
    }
977
1070
}
978
1071
 
981
1074
                              GimpViewable *viewable,
982
1075
                              gint          width,
983
1076
                              gint          height,
 
1077
                              GimpUnit      unit,
984
1078
                              gint          offset_x,
985
1079
                              gint          offset_y,
 
1080
                              GimpItemSet   unused,
986
1081
                              gpointer      data)
987
1082
{
988
1083
  GimpContext *context = GIMP_CONTEXT (data);
989
1084
 
 
1085
  layer_resize_unit = unit;
 
1086
 
990
1087
  if (width > 0 && height > 0)
991
1088
    {
992
1089
      GimpItem *item = GIMP_ITEM (viewable);
993
1090
 
994
1091
      gtk_widget_destroy (dialog);
995
1092
 
996
 
      if (width == gimp_item_width (item) && height == gimp_item_height (item))
 
1093
      if (width  == gimp_item_width (item) &&
 
1094
          height == gimp_item_height (item))
997
1095
        return;
998
1096
 
999
 
      gimp_item_resize (item,
1000
 
                        context,
 
1097
      gimp_item_resize (item, context,
1001
1098
                        width, height, offset_x, offset_y);
1002
1099
 
1003
1100
      gimp_image_flush (gimp_item_get_image (item));
1004
1101
    }
1005
1102
  else
1006
1103
    {
1007
 
      g_message (_("Invalid width or height. Both must be positive."));
 
1104
      g_warning ("Resize Error: "
 
1105
                 "Both width and height must be greater than zero.");
1008
1106
    }
1009
1107
}
1010
1108