← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/core/gimplayer.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/core/gimplayer.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
23
23
 
24
24
#include <glib-object.h>
25
25
 
 
26
#include "libgimpbase/gimpbase.h"
26
27
#include "libgimpmath/gimpmath.h"
27
28
 
28
29
#include "core-types.h"
34
35
 
35
36
#include "paint-funcs/paint-funcs.h"
36
37
 
37
 
#include "gimp-utils.h"
38
38
#include "gimpcontext.h"
39
39
#include "gimpcontainer.h"
 
40
#include "gimpdrawable-convert.h"
40
41
#include "gimpdrawable-invert.h"
41
 
#include "gimpimage-convert.h"
42
42
#include "gimpimage-undo-push.h"
43
43
#include "gimpimage-undo.h"
44
44
#include "gimpimage.h"
46
46
#include "gimplayer.h"
47
47
#include "gimplayermask.h"
48
48
#include "gimpmarshal.h"
 
49
#include "gimppickable.h"
49
50
 
50
51
#include "gimp-intl.h"
51
52
 
54
55
{
55
56
  OPACITY_CHANGED,
56
57
  MODE_CHANGED,
57
 
  PRESERVE_TRANS_CHANGED,
 
58
  LOCK_ALPHA_CHANGED,
58
59
  MASK_CHANGED,
59
60
  LAST_SIGNAL
60
61
};
61
62
 
62
 
 
63
 
static void       gimp_layer_class_init         (GimpLayerClass     *klass);
64
 
static void       gimp_layer_init               (GimpLayer          *layer);
65
 
 
 
63
enum
 
64
{
 
65
  PROP_0,
 
66
  PROP_OPACITY,
 
67
  PROP_MODE,
 
68
  PROP_LOCK_ALPHA
 
69
};
 
70
 
 
71
 
 
72
static void   gimp_layer_pickable_iface_init (GimpPickableInterface *iface);
 
73
 
 
74
static void       gimp_layer_set_property       (GObject            *object,
 
75
                                                 guint               property_id,
 
76
                                                 const GValue       *value,
 
77
                                                 GParamSpec         *pspec);
 
78
static void       gimp_layer_get_property       (GObject            *object,
 
79
                                                 guint               property_id,
 
80
                                                 GValue             *value,
 
81
                                                 GParamSpec         *pspec);
66
82
static void       gimp_layer_dispose            (GObject            *object);
67
83
static void       gimp_layer_finalize           (GObject            *object);
68
84
 
119
135
                                                 GimpInterpolationType  interpolation_type,
120
136
                                                 gboolean            supersample,
121
137
                                                 gint                recursion_level,
122
 
                                                 gboolean            clip_result,
 
138
                                                 GimpTransformResize    clip_result,
123
139
                                                 GimpProgress       *progress);
124
140
static void    gimp_layer_invalidate_boundary   (GimpDrawable       *drawable);
125
141
static void    gimp_layer_get_active_components (const GimpDrawable *drawable,
131
147
                                                 GimpImageType       type,
132
148
                                                 gint                offset_x,
133
149
                                                 gint                offset_y);
 
150
static gint    gimp_layer_get_opacity_at        (GimpPickable       *pickable,
 
151
                                                 gint                x,
 
152
                                                 gint                y);
134
153
 
135
 
static void       gimp_layer_transform_color    (GimpImage          *gimage,
 
154
static void       gimp_layer_transform_color    (GimpImage          *image,
136
155
                                                 PixelRegion        *layerPR,
137
156
                                                 PixelRegion        *bufPR,
138
 
                                                 GimpDrawable       *drawable,
139
 
                                                 GimpImageBaseType   src_type);
 
157
                                                 GimpImageType       dest_type,
 
158
                                                 GimpImageType       src_type);
140
159
 
141
160
static void       gimp_layer_layer_mask_update  (GimpDrawable       *layer_mask,
142
161
                                                 gint                x,
146
165
                                                 GimpLayer          *layer);
147
166
 
148
167
 
149
 
static guint  layer_signals[LAST_SIGNAL] = { 0 };
150
 
 
151
 
static GimpDrawableClass *parent_class   = NULL;
152
 
 
153
 
 
154
 
GType
155
 
gimp_layer_get_type (void)
156
 
{
157
 
  static GType layer_type = 0;
158
 
 
159
 
  if (! layer_type)
160
 
    {
161
 
      static const GTypeInfo layer_info =
162
 
      {
163
 
        sizeof (GimpLayerClass),
164
 
        (GBaseInitFunc) NULL,
165
 
        (GBaseFinalizeFunc) NULL,
166
 
        (GClassInitFunc) gimp_layer_class_init,
167
 
        NULL,           /* class_finalize */
168
 
        NULL,           /* class_data     */
169
 
        sizeof (GimpLayer),
170
 
        0,              /* n_preallocs    */
171
 
        (GInstanceInitFunc) gimp_layer_init,
172
 
      };
173
 
 
174
 
      layer_type = g_type_register_static (GIMP_TYPE_DRAWABLE,
175
 
                                           "GimpLayer",
176
 
                                           &layer_info, 0);
177
 
    }
178
 
 
179
 
  return layer_type;
180
 
}
 
168
G_DEFINE_TYPE_WITH_CODE (GimpLayer, gimp_layer, GIMP_TYPE_DRAWABLE,
 
169
                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_PICKABLE,
 
170
                                                gimp_layer_pickable_iface_init))
 
171
 
 
172
#define parent_class gimp_layer_parent_class
 
173
 
 
174
static guint layer_signals[LAST_SIGNAL] = { 0 };
 
175
 
181
176
 
182
177
static void
183
178
gimp_layer_class_init (GimpLayerClass *klass)
188
183
  GimpItemClass     *item_class        = GIMP_ITEM_CLASS (klass);
189
184
  GimpDrawableClass *drawable_class    = GIMP_DRAWABLE_CLASS (klass);
190
185
 
191
 
  parent_class = g_type_class_peek_parent (klass);
192
 
 
193
186
  layer_signals[OPACITY_CHANGED] =
194
 
    g_signal_new ("opacity_changed",
195
 
                  G_TYPE_FROM_CLASS (klass),
196
 
                  G_SIGNAL_RUN_FIRST,
197
 
                  G_STRUCT_OFFSET (GimpLayerClass, opacity_changed),
198
 
                  NULL, NULL,
199
 
                  gimp_marshal_VOID__VOID,
200
 
                  G_TYPE_NONE, 0);
 
187
    g_signal_new ("opacity-changed",
 
188
                  G_TYPE_FROM_CLASS (klass),
 
189
                  G_SIGNAL_RUN_FIRST,
 
190
                  G_STRUCT_OFFSET (GimpLayerClass, opacity_changed),
 
191
                  NULL, NULL,
 
192
                  gimp_marshal_VOID__VOID,
 
193
                  G_TYPE_NONE, 0);
201
194
 
202
195
  layer_signals[MODE_CHANGED] =
203
 
    g_signal_new ("mode_changed",
204
 
                  G_TYPE_FROM_CLASS (klass),
205
 
                  G_SIGNAL_RUN_FIRST,
206
 
                  G_STRUCT_OFFSET (GimpLayerClass, mode_changed),
207
 
                  NULL, NULL,
208
 
                  gimp_marshal_VOID__VOID,
209
 
                  G_TYPE_NONE, 0);
 
196
    g_signal_new ("mode-changed",
 
197
                  G_TYPE_FROM_CLASS (klass),
 
198
                  G_SIGNAL_RUN_FIRST,
 
199
                  G_STRUCT_OFFSET (GimpLayerClass, mode_changed),
 
200
                  NULL, NULL,
 
201
                  gimp_marshal_VOID__VOID,
 
202
                  G_TYPE_NONE, 0);
210
203
 
211
 
  layer_signals[PRESERVE_TRANS_CHANGED] =
212
 
    g_signal_new ("preserve_trans_changed",
213
 
                  G_TYPE_FROM_CLASS (klass),
214
 
                  G_SIGNAL_RUN_FIRST,
215
 
                  G_STRUCT_OFFSET (GimpLayerClass, preserve_trans_changed),
216
 
                  NULL, NULL,
217
 
                  gimp_marshal_VOID__VOID,
218
 
                  G_TYPE_NONE, 0);
 
204
  layer_signals[LOCK_ALPHA_CHANGED] =
 
205
    g_signal_new ("lock-alpha-changed",
 
206
                  G_TYPE_FROM_CLASS (klass),
 
207
                  G_SIGNAL_RUN_FIRST,
 
208
                  G_STRUCT_OFFSET (GimpLayerClass, lock_alpha_changed),
 
209
                  NULL, NULL,
 
210
                  gimp_marshal_VOID__VOID,
 
211
                  G_TYPE_NONE, 0);
219
212
 
220
213
  layer_signals[MASK_CHANGED] =
221
 
    g_signal_new ("mask_changed",
222
 
                  G_TYPE_FROM_CLASS (klass),
223
 
                  G_SIGNAL_RUN_FIRST,
224
 
                  G_STRUCT_OFFSET (GimpLayerClass, mask_changed),
225
 
                  NULL, NULL,
226
 
                  gimp_marshal_VOID__VOID,
227
 
                  G_TYPE_NONE, 0);
 
214
    g_signal_new ("mask-changed",
 
215
                  G_TYPE_FROM_CLASS (klass),
 
216
                  G_SIGNAL_RUN_FIRST,
 
217
                  G_STRUCT_OFFSET (GimpLayerClass, mask_changed),
 
218
                  NULL, NULL,
 
219
                  gimp_marshal_VOID__VOID,
 
220
                  G_TYPE_NONE, 0);
228
221
 
 
222
  object_class->set_property          = gimp_layer_set_property;
 
223
  object_class->get_property          = gimp_layer_get_property;
229
224
  object_class->dispose               = gimp_layer_dispose;
230
225
  object_class->finalize              = gimp_layer_finalize;
231
226
 
262
257
 
263
258
  klass->opacity_changed              = NULL;
264
259
  klass->mode_changed                 = NULL;
265
 
  klass->preserve_trans_changed       = NULL;
 
260
  klass->lock_alpha_changed           = NULL;
266
261
  klass->mask_changed                 = NULL;
 
262
 
 
263
  g_object_class_install_property (object_class, PROP_OPACITY,
 
264
                                   g_param_spec_double ("opacity", NULL, NULL,
 
265
                                                        GIMP_OPACITY_TRANSPARENT,
 
266
                                                        GIMP_OPACITY_OPAQUE,
 
267
                                                        GIMP_OPACITY_OPAQUE,
 
268
                                                        GIMP_PARAM_READABLE));
 
269
 
 
270
  g_object_class_install_property (object_class, PROP_MODE,
 
271
                                   g_param_spec_enum ("mode", NULL, NULL,
 
272
                                                      GIMP_TYPE_LAYER_MODE_EFFECTS,
 
273
                                                      GIMP_NORMAL_MODE,
 
274
                                                      GIMP_PARAM_READABLE));
 
275
 
 
276
  g_object_class_install_property (object_class, PROP_LOCK_ALPHA,
 
277
                                   g_param_spec_boolean ("lock-alpha",
 
278
                                                         NULL, NULL,
 
279
                                                         FALSE,
 
280
                                                         GIMP_PARAM_READABLE));
267
281
}
268
282
 
269
283
static void
270
284
gimp_layer_init (GimpLayer *layer)
271
285
{
272
 
  layer->opacity        = GIMP_OPACITY_OPAQUE;
273
 
  layer->mode           = GIMP_NORMAL_MODE;
274
 
  layer->preserve_trans = FALSE;
 
286
  layer->opacity    = GIMP_OPACITY_OPAQUE;
 
287
  layer->mode       = GIMP_NORMAL_MODE;
 
288
  layer->lock_alpha = FALSE;
275
289
 
276
 
  layer->mask           = NULL;
 
290
  layer->mask       = NULL;
277
291
 
278
292
  /*  floating selection  */
279
293
  layer->fs.backing_store  = NULL;
285
299
}
286
300
 
287
301
static void
 
302
gimp_layer_pickable_iface_init (GimpPickableInterface *iface)
 
303
{
 
304
  iface->get_opacity_at = gimp_layer_get_opacity_at;
 
305
}
 
306
 
 
307
static void
 
308
gimp_layer_set_property (GObject      *object,
 
309
                         guint         property_id,
 
310
                         const GValue *value,
 
311
                         GParamSpec   *pspec)
 
312
{
 
313
  switch (property_id)
 
314
    {
 
315
    case PROP_OPACITY:
 
316
    case PROP_MODE:
 
317
    case PROP_LOCK_ALPHA:
 
318
      g_assert_not_reached ();
 
319
      break;
 
320
    default:
 
321
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
322
      break;
 
323
    }
 
324
}
 
325
 
 
326
static void
 
327
gimp_layer_get_property (GObject    *object,
 
328
                         guint       property_id,
 
329
                         GValue     *value,
 
330
                         GParamSpec *pspec)
 
331
{
 
332
  GimpLayer *layer = GIMP_LAYER (object);
 
333
 
 
334
  switch (property_id)
 
335
    {
 
336
    case PROP_OPACITY:
 
337
      g_value_set_double (value, layer->opacity);
 
338
      break;
 
339
    case PROP_MODE:
 
340
      g_value_set_enum (value, layer->mode);
 
341
      break;
 
342
    case PROP_LOCK_ALPHA:
 
343
      g_value_set_boolean (value, layer->lock_alpha);
 
344
      break;
 
345
    default:
 
346
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
347
      break;
 
348
    }
 
349
}
 
350
 
 
351
static void
288
352
gimp_layer_dispose (GObject *object)
289
353
{
290
354
  GimpLayer *layer = GIMP_LAYER (object);
334
398
 
335
399
  if (layer->mask)
336
400
    {
337
 
      gchar *mask_name;
 
401
      gchar *mask_name = g_strdup_printf (_("%s mask"),
 
402
                                          gimp_object_get_name (object));
338
403
 
339
 
      mask_name = g_strdup_printf (_("%s mask"), gimp_object_get_name (object));
340
 
      gimp_object_set_name (GIMP_OBJECT (layer->mask), mask_name);
341
 
      g_free (mask_name);
 
404
      gimp_object_take_name (GIMP_OBJECT (layer->mask), mask_name);
342
405
    }
343
406
}
344
407
 
379
442
{
380
443
  if (gimp_layer_is_floating_sel (GIMP_LAYER (viewable)))
381
444
    {
382
 
      if (tooltip)
383
 
        *tooltip = NULL;
384
 
 
385
445
      return g_strdup_printf (_("Floating Selection\n(%s)"),
386
446
                              gimp_object_get_name (GIMP_OBJECT (viewable)));
387
447
    }
394
454
gimp_layer_get_active_components (const GimpDrawable *drawable,
395
455
                                  gboolean           *active)
396
456
{
397
 
  GimpLayer *layer  = GIMP_LAYER (drawable);
398
 
  GimpImage *gimage = gimp_item_get_image (GIMP_ITEM (drawable));
 
457
  GimpLayer *layer = GIMP_LAYER (drawable);
 
458
  GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
399
459
  gint       i;
400
460
 
401
 
  /*  first copy the gimage active channels  */
 
461
  /*  first copy the image active channels  */
402
462
  for (i = 0; i < MAX_CHANNELS; i++)
403
 
    active[i] = gimage->active[i];
 
463
    active[i] = image->active[i];
404
464
 
405
 
  if (gimp_drawable_has_alpha (drawable) && layer->preserve_trans)
 
465
  if (gimp_drawable_has_alpha (drawable) && layer->lock_alpha)
406
466
    active[gimp_drawable_bytes (drawable) - 1] = FALSE;
407
467
}
408
468
 
444
504
static gboolean
445
505
gimp_layer_is_attached (GimpItem *item)
446
506
{
447
 
  return (GIMP_IS_IMAGE (item->gimage) &&
448
 
          gimp_container_have (item->gimage->layers, GIMP_OBJECT (item)));
 
507
  return (GIMP_IS_IMAGE (item->image) &&
 
508
          gimp_container_have (item->image->layers, GIMP_OBJECT (item)));
449
509
}
450
510
 
451
511
static GimpItem *
453
513
                      GType     new_type,
454
514
                      gboolean  add_alpha)
455
515
{
456
 
  GimpLayer *layer;
457
 
  GimpItem  *new_item;
458
 
  GimpLayer *new_layer;
 
516
  GimpItem *new_item;
459
517
 
460
518
  g_return_val_if_fail (g_type_is_a (new_type, GIMP_TYPE_DRAWABLE), NULL);
461
519
 
462
520
  new_item = GIMP_ITEM_CLASS (parent_class)->duplicate (item, new_type,
463
521
                                                        add_alpha);
464
522
 
465
 
  if (! GIMP_IS_LAYER (new_item))
466
 
    return new_item;
467
 
 
468
 
  layer     = GIMP_LAYER (item);
469
 
  new_layer = GIMP_LAYER (new_item);
470
 
 
471
 
  new_layer->mode           = layer->mode;
472
 
  new_layer->opacity        = layer->opacity;
473
 
  new_layer->preserve_trans = layer->preserve_trans;
474
 
 
475
 
  /*  duplicate the layer mask if necessary  */
476
 
  if (layer->mask)
 
523
  if (GIMP_IS_LAYER (new_item))
477
524
    {
478
 
      GimpLayerMask *layer_mask =
479
 
        GIMP_LAYER_MASK (gimp_item_duplicate (GIMP_ITEM (layer->mask),
480
 
                                              G_TYPE_FROM_INSTANCE (layer->mask),
481
 
                                              FALSE));
482
 
 
483
 
      gimp_layer_add_mask (new_layer, layer_mask, FALSE);
 
525
      GimpLayer *layer     = GIMP_LAYER (item);
 
526
      GimpLayer *new_layer = GIMP_LAYER (new_item);
 
527
 
 
528
      new_layer->mode       = layer->mode;
 
529
      new_layer->opacity    = layer->opacity;
 
530
      new_layer->lock_alpha = layer->lock_alpha;
 
531
 
 
532
      /*  duplicate the layer mask if necessary  */
 
533
      if (layer->mask)
 
534
        {
 
535
          GimpItem *new_mask =
 
536
            gimp_item_duplicate (GIMP_ITEM (layer->mask),
 
537
                                 G_TYPE_FROM_INSTANCE (layer->mask),
 
538
                                 FALSE);
 
539
          gimp_layer_add_mask (new_layer, GIMP_LAYER_MASK (new_mask), FALSE);
 
540
        }
484
541
    }
485
542
 
486
543
  return new_item;
544
601
 
545
602
            gimp_layer_transform_color (dest_image,
546
603
                                        &newPR, &layerPR,
547
 
                                        NULL,
548
 
                                        old_base_type);
 
604
                                        new_type,
 
605
                                        gimp_drawable_type (drawable));
549
606
          }
550
607
          break;
551
608
        }
569
626
                   const gchar *undo_desc)
570
627
{
571
628
  GimpLayer *layer = GIMP_LAYER (item);
572
 
  GimpImage *gimage;
 
629
  GimpImage *image = gimp_item_get_image (item);
573
630
  gboolean   attached;
574
631
  gboolean   floating_sel;
575
632
 
576
 
  gimage = gimp_item_get_image (item);
577
 
 
578
633
  attached     = gimp_item_is_attached (item);
579
634
  floating_sel = gimp_layer_is_floating_sel (layer);
580
635
 
585
640
 
586
641
      if (attached)
587
642
        {
588
 
          gimp_image_undo_group_start (gimage,
 
643
          gimp_image_undo_group_start (image,
589
644
                                       GIMP_UNDO_GROUP_ITEM_PROPERTIES,
590
645
                                       undo_desc);
591
646
 
596
651
  GIMP_ITEM_CLASS (parent_class)->rename (item, new_name, undo_desc);
597
652
 
598
653
  if (attached && floating_sel)
599
 
    gimp_image_undo_group_end (gimage);
 
654
    gimp_image_undo_group_end (image);
600
655
 
601
656
  return TRUE;
602
657
}
603
658
 
604
659
static void
605
660
gimp_layer_translate (GimpItem *item,
606
 
                      gint      offset_x,
607
 
                      gint      offset_y,
 
661
                      gint      offset_x,
 
662
                      gint      offset_y,
608
663
                      gboolean  push_undo)
609
664
{
610
665
  GimpLayer *layer = GIMP_LAYER (item);
664
719
static void
665
720
gimp_layer_resize (GimpItem    *item,
666
721
                   GimpContext *context,
667
 
                   gint         new_width,
668
 
                   gint         new_height,
669
 
                   gint         offset_x,
670
 
                   gint         offset_y)
 
722
                   gint         new_width,
 
723
                   gint         new_height,
 
724
                   gint         offset_x,
 
725
                   gint         offset_y)
671
726
{
672
727
  GimpLayer *layer  = GIMP_LAYER (item);
673
728
 
723
778
                      GimpInterpolationType   interpolation_type,
724
779
                      gboolean                supersample,
725
780
                      gint                    recursion_level,
726
 
                      gboolean                clip_result,
 
781
                      GimpTransformResize     clip_result,
727
782
                      GimpProgress           *progress)
728
783
{
729
784
  GimpLayer *layer = GIMP_LAYER (item);
730
785
 
 
786
#ifdef __GNUC__
 
787
#warning FIXME: make interpolated transformations work on layers without alpha
 
788
#endif
 
789
  if (interpolation_type != GIMP_INTERPOLATION_NONE &&
 
790
      ! gimp_drawable_has_alpha (GIMP_DRAWABLE (item)))
 
791
    gimp_layer_add_alpha (layer);
 
792
 
731
793
  GIMP_ITEM_CLASS (parent_class)->transform (item, context, matrix, direction,
732
794
                                             interpolation_type,
733
795
                                             supersample, recursion_level,
745
807
gimp_layer_invalidate_boundary (GimpDrawable *drawable)
746
808
{
747
809
  GimpLayer   *layer = GIMP_LAYER (drawable);
748
 
  GimpImage   *gimage;
 
810
  GimpImage   *image;
749
811
  GimpChannel *mask;
750
812
 
751
 
  if (! (gimage = gimp_item_get_image (GIMP_ITEM (layer))))
 
813
  if (! (image = gimp_item_get_image (GIMP_ITEM (layer))))
752
814
    return;
753
815
 
754
816
  /*  Turn the current selection off  */
755
 
  gimp_image_selection_control (gimage, GIMP_SELECTION_OFF);
 
817
  gimp_image_selection_control (image, GIMP_SELECTION_OFF);
756
818
 
757
819
  /*  clear the affected region surrounding the layer  */
758
 
  gimp_image_selection_control (gimage, GIMP_SELECTION_LAYER_OFF);
 
820
  gimp_image_selection_control (image, GIMP_SELECTION_LAYER_OFF);
759
821
 
760
822
  /*  get the selection mask channel  */
761
 
  mask = gimp_image_get_mask (gimage);
 
823
  mask = gimp_image_get_mask (image);
762
824
 
763
825
  /*  Only bother with the bounds if there is a selection  */
764
826
  if (! gimp_channel_is_empty (mask))
771
833
    floating_sel_invalidate (layer);
772
834
}
773
835
 
 
836
static gint
 
837
gimp_layer_get_opacity_at (GimpPickable *pickable,
 
838
                           gint          x,
 
839
                           gint          y)
 
840
{
 
841
  GimpLayer *layer = GIMP_LAYER (pickable);
 
842
  Tile      *tile;
 
843
  gint       val   = 0;
 
844
 
 
845
  if (x >= 0 && x < GIMP_ITEM (layer)->width &&
 
846
      y >= 0 && y < GIMP_ITEM (layer)->height &&
 
847
      gimp_item_get_visible (GIMP_ITEM (layer)))
 
848
    {
 
849
      /*  If the point is inside, and the layer has no
 
850
       *  alpha channel, success!
 
851
       */
 
852
      if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
 
853
        return OPAQUE_OPACITY;
 
854
 
 
855
      /*  Otherwise, determine if the alpha value at
 
856
       *  the given point is non-zero
 
857
       */
 
858
      tile = tile_manager_get_tile (GIMP_DRAWABLE (layer)->tiles,
 
859
                                    x, y, TRUE, FALSE);
 
860
 
 
861
      val = * ((guchar *) tile_data_pointer (tile,
 
862
                                             x % TILE_WIDTH,
 
863
                                             y % TILE_HEIGHT) +
 
864
               tile_bpp (tile) - 1);
 
865
 
 
866
      if (layer->mask)
 
867
        {
 
868
          gint mask_val;
 
869
 
 
870
          mask_val = gimp_pickable_get_opacity_at (GIMP_PICKABLE (layer->mask),
 
871
                                                   x, y);
 
872
 
 
873
          val = val * mask_val / 255;
 
874
        }
 
875
 
 
876
      tile_release (tile, FALSE);
 
877
    }
 
878
 
 
879
  return val;
 
880
}
 
881
 
774
882
static void
775
 
gimp_layer_transform_color (GimpImage         *gimage,
776
 
                            PixelRegion       *layerPR,
777
 
                            PixelRegion       *bufPR,
778
 
                            GimpDrawable      *drawable,
779
 
                            GimpImageBaseType  src_type)
 
883
gimp_layer_transform_color (GimpImage     *image,
 
884
                            PixelRegion   *layerPR,
 
885
                            PixelRegion   *bufPR,
 
886
                            GimpImageType  dest_type,
 
887
                            GimpImageType  src_type)
780
888
{
781
 
  gint      i;
782
 
  gint      h;
783
 
  guchar   *src;
784
 
  guchar   *dest;
785
 
  gpointer  pr;
 
889
  GimpImageBaseType base_type = GIMP_IMAGE_TYPE_BASE_TYPE (src_type);
 
890
  gboolean          alpha     = GIMP_IMAGE_TYPE_HAS_ALPHA (src_type);
 
891
  gpointer          pr;
786
892
 
787
893
  for (pr = pixel_regions_register (2, layerPR, bufPR);
788
894
       pr != NULL;
789
895
       pr = pixel_regions_process (pr))
790
896
    {
791
 
      h    = layerPR->h;
792
 
      src  = bufPR->data;
793
 
      dest = layerPR->data;
 
897
      const guchar *src  = bufPR->data;
 
898
      guchar       *dest = layerPR->data;
 
899
      gint          h    = layerPR->h;
794
900
 
795
901
      while (h--)
796
 
        {
797
 
          for (i = 0; i < layerPR->w; i++)
798
 
            {
799
 
              gimp_image_transform_color (gimage, drawable,
800
 
                                          dest + (i * layerPR->bytes),
801
 
                                          src_type,
802
 
                                          src  + (i * bufPR->bytes));
803
 
              /*  copy alpha channel  */
804
 
              dest[(i + 1) * layerPR->bytes - 1] = src[(i + 1) * bufPR->bytes - 1];
805
 
            }
806
 
 
807
 
          src  += bufPR->rowstride;
808
 
          dest += layerPR->rowstride;
809
 
        }
 
902
        {
 
903
          const guchar *s = src;
 
904
          guchar       *d = dest;
 
905
          gint i;
 
906
 
 
907
          for (i = 0; i < layerPR->w; i++)
 
908
            {
 
909
              gimp_image_transform_color (image, dest_type, d, base_type, s);
 
910
 
 
911
              /*  alpha channel  */
 
912
              d[layerPR->bytes - 1] = (alpha ?
 
913
                                       s[bufPR->bytes - 1] : OPAQUE_OPACITY);
 
914
 
 
915
              s += bufPR->bytes;
 
916
              d += layerPR->bytes;
 
917
            }
 
918
 
 
919
          src  += bufPR->rowstride;
 
920
          dest += layerPR->rowstride;
 
921
        }
810
922
    }
811
923
}
812
924
 
831
943
/*  public functions  */
832
944
 
833
945
GimpLayer *
834
 
gimp_layer_new (GimpImage            *gimage,
835
 
                gint                  width,
836
 
                gint                  height,
837
 
                GimpImageType         type,
838
 
                const gchar          *name,
839
 
                gdouble               opacity,
840
 
                GimpLayerModeEffects  mode)
 
946
gimp_layer_new (GimpImage            *image,
 
947
                gint                  width,
 
948
                gint                  height,
 
949
                GimpImageType         type,
 
950
                const gchar          *name,
 
951
                gdouble               opacity,
 
952
                GimpLayerModeEffects  mode)
841
953
{
842
954
  GimpLayer *layer;
843
955
 
844
 
  g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
 
956
  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
845
957
  g_return_val_if_fail (width > 0, NULL);
846
958
  g_return_val_if_fail (height > 0, NULL);
847
959
 
848
960
  layer = g_object_new (GIMP_TYPE_LAYER, NULL);
849
961
 
850
962
  gimp_drawable_configure (GIMP_DRAWABLE (layer),
851
 
                           gimage,
 
963
                           image,
852
964
                           0, 0, width, height,
853
965
                           type,
854
966
                           name);
864
976
/**
865
977
 * gimp_layer_new_from_tiles:
866
978
 * @tiles:       The buffer to make the new layer from.
867
 
 * @dest_gimage: The image the new layer will be added to.
 
979
 * @dest_image: The image the new layer will be added to.
868
980
 * @type:        The #GimpImageType of the new layer.
869
981
 * @name:        The new layer's name.
870
982
 * @opacity:     The new layer's opacity.
878
990
 **/
879
991
GimpLayer *
880
992
gimp_layer_new_from_tiles (TileManager          *tiles,
881
 
                           GimpImage            *dest_gimage,
 
993
                           GimpImage            *dest_image,
882
994
                           GimpImageType         type,
883
 
                           const gchar          *name,
884
 
                           gdouble               opacity,
885
 
                           GimpLayerModeEffects  mode)
 
995
                           const gchar          *name,
 
996
                           gdouble               opacity,
 
997
                           GimpLayerModeEffects  mode)
 
998
{
 
999
  PixelRegion bufPR;
 
1000
 
 
1001
  g_return_val_if_fail (tiles != NULL, NULL);
 
1002
  g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL);
 
1003
  g_return_val_if_fail (name != NULL, NULL);
 
1004
 
 
1005
  pixel_region_init (&bufPR, tiles,
 
1006
                     0, 0,
 
1007
                     tile_manager_width (tiles),
 
1008
                     tile_manager_height (tiles),
 
1009
                     FALSE);
 
1010
 
 
1011
  return gimp_layer_new_from_region (&bufPR, dest_image, type,
 
1012
                                     name, opacity, mode);
 
1013
}
 
1014
 
 
1015
/**
 
1016
 * gimp_layer_new_from_pixbuf:
 
1017
 * @pixbuf:      The pixbuf to make the new layer from.
 
1018
 * @dest_image: The image the new layer will be added to.
 
1019
 * @type:        The #GimpImageType of the new layer.
 
1020
 * @name:        The new layer's name.
 
1021
 * @opacity:     The new layer's opacity.
 
1022
 * @mode:        The new layer's mode.
 
1023
 *
 
1024
 * Copies %pixbuf to a layer taking into consideration the
 
1025
 * possibility of transforming the contents to meet the requirements
 
1026
 * of the target image type
 
1027
 *
 
1028
 * Return value: The new layer.
 
1029
 **/
 
1030
GimpLayer *
 
1031
gimp_layer_new_from_pixbuf (GdkPixbuf            *pixbuf,
 
1032
                            GimpImage            *dest_image,
 
1033
                            GimpImageType         type,
 
1034
                            const gchar          *name,
 
1035
                            gdouble               opacity,
 
1036
                            GimpLayerModeEffects  mode)
 
1037
{
 
1038
  PixelRegion bufPR = { 0, };
 
1039
 
 
1040
  g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
 
1041
  g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL);
 
1042
  g_return_val_if_fail (name != NULL, NULL);
 
1043
 
 
1044
  pixel_region_init_data (&bufPR, gdk_pixbuf_get_pixels (pixbuf),
 
1045
                          gdk_pixbuf_get_n_channels (pixbuf),
 
1046
                          gdk_pixbuf_get_rowstride (pixbuf),
 
1047
                          0, 0,
 
1048
                          gdk_pixbuf_get_width (pixbuf),
 
1049
                          gdk_pixbuf_get_height (pixbuf));
 
1050
 
 
1051
  return gimp_layer_new_from_region (&bufPR, dest_image, type,
 
1052
                                     name, opacity, mode);
 
1053
}
 
1054
 
 
1055
/**
 
1056
 * gimp_layer_new_from_region:
 
1057
 * @region:      A readable pixel region.
 
1058
 * @dest_image: The image the new layer will be added to.
 
1059
 * @type:        The #GimpImageType of the new layer.
 
1060
 * @name:        The new layer's name.
 
1061
 * @opacity:     The new layer's opacity.
 
1062
 * @mode:        The new layer's mode.
 
1063
 *
 
1064
 * Copies %region to a layer taking into consideration the
 
1065
 * possibility of transforming the contents to meet the requirements
 
1066
 * of the target image type
 
1067
 *
 
1068
 * Return value: The new layer.
 
1069
 **/
 
1070
GimpLayer *
 
1071
gimp_layer_new_from_region (PixelRegion          *region,
 
1072
                            GimpImage            *dest_image,
 
1073
                            GimpImageType         type,
 
1074
                            const gchar          *name,
 
1075
                            gdouble               opacity,
 
1076
                            GimpLayerModeEffects  mode)
886
1077
{
887
1078
  GimpLayer     *new_layer;
888
1079
  PixelRegion    layerPR;
889
 
  PixelRegion    bufPR;
890
1080
  GimpImageType  src_type;
891
1081
  gint           width;
892
1082
  gint           height;
893
1083
 
894
 
  g_return_val_if_fail (tiles != NULL, NULL);
895
 
  g_return_val_if_fail (GIMP_IS_IMAGE (dest_gimage), NULL);
 
1084
  g_return_val_if_fail (region != NULL, NULL);
 
1085
  g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL);
896
1086
  g_return_val_if_fail (name != NULL, NULL);
897
1087
 
898
 
  width  = tile_manager_width (tiles);
899
 
  height = tile_manager_height (tiles);
 
1088
  width  = region->w;
 
1089
  height = region->h;
900
1090
 
901
 
  switch (tile_manager_bpp (tiles))
 
1091
  switch (region->bytes)
902
1092
    {
903
1093
    case 1: src_type = GIMP_GRAY_IMAGE;  break;
904
1094
    case 2: src_type = GIMP_GRAYA_IMAGE; break;
909
1099
      break;
910
1100
    }
911
1101
 
912
 
  new_layer = gimp_layer_new (dest_gimage, width, height, type, name,
913
 
                              opacity, mode);
 
1102
  new_layer = gimp_layer_new (dest_image, width, height, type, name,
 
1103
                              opacity, mode);
914
1104
 
915
1105
  if (! new_layer)
916
1106
    {
917
 
      g_message ("gimp_layer_new_from_tiles: could not allocate new layer");
 
1107
      g_warning ("%s: could not allocate new layer", G_STRFUNC);
918
1108
      return NULL;
919
1109
    }
920
1110
 
921
 
  /*  Configure the pixel regions  */
922
 
  pixel_region_init (&bufPR, tiles,
923
 
                     0, 0, width, height,
924
 
                     FALSE);
925
1111
  pixel_region_init (&layerPR, GIMP_DRAWABLE (new_layer)->tiles,
926
 
                     0, 0, width, height,
927
 
                     TRUE);
 
1112
                     0, 0, width, height,
 
1113
                     TRUE);
928
1114
 
929
1115
  switch (type)
930
1116
    {
932
1118
      switch (src_type)
933
1119
        {
934
1120
       case GIMP_RGB_IMAGE:
935
 
          copy_region (&bufPR, &layerPR);
 
1121
          copy_region (region, &layerPR);
936
1122
          break;
937
1123
        default:
938
1124
          g_warning ("%s: unhandled type conversion", G_STRFUNC);
944
1130
      switch (src_type)
945
1131
        {
946
1132
        case GIMP_RGBA_IMAGE:
947
 
          copy_region (&bufPR, &layerPR);
 
1133
          copy_region (region, &layerPR);
948
1134
          break;
949
1135
        case GIMP_RGB_IMAGE:
950
 
          add_alpha_region (&bufPR, &layerPR);
 
1136
          add_alpha_region (region, &layerPR);
951
1137
          break;
 
1138
        case GIMP_GRAY_IMAGE:
952
1139
        case GIMP_GRAYA_IMAGE:
953
 
          gimp_layer_transform_color (dest_gimage, &layerPR, &bufPR,
954
 
                                      GIMP_DRAWABLE (new_layer), GIMP_GRAY);
 
1140
          gimp_layer_transform_color (dest_image, &layerPR, region,
 
1141
                                      type, src_type);
955
1142
          break;
956
1143
        default:
957
1144
          g_warning ("%s: unhandled type conversion", G_STRFUNC);
963
1150
      switch (src_type)
964
1151
        {
965
1152
        case GIMP_GRAY_IMAGE:
966
 
          copy_region (&bufPR, &layerPR);
 
1153
          copy_region (region, &layerPR);
967
1154
          break;
968
1155
        default:
969
1156
          g_warning ("%s: unhandled type conversion", G_STRFUNC);
974
1161
    case GIMP_GRAYA_IMAGE:
975
1162
      switch (src_type)
976
1163
        {
 
1164
        case GIMP_RGB_IMAGE:
977
1165
        case GIMP_RGBA_IMAGE:
978
 
          gimp_layer_transform_color (dest_gimage, &layerPR, &bufPR,
979
 
                                      GIMP_DRAWABLE (new_layer), GIMP_RGB);
 
1166
          gimp_layer_transform_color (dest_image, &layerPR, region,
 
1167
                                      type, src_type);
980
1168
          break;
981
1169
        case GIMP_GRAYA_IMAGE:
982
 
          copy_region (&bufPR, &layerPR);
 
1170
          copy_region (region, &layerPR);
983
1171
          break;
984
1172
        case GIMP_GRAY_IMAGE:
985
 
          add_alpha_region (&bufPR, &layerPR);
 
1173
          add_alpha_region (region, &layerPR);
986
1174
          break;
987
1175
        default:
988
1176
          g_warning ("%s: unhandled type conversion", G_STRFUNC);
997
1185
    case GIMP_INDEXEDA_IMAGE:
998
1186
      switch (src_type)
999
1187
        {
 
1188
        case GIMP_RGB_IMAGE:
1000
1189
        case GIMP_RGBA_IMAGE:
1001
 
          gimp_layer_transform_color (dest_gimage, &layerPR, &bufPR,
1002
 
                                      GIMP_DRAWABLE (new_layer), GIMP_RGB);
 
1190
          gimp_layer_transform_color (dest_image, &layerPR, region,
 
1191
                                      type, src_type);
1003
1192
          break;
 
1193
        case GIMP_GRAY_IMAGE:
1004
1194
        case GIMP_GRAYA_IMAGE:
1005
 
          gimp_layer_transform_color (dest_gimage, &layerPR, &bufPR,
1006
 
                                      GIMP_DRAWABLE (new_layer), GIMP_GRAY);
 
1195
          gimp_layer_transform_color (dest_image, &layerPR, region,
 
1196
                                      type, src_type);
1007
1197
          break;
1008
1198
        default:
1009
1199
          g_warning ("%s: unhandled type conversion", G_STRFUNC);
1017
1207
 
1018
1208
GimpLayerMask *
1019
1209
gimp_layer_add_mask (GimpLayer     *layer,
1020
 
                     GimpLayerMask *mask,
 
1210
                     GimpLayerMask *mask,
1021
1211
                     gboolean       push_undo)
1022
1212
{
1023
 
  GimpImage *gimage;
 
1213
  GimpImage *image;
1024
1214
 
1025
1215
  g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
1026
1216
  g_return_val_if_fail (GIMP_IS_LAYER_MASK (mask), NULL);
1028
1218
  if (! gimp_item_is_attached (GIMP_ITEM (layer)))
1029
1219
    push_undo = FALSE;
1030
1220
 
1031
 
  gimage = gimp_item_get_image (GIMP_ITEM (layer));
 
1221
  image = gimp_item_get_image (GIMP_ITEM (layer));
1032
1222
 
1033
 
  if (! gimage)
 
1223
  if (! image)
1034
1224
    {
1035
1225
      g_message (_("Cannot add layer mask to layer "
1036
1226
                   "which is not part of an image."));
1040
1230
  if (layer->mask)
1041
1231
    {
1042
1232
      g_message (_("Unable to add a layer mask since "
1043
 
                   "the layer already has one."));
1044
 
      return NULL;
1045
 
    }
1046
 
 
1047
 
  if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
1048
 
    {
1049
 
      g_message (_("Cannot add layer mask to a layer "
1050
 
                   "with no alpha channel."));
 
1233
                   "the layer already has one."));
1051
1234
      return NULL;
1052
1235
    }
1053
1236
 
1062
1245
    }
1063
1246
 
1064
1247
  if (push_undo)
1065
 
    gimp_image_undo_push_layer_mask_add (gimage, _("Add Layer Mask"),
 
1248
    gimp_image_undo_push_layer_mask_add (image, _("Add Layer Mask"),
1066
1249
                                         layer, mask);
1067
1250
 
1068
 
  layer->mask = g_object_ref (mask);
1069
 
  gimp_item_sink (GIMP_ITEM (layer->mask));
 
1251
  layer->mask = g_object_ref_sink (mask);
1070
1252
 
1071
1253
  gimp_layer_mask_set_layer (mask, layer);
1072
1254
 
1089
1271
 
1090
1272
GimpLayerMask *
1091
1273
gimp_layer_create_mask (const GimpLayer *layer,
1092
 
                        GimpAddMaskType  add_mask_type)
 
1274
                        GimpAddMaskType  add_mask_type,
 
1275
                        GimpChannel     *channel)
1093
1276
{
1094
1277
  GimpDrawable  *drawable;
1095
1278
  GimpItem      *item;
1096
1279
  PixelRegion    srcPR;
1097
1280
  PixelRegion    destPR;
1098
1281
  GimpLayerMask *mask;
1099
 
  GimpImage     *gimage;
 
1282
  GimpImage     *image;
1100
1283
  gchar         *mask_name;
1101
1284
  GimpRGB        black = { 0.0, 0.0, 0.0, GIMP_OPACITY_OPAQUE };
1102
1285
 
1103
1286
  g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL);
 
1287
  g_return_val_if_fail (add_mask_type != GIMP_ADD_CHANNEL_MASK ||
 
1288
                        GIMP_IS_CHANNEL (channel), NULL);
1104
1289
 
1105
1290
  drawable = GIMP_DRAWABLE (layer);
1106
1291
  item     = GIMP_ITEM (layer);
1107
 
  gimage   = gimp_item_get_image (item);
 
1292
  image    = gimp_item_get_image (item);
1108
1293
 
1109
1294
  mask_name = g_strdup_printf (_("%s mask"),
1110
 
                               gimp_object_get_name (GIMP_OBJECT (layer)));
 
1295
                               gimp_object_get_name (GIMP_OBJECT (layer)));
1111
1296
 
1112
 
  mask = gimp_layer_mask_new (gimage,
1113
 
                              item->width,
1114
 
                              item->height,
1115
 
                              mask_name, &black);
 
1297
  mask = gimp_layer_mask_new (image,
 
1298
                              item->width,
 
1299
                              item->height,
 
1300
                              mask_name, &black);
1116
1301
 
1117
1302
  g_free (mask_name);
1118
1303
 
1130
1315
      break;
1131
1316
    }
1132
1317
 
1133
 
  pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
1134
 
                     0, 0,
1135
 
                     GIMP_ITEM (mask)->width,
 
1318
  pixel_region_init (&destPR, gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)),
 
1319
                     0, 0,
 
1320
                     GIMP_ITEM (mask)->width,
1136
1321
                     GIMP_ITEM (mask)->height,
1137
 
                     TRUE);
 
1322
                     TRUE);
1138
1323
 
1139
1324
  switch (add_mask_type)
1140
1325
    {
1145
1330
    case GIMP_ADD_ALPHA_MASK:
1146
1331
    case GIMP_ADD_ALPHA_TRANSFER_MASK:
1147
1332
      if (gimp_drawable_has_alpha (drawable))
1148
 
        {
1149
 
          pixel_region_init (&srcPR, drawable->tiles,
1150
 
                             0, 0,
1151
 
                             item->width, item->height,
1152
 
                             FALSE);
 
1333
        {
 
1334
          pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
 
1335
                             0, 0,
 
1336
                             item->width, item->height,
 
1337
                             FALSE);
1153
1338
 
1154
 
          extract_alpha_region (&srcPR, NULL, &destPR);
 
1339
          extract_alpha_region (&srcPR, NULL, &destPR);
1155
1340
 
1156
1341
          if (add_mask_type == GIMP_ADD_ALPHA_TRANSFER_MASK)
1157
1342
            {
1159
1344
              gint    w, h;
1160
1345
              guchar *alpha_ptr;
1161
1346
 
1162
 
              gimp_drawable_push_undo (GIMP_DRAWABLE (layer),
 
1347
              gimp_drawable_push_undo (drawable,
1163
1348
                                       _("Transfer Alpha to Mask"),
1164
1349
                                       0, 0,
1165
1350
                                       item->width,
1166
1351
                                       item->height,
1167
1352
                                       NULL, FALSE);
1168
1353
 
1169
 
              pixel_region_init (&srcPR, drawable->tiles,
 
1354
              pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
1170
1355
                                 0, 0,
1171
1356
                                 item->width, item->height,
1172
1357
                                 TRUE);
1191
1376
                    }
1192
1377
                }
1193
1378
            }
1194
 
        }
 
1379
        }
1195
1380
      break;
1196
1381
 
1197
1382
    case GIMP_ADD_SELECTION_MASK:
 
1383
    case GIMP_ADD_CHANNEL_MASK:
1198
1384
      {
1199
 
        GimpChannel *selection;
1200
 
        gboolean     selection_empty;
1201
 
        gint         copy_x, copy_y;
1202
 
        gint         copy_width, copy_height;
1203
 
 
1204
 
        selection       = gimp_image_get_mask (gimage);
1205
 
        selection_empty = gimp_channel_is_empty (selection);
1206
 
 
1207
 
        gimp_rectangle_intersect (0, 0, gimage->width, gimage->height,
 
1385
        gboolean channel_empty;
 
1386
        gint     copy_x, copy_y;
 
1387
        gint     copy_width, copy_height;
 
1388
 
 
1389
        if (add_mask_type == GIMP_ADD_SELECTION_MASK)
 
1390
          channel = GIMP_CHANNEL (gimp_image_get_mask (image));
 
1391
 
 
1392
        channel_empty = gimp_channel_is_empty (channel);
 
1393
 
 
1394
        gimp_rectangle_intersect (0, 0, image->width, image->height,
1208
1395
                                  item->offset_x, item->offset_y,
1209
1396
                                  item->width, item->height,
1210
1397
                                  &copy_x, &copy_y, &copy_width, &copy_height);
1211
1398
 
1212
 
        if (copy_width < item->width || copy_height < item->height ||
1213
 
            selection_empty)
 
1399
        if (copy_width  < item->width  ||
 
1400
            copy_height < item->height ||
 
1401
            channel_empty)
1214
1402
          gimp_channel_clear (GIMP_CHANNEL (mask), NULL, FALSE);
1215
1403
 
1216
 
        if ((copy_width || copy_height) && ! selection_empty)
 
1404
        if ((copy_width || copy_height) && ! channel_empty)
1217
1405
          {
1218
 
            pixel_region_init (&srcPR, GIMP_DRAWABLE (selection)->tiles,
 
1406
            pixel_region_init (&srcPR,
 
1407
                               gimp_drawable_get_tiles (GIMP_DRAWABLE (channel)),
1219
1408
                               copy_x, copy_y,
1220
1409
                               copy_width, copy_height,
1221
1410
                               FALSE);
1222
 
            pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
 
1411
            pixel_region_init (&destPR,
 
1412
                               gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)),
1223
1413
                               copy_x - item->offset_x, copy_y - item->offset_y,
1224
1414
                               copy_width, copy_height,
1225
1415
                               TRUE);
1261
1451
          }
1262
1452
        else
1263
1453
          {
1264
 
            pixel_region_init (&srcPR, drawable->tiles,
 
1454
            pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
1265
1455
                               0, 0,
1266
1456
                               item->width,
1267
1457
                               item->height,
1292
1482
 
1293
1483
void
1294
1484
gimp_layer_apply_mask (GimpLayer         *layer,
1295
 
                       GimpMaskApplyMode  mode,
 
1485
                       GimpMaskApplyMode  mode,
1296
1486
                       gboolean           push_undo)
1297
1487
{
1298
1488
  GimpItem    *item;
1299
 
  GimpImage   *gimage;
 
1489
  GimpImage   *image;
1300
1490
  PixelRegion  srcPR, maskPR;
1301
1491
  gboolean     view_changed = FALSE;
1302
1492
 
1311
1501
 
1312
1502
  item = GIMP_ITEM (layer);
1313
1503
 
1314
 
  gimage = gimp_item_get_image (item);
 
1504
  image = gimp_item_get_image (item);
1315
1505
 
1316
 
  if (! gimage)
 
1506
  if (! image)
1317
1507
    return;
1318
1508
 
1319
1509
  if (push_undo)
1320
1510
    {
1321
 
      gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_LAYER_APPLY_MASK,
 
1511
      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_LAYER_APPLY_MASK,
1322
1512
                                   (mode == GIMP_MASK_APPLY) ?
1323
1513
                                   _("Apply Layer Mask") :
1324
1514
                                   _("Delete Layer Mask"));
1325
1515
 
1326
 
      gimp_image_undo_push_layer_mask_remove (gimage, NULL, layer, layer->mask);
 
1516
      gimp_image_undo_push_layer_mask_remove (image, NULL, layer, layer->mask);
1327
1517
    }
1328
1518
 
1329
1519
  /*  check if applying the mask changes the projection  */
1345
1535
 
1346
1536
      /*  Combine the current layer's alpha channel and the mask  */
1347
1537
      pixel_region_init (&srcPR, GIMP_DRAWABLE (layer)->tiles,
1348
 
                         0, 0,
1349
 
                         item->width,
1350
 
                         item->height,
1351
 
                         TRUE);
 
1538
                         0, 0,
 
1539
                         item->width,
 
1540
                         item->height,
 
1541
                         TRUE);
1352
1542
      pixel_region_init (&maskPR, GIMP_DRAWABLE (layer->mask)->tiles,
1353
 
                         0, 0,
1354
 
                         item->width,
1355
 
                         item->height,
1356
 
                         FALSE);
 
1543
                         0, 0,
 
1544
                         item->width,
 
1545
                         item->height,
 
1546
                         FALSE);
1357
1547
 
1358
1548
      apply_mask_to_region (&srcPR, &maskPR, OPAQUE_OPACITY);
1359
1549
    }
1367
1557
  layer->mask = NULL;
1368
1558
 
1369
1559
  if (push_undo)
1370
 
    gimp_image_undo_group_end (gimage);
 
1560
    gimp_image_undo_group_end (image);
1371
1561
 
1372
1562
  /*  If applying actually changed the view  */
1373
1563
  if (view_changed)
1374
1564
    {
1375
1565
      gimp_drawable_update (GIMP_DRAWABLE (layer),
1376
 
                            0, 0,
1377
 
                            item->width,
1378
 
                            item->height);
 
1566
                            0, 0,
 
1567
                            item->width,
 
1568
                            item->height);
1379
1569
    }
1380
1570
  else
1381
1571
    {
1401
1591
 
1402
1592
  /*  Allocate the new tiles  */
1403
1593
  new_tiles = tile_manager_new (GIMP_ITEM (layer)->width,
1404
 
                                GIMP_ITEM (layer)->height,
1405
 
                                GIMP_IMAGE_TYPE_BYTES (new_type));
 
1594
                                GIMP_ITEM (layer)->height,
 
1595
                                GIMP_IMAGE_TYPE_BYTES (new_type));
1406
1596
 
1407
1597
  /*  Configure the pixel regions  */
1408
1598
  pixel_region_init (&srcPR, GIMP_DRAWABLE (layer)->tiles,
1409
 
                     0, 0,
1410
 
                     GIMP_ITEM (layer)->width,
1411
 
                     GIMP_ITEM (layer)->height,
1412
 
                     FALSE);
 
1599
                     0, 0,
 
1600
                     GIMP_ITEM (layer)->width,
 
1601
                     GIMP_ITEM (layer)->height,
 
1602
                     FALSE);
1413
1603
  pixel_region_init (&destPR, new_tiles,
1414
 
                     0, 0,
1415
 
                     GIMP_ITEM (layer)->width,
1416
 
                     GIMP_ITEM (layer)->height,
1417
 
                     TRUE);
 
1604
                     0, 0,
 
1605
                     GIMP_ITEM (layer)->width,
 
1606
                     GIMP_ITEM (layer)->height,
 
1607
                     TRUE);
1418
1608
 
1419
1609
  /*  Add an alpha channel  */
1420
1610
  add_alpha_region (&srcPR, &destPR);
1430
1620
}
1431
1621
 
1432
1622
void
 
1623
gimp_layer_flatten (GimpLayer   *layer,
 
1624
                    GimpContext *context)
 
1625
{
 
1626
  PixelRegion    srcPR, destPR;
 
1627
  TileManager   *new_tiles;
 
1628
  GimpImageType  new_type;
 
1629
  guchar         bg[4];
 
1630
 
 
1631
  g_return_if_fail (GIMP_IS_LAYER (layer));
 
1632
  g_return_if_fail (GIMP_IS_CONTEXT (context));
 
1633
 
 
1634
  if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
 
1635
    return;
 
1636
 
 
1637
  new_type = gimp_drawable_type_without_alpha (GIMP_DRAWABLE (layer));
 
1638
 
 
1639
  gimp_image_get_background (gimp_item_get_image (GIMP_ITEM (layer)), context,
 
1640
                             gimp_drawable_type (GIMP_DRAWABLE (layer)),
 
1641
                             bg);
 
1642
 
 
1643
  /*  Allocate the new tiles  */
 
1644
  new_tiles = tile_manager_new (GIMP_ITEM (layer)->width,
 
1645
                                GIMP_ITEM (layer)->height,
 
1646
                                GIMP_IMAGE_TYPE_BYTES (new_type));
 
1647
 
 
1648
  /*  Configure the pixel regions  */
 
1649
  pixel_region_init (&srcPR, GIMP_DRAWABLE (layer)->tiles,
 
1650
                     0, 0,
 
1651
                     GIMP_ITEM (layer)->width,
 
1652
                     GIMP_ITEM (layer)->height,
 
1653
                     FALSE);
 
1654
  pixel_region_init (&destPR, new_tiles,
 
1655
                     0, 0,
 
1656
                     GIMP_ITEM (layer)->width,
 
1657
                     GIMP_ITEM (layer)->height,
 
1658
                     TRUE);
 
1659
 
 
1660
  /*  Remove alpha channel  */
 
1661
  flatten_region (&srcPR, &destPR, bg);
 
1662
 
 
1663
  /*  Set the new tiles  */
 
1664
  gimp_drawable_set_tiles_full (GIMP_DRAWABLE (layer),
 
1665
                                gimp_item_is_attached (GIMP_ITEM (layer)),
 
1666
                                _("Remove Alpha Channel"),
 
1667
                                new_tiles, new_type,
 
1668
                                GIMP_ITEM (layer)->offset_x,
 
1669
                                GIMP_ITEM (layer)->offset_y);
 
1670
  tile_manager_unref (new_tiles);
 
1671
}
 
1672
 
 
1673
void
1433
1674
gimp_layer_resize_to_image (GimpLayer   *layer,
1434
1675
                            GimpContext *context)
1435
1676
{
1436
 
  GimpImage *gimage;
 
1677
  GimpImage *image;
1437
1678
  gint       offset_x;
1438
1679
  gint       offset_y;
1439
1680
 
1441
1682
  g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (layer)));
1442
1683
  g_return_if_fail (GIMP_IS_CONTEXT (context));
1443
1684
 
1444
 
  gimage = gimp_item_get_image (GIMP_ITEM (layer));
 
1685
  image = gimp_item_get_image (GIMP_ITEM (layer));
1445
1686
 
1446
 
  gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_ITEM_RESIZE,
 
1687
  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_ITEM_RESIZE,
1447
1688
                               _("Layer to Image Size"));
1448
1689
 
1449
1690
  gimp_item_offsets (GIMP_ITEM (layer), &offset_x, &offset_y);
1450
1691
  gimp_item_resize (GIMP_ITEM (layer), context,
1451
 
                    gimage->width, gimage->height, offset_x, offset_y);
 
1692
                    image->width, image->height, offset_x, offset_y);
1452
1693
 
1453
 
  gimp_image_undo_group_end (gimage);
 
1694
  gimp_image_undo_group_end (image);
1454
1695
}
1455
1696
 
1456
1697
BoundSeg *
1457
1698
gimp_layer_boundary (GimpLayer *layer,
1458
 
                     gint      *num_segs)
 
1699
                     gint      *num_segs)
1459
1700
{
1460
1701
  GimpItem *item;
1461
1702
  BoundSeg *new_segs;
1474
1715
  if (gimp_layer_is_floating_sel (layer))
1475
1716
    {
1476
1717
      if (GIMP_IS_CHANNEL (layer->fs.drawable))
1477
 
        {
1478
 
          /*  if the owner drawable is a channel, just return nothing  */
 
1718
        {
 
1719
          /*  if the owner drawable is a channel, just return nothing  */
1479
1720
 
1480
 
          g_free (new_segs);
1481
 
          *num_segs = 0;
1482
 
          return NULL;
1483
 
        }
 
1721
          g_free (new_segs);
 
1722
          *num_segs = 0;
 
1723
          return NULL;
 
1724
        }
1484
1725
      else
1485
 
        {
1486
 
          /*  otherwise, set the layer to the owner drawable  */
 
1726
        {
 
1727
          /*  otherwise, set the layer to the owner drawable  */
1487
1728
 
1488
 
          layer = GIMP_LAYER (layer->fs.drawable);
1489
 
        }
 
1729
          layer = GIMP_LAYER (layer->fs.drawable);
 
1730
        }
1490
1731
    }
1491
1732
 
1492
1733
  new_segs[0].x1   = item->offset_x;
1516
1757
  return new_segs;
1517
1758
}
1518
1759
 
1519
 
gboolean
1520
 
gimp_layer_pick_correlate (GimpLayer *layer,
1521
 
                           gint       x,
1522
 
                           gint       y)
1523
 
{
1524
 
  Tile *tile;
1525
 
  Tile *mask_tile;
1526
 
  gint  val;
1527
 
 
1528
 
  g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
1529
 
 
1530
 
  /*  Is the point inside the layer?
1531
 
   *  First transform the point to layer coordinates...
1532
 
   */
1533
 
  x -= GIMP_ITEM (layer)->offset_x;
1534
 
  y -= GIMP_ITEM (layer)->offset_y;
1535
 
 
1536
 
  if (x >= 0 && x < GIMP_ITEM (layer)->width &&
1537
 
      y >= 0 && y < GIMP_ITEM (layer)->height &&
1538
 
      gimp_item_get_visible (GIMP_ITEM (layer)))
1539
 
    {
1540
 
      /*  If the point is inside, and the layer has no
1541
 
       *  alpha channel, success!
1542
 
       */
1543
 
      if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (layer)))
1544
 
        return TRUE;
1545
 
 
1546
 
      /*  Otherwise, determine if the alpha value at
1547
 
       *  the given point is non-zero
1548
 
       */
1549
 
      tile = tile_manager_get_tile (GIMP_DRAWABLE (layer)->tiles,
1550
 
                                    x, y, TRUE, FALSE);
1551
 
 
1552
 
      val = * ((guchar *) tile_data_pointer (tile,
1553
 
                                             x % TILE_WIDTH,
1554
 
                                             y % TILE_HEIGHT) +
1555
 
               tile_bpp (tile) - 1);
1556
 
 
1557
 
      if (layer->mask)
1558
 
        {
1559
 
          guchar *ptr;
1560
 
 
1561
 
          mask_tile = tile_manager_get_tile (GIMP_DRAWABLE (layer->mask)->tiles,
1562
 
                                             x, y, TRUE, FALSE);
1563
 
          ptr = tile_data_pointer (mask_tile, x % TILE_WIDTH, y % TILE_HEIGHT);
1564
 
          val = val * (*ptr) / 255;
1565
 
          tile_release (mask_tile, FALSE);
1566
 
        }
1567
 
 
1568
 
      tile_release (tile, FALSE);
1569
 
 
1570
 
      if (val > 63)
1571
 
        return TRUE;
1572
 
    }
1573
 
 
1574
 
  return FALSE;
1575
 
}
1576
 
 
1577
1760
/**********************/
1578
1761
/*  access functions  */
1579
1762
/**********************/
1607
1790
    {
1608
1791
      if (push_undo && gimp_item_is_attached (GIMP_ITEM (layer)))
1609
1792
        {
1610
 
          GimpImage *gimage = gimp_item_get_image (GIMP_ITEM (layer));
 
1793
          GimpImage *image = gimp_item_get_image (GIMP_ITEM (layer));
1611
1794
 
1612
 
          if (gimage)
1613
 
            gimp_image_undo_push_layer_opacity (gimage, NULL, layer);
 
1795
          gimp_image_undo_push_layer_opacity (image, NULL, layer);
1614
1796
        }
1615
1797
 
1616
1798
      layer->opacity = opacity;
1617
1799
 
1618
1800
      g_signal_emit (layer, layer_signals[OPACITY_CHANGED], 0);
 
1801
      g_object_notify (G_OBJECT (layer), "opacity");
1619
1802
 
1620
1803
      gimp_drawable_update (GIMP_DRAWABLE (layer),
1621
 
                            0, 0,
1622
 
                            GIMP_ITEM (layer)->width,
1623
 
                            GIMP_ITEM (layer)->height);
 
1804
                            0, 0,
 
1805
                            GIMP_ITEM (layer)->width,
 
1806
                            GIMP_ITEM (layer)->height);
1624
1807
    }
1625
1808
}
1626
1809
 
1643
1826
    {
1644
1827
      if (push_undo && gimp_item_is_attached (GIMP_ITEM (layer)))
1645
1828
        {
1646
 
          GimpImage *gimage = gimp_item_get_image (GIMP_ITEM (layer));
 
1829
          GimpImage *image = gimp_item_get_image (GIMP_ITEM (layer));
1647
1830
 
1648
 
          if (gimage)
1649
 
            gimp_image_undo_push_layer_mode (gimage, NULL, layer);
 
1831
          gimp_image_undo_push_layer_mode (image, NULL, layer);
1650
1832
        }
1651
1833
 
1652
1834
      layer->mode = mode;
1653
1835
 
1654
1836
      g_signal_emit (layer, layer_signals[MODE_CHANGED], 0);
 
1837
      g_object_notify (G_OBJECT (layer), "mode");
1655
1838
 
1656
1839
      gimp_drawable_update (GIMP_DRAWABLE (layer),
1657
 
                            0, 0,
1658
 
                            GIMP_ITEM (layer)->width,
1659
 
                            GIMP_ITEM (layer)->height);
 
1840
                            0, 0,
 
1841
                            GIMP_ITEM (layer)->width,
 
1842
                            GIMP_ITEM (layer)->height);
1660
1843
    }
1661
1844
}
1662
1845
 
1669
1852
}
1670
1853
 
1671
1854
void
1672
 
gimp_layer_set_preserve_trans (GimpLayer *layer,
1673
 
                               gboolean   preserve,
1674
 
                               gboolean   push_undo)
 
1855
gimp_layer_set_lock_alpha (GimpLayer *layer,
 
1856
                           gboolean   lock_alpha,
 
1857
                           gboolean   push_undo)
1675
1858
{
1676
1859
  g_return_if_fail (GIMP_IS_LAYER (layer));
1677
1860
 
1678
 
  if (layer->preserve_trans != preserve)
 
1861
  lock_alpha = lock_alpha ? TRUE : FALSE;
 
1862
 
 
1863
  if (layer->lock_alpha != lock_alpha)
1679
1864
    {
1680
1865
      if (push_undo && gimp_item_is_attached (GIMP_ITEM (layer)))
1681
1866
        {
1682
 
          GimpImage *gimage = gimp_item_get_image (GIMP_ITEM (layer));
 
1867
          GimpImage *image = gimp_item_get_image (GIMP_ITEM (layer));
1683
1868
 
1684
 
          if (gimage)
1685
 
            gimp_image_undo_push_layer_preserve_trans (gimage, NULL, layer);
 
1869
          gimp_image_undo_push_layer_lock_alpha (image, NULL, layer);
1686
1870
        }
1687
1871
 
1688
 
      layer->preserve_trans = preserve ? TRUE : FALSE;
 
1872
      layer->lock_alpha = lock_alpha;
1689
1873
 
1690
 
      g_signal_emit (layer, layer_signals[PRESERVE_TRANS_CHANGED], 0);
 
1874
      g_signal_emit (layer, layer_signals[LOCK_ALPHA_CHANGED], 0);
 
1875
      g_object_notify (G_OBJECT (layer), "lock-alpha");
1691
1876
    }
1692
1877
}
1693
1878
 
1694
1879
gboolean
1695
 
gimp_layer_get_preserve_trans (const GimpLayer *layer)
 
1880
gimp_layer_get_lock_alpha (const GimpLayer *layer)
1696
1881
{
1697
1882
  g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
1698
1883
 
1699
 
  return layer->preserve_trans;
 
1884
  return layer->lock_alpha;
1700
1885
}