← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/core/gimpprojection-construct.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/gimpprojection-construct.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
29
29
 
30
30
#include "paint-funcs/paint-funcs.h"
31
31
 
 
32
#include "gimpdrawable.h"
32
33
#include "gimpimage.h"
33
34
#include "gimplayer.h"
34
35
#include "gimplayer-floating-sel.h"
69
70
static void   project_indexed                    (GimpProjection *proj,
70
71
                                                  GimpLayer      *layer,
71
72
                                                  PixelRegion    *src,
72
 
                                                  PixelRegion    *dest);
 
73
                                                  PixelRegion    *dest,
 
74
                                                  PixelRegion    *mask);
73
75
static void   project_indexed_alpha              (GimpProjection *proj,
74
76
                                                  GimpLayer      *layer,
75
77
                                                  PixelRegion    *src,
93
95
  g_return_if_fail (GIMP_IS_PROJECTION (proj));
94
96
 
95
97
#if 0
96
 
  gint xoff;
97
 
  gint yoff;
98
 
 
99
 
  /*  set the construct flag, used to determine if anything
100
 
   *  has been written to the gimage raw image yet.
101
 
   */
102
 
  gimage->construct_flag = FALSE;
103
 
 
104
 
  if (gimage->layers)
105
 
    {
106
 
      gimp_item_offsets (GIMP_ITEM (gimage->layers->data), &xoff, &yoff);
107
 
    }
108
 
 
109
 
  if ((gimage->layers) &&                         /* There's a layer.      */
110
 
      (! g_slist_next (gimage->layers)) &&        /* It's the only layer.  */
111
 
      (gimp_drawable_has_alpha (GIMP_DRAWABLE (gimage->layers->data))) &&
112
 
                                                  /* It's !flat.           */
113
 
      (gimp_item_get_visible (GIMP_ITEM (gimage->layers->data))) &&
114
 
                                                  /* It's visible.         */
115
 
      (gimp_item_width  (GIMP_ITEM (gimage->layers->data)) ==
116
 
       gimage->width) &&
117
 
      (gimp_item_height (GIMP_ITEM (gimage->layers->data)) ==
118
 
       gimage->height) &&                         /* Covers all.           */
119
 
      (!gimp_drawable_is_indexed (GIMP_DRAWABLE (gimage->layers->data))) &&
120
 
                                                  /* Not indexed.          */
121
 
      (((GimpLayer *)(gimage->layers->data))->opacity == GIMP_OPACITY_OPAQUE)
122
 
                                                  /* Opaque                */
123
 
      )
124
 
    {
125
 
      gint xoff;
126
 
      gint yoff;
127
 
 
128
 
      gimp_item_offsets (GIMP_ITEM (gimage->layers->data), &xoff, &yoff);
129
 
 
130
 
      if ((xoff==0) && (yoff==0)) /* Starts at 0,0         */
131
 
        {
132
 
          PixelRegion srcPR, destPR;
133
 
          gpointer    pr;
134
 
 
135
 
          g_warning("Can use cow-projection hack.  Yay!");
136
 
 
137
 
          pixel_region_init (&srcPR, gimp_drawable_data
138
 
                             (GIMP_DRAWABLE (gimage->layers->data)),
139
 
                             x, y, w,h, FALSE);
140
 
          pixel_region_init (&destPR,
141
 
                             gimp_image_projection (gimage),
142
 
                             x, y, w,h, TRUE);
143
 
 
144
 
          for (pr = pixel_regions_register (2, &srcPR, &destPR);
145
 
               pr != NULL;
146
 
               pr = pixel_regions_process (pr))
147
 
            {
148
 
              tile_manager_map_over_tile (destPR.tiles,
149
 
                                          destPR.curtile, srcPR.curtile);
150
 
            }
151
 
 
152
 
          gimage->construct_flag = TRUE;
153
 
          gimp_image_construct_channels (gimage, x, y, w, h);
154
 
 
155
 
          return;
156
 
        }
157
 
    }
158
 
#else
 
98
  GimpImage *image = proj->image;
 
99
 
 
100
  if ((gimp_container_num_children (image->layers) == 1)) /* a single layer */
 
101
    {
 
102
      GimpDrawable *layer;
 
103
 
 
104
      layer = GIMP_DRAWABLE (gimp_container_get_child_by_index (image->layers,
 
105
                                                                0));
 
106
 
 
107
      if (gimp_drawable_has_alpha (layer)                         &&
 
108
          (gimp_item_get_visible (GIMP_ITEM (layer)))             &&
 
109
          (gimp_item_width (GIMP_ITEM (layer))  == image->width)  &&
 
110
          (gimp_item_height (GIMP_ITEM (layer)) == image->height) &&
 
111
          (! gimp_drawable_is_indexed (layer))                    &&
 
112
          (gimp_layer_get_opacity (GIMP_LAYER (layer)) == GIMP_OPACITY_OPAQUE))
 
113
        {
 
114
          gint xoff;
 
115
          gint yoff;
 
116
 
 
117
          gimp_item_offsets (GIMP_ITEM (layer), &xoff, &yoff);
 
118
 
 
119
          if (xoff == 0 && yoff == 0)
 
120
            {
 
121
              PixelRegion srcPR, destPR;
 
122
 
 
123
              g_printerr ("cow-projection!");
 
124
 
 
125
              pixel_region_init (&srcPR, gimp_drawable_get_tiles (layer),
 
126
                                 x, y, w,h, FALSE);
 
127
              pixel_region_init (&destPR, gimp_projection_get_tiles (proj),
 
128
                                 x, y, w,h, TRUE);
 
129
 
 
130
              copy_region (&srcPR, &destPR);
 
131
 
 
132
              proj->construct_flag = TRUE;
 
133
 
 
134
              gimp_projection_construct_channels (proj, x, y, w, h);
 
135
 
 
136
              return;
 
137
            }
 
138
        }
 
139
    }
 
140
#endif
 
141
 
159
142
  proj->construct_flag = FALSE;
160
 
#endif
161
143
 
162
144
  /*  First, determine if the projection image needs to be
163
145
   *  initialized--this is the case when there are no visible
183
165
                                  gint            w,
184
166
                                  gint            h)
185
167
{
186
 
  GimpLayer   *layer;
187
 
  gint         x1, y1, x2, y2;
188
 
  PixelRegion  src1PR, src2PR, maskPR;
189
 
  PixelRegion * mask;
190
 
  GList       *list;
191
 
  GList       *reverse_list;
192
 
  gint         off_x;
193
 
  gint         off_y;
 
168
  GimpLayer *layer;
 
169
  GList     *list;
 
170
  GList     *reverse_list;
 
171
  gint       x1, y1, x2, y2;
 
172
  gint       off_x;
 
173
  gint       off_y;
194
174
 
195
175
  /*  composite the floating selection if it exists  */
196
 
  if ((layer = gimp_image_floating_sel (proj->gimage)))
 
176
  if ((layer = gimp_image_floating_sel (proj->image)))
197
177
    floating_sel_composite (layer, x, y, w, h, FALSE);
198
178
 
199
179
  reverse_list = NULL;
200
180
 
201
 
  for (list = GIMP_LIST (proj->gimage->layers)->list;
 
181
  for (list = GIMP_LIST (proj->image->layers)->list;
202
182
       list;
203
183
       list = g_list_next (list))
204
184
    {
205
 
      layer = (GimpLayer *) list->data;
 
185
      layer = list->data;
206
186
 
207
187
      /*  only add layers that are visible and not floating selections
208
188
       *  to the list
209
189
       */
210
190
      if (! gimp_layer_is_floating_sel (layer) &&
211
 
          gimp_item_get_visible (GIMP_ITEM (layer)))
212
 
        {
213
 
          reverse_list = g_list_prepend (reverse_list, layer);
214
 
        }
 
191
          gimp_item_get_visible (GIMP_ITEM (layer)))
 
192
        {
 
193
          reverse_list = g_list_prepend (reverse_list, layer);
 
194
        }
215
195
    }
216
196
 
217
197
  for (list = reverse_list; list; list = g_list_next (list))
218
198
    {
219
 
      layer = (GimpLayer *) list->data;
 
199
      PixelRegion  src1PR;
 
200
      PixelRegion  src2PR;
 
201
      PixelRegion  maskPR;
 
202
 
 
203
      layer = list->data;
220
204
 
221
205
      gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y);
222
206
 
227
211
 
228
212
      /* configure the pixel regions  */
229
213
      pixel_region_init (&src1PR, gimp_projection_get_tiles (proj),
230
 
                         x1, y1, (x2 - x1), (y2 - y1),
231
 
                         TRUE);
 
214
                         x1, y1, (x2 - x1), (y2 - y1),
 
215
                         TRUE);
232
216
 
233
217
      /*  If we're showing the layer mask instead of the layer...  */
234
218
      if (layer->mask && layer->mask->show_mask)
235
 
        {
236
 
          pixel_region_init (&src2PR,
237
 
                             gimp_drawable_data (GIMP_DRAWABLE (layer->mask)),
238
 
                             (x1 - off_x), (y1 - off_y),
239
 
                             (x2 - x1), (y2 - y1), FALSE);
 
219
        {
 
220
          pixel_region_init (&src2PR,
 
221
                             gimp_drawable_get_tiles (GIMP_DRAWABLE (layer->mask)),
 
222
                             (x1 - off_x), (y1 - off_y),
 
223
                             (x2 - x1), (y2 - y1), FALSE);
240
224
 
241
 
          copy_gray_to_region (&src2PR, &src1PR);
242
 
        }
 
225
          copy_gray_to_region (&src2PR, &src1PR);
 
226
        }
243
227
      /*  Otherwise, normal  */
244
228
      else
245
 
        {
246
 
          pixel_region_init (&src2PR,
247
 
                             gimp_drawable_data (GIMP_DRAWABLE (layer)),
248
 
                             (x1 - off_x), (y1 - off_y),
249
 
                             (x2 - x1), (y2 - y1), FALSE);
250
 
 
251
 
          if (layer->mask && layer->mask->apply_mask)
252
 
            {
253
 
              pixel_region_init (&maskPR,
254
 
                                 gimp_drawable_data (GIMP_DRAWABLE (layer->mask)),
255
 
                                 (x1 - off_x), (y1 - off_y),
256
 
                                 (x2 - x1), (y2 - y1), FALSE);
257
 
              mask = &maskPR;
258
 
            }
259
 
          else
260
 
            mask = NULL;
261
 
 
262
 
          /*  Based on the type of the layer, project the layer onto the
263
 
           *  projection image...
264
 
           */
265
 
          switch (gimp_drawable_type (GIMP_DRAWABLE (layer)))
266
 
            {
267
 
            case GIMP_RGB_IMAGE: case GIMP_GRAY_IMAGE:
268
 
              /* no mask possible */
269
 
              project_intensity (proj, layer, &src2PR, &src1PR, mask);
270
 
              break;
271
 
 
272
 
            case GIMP_RGBA_IMAGE: case GIMP_GRAYA_IMAGE:
273
 
              project_intensity_alpha (proj, layer, &src2PR, &src1PR, mask);
274
 
              break;
275
 
 
276
 
            case GIMP_INDEXED_IMAGE:
277
 
              /* no mask possible */
278
 
              project_indexed (proj, layer, &src2PR, &src1PR);
279
 
              break;
280
 
 
281
 
            case GIMP_INDEXEDA_IMAGE:
282
 
              project_indexed_alpha (proj, layer, &src2PR, &src1PR, mask);
283
 
              break;
284
 
 
285
 
            default:
286
 
              break;
287
 
            }
288
 
        }
 
229
        {
 
230
          PixelRegion *mask = NULL;
 
231
 
 
232
          pixel_region_init (&src2PR,
 
233
                             gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
 
234
                             (x1 - off_x), (y1 - off_y),
 
235
                             (x2 - x1), (y2 - y1), FALSE);
 
236
 
 
237
          if (layer->mask && layer->mask->apply_mask)
 
238
            {
 
239
              pixel_region_init (&maskPR,
 
240
                                 gimp_drawable_get_tiles (GIMP_DRAWABLE (layer->mask)),
 
241
                                 (x1 - off_x), (y1 - off_y),
 
242
                                 (x2 - x1), (y2 - y1), FALSE);
 
243
              mask = &maskPR;
 
244
            }
 
245
 
 
246
          /*  Based on the type of the layer, project the layer onto the
 
247
           *  projection image...
 
248
           */
 
249
          switch (gimp_drawable_type (GIMP_DRAWABLE (layer)))
 
250
            {
 
251
            case GIMP_RGB_IMAGE:
 
252
            case GIMP_GRAY_IMAGE:
 
253
              project_intensity (proj, layer, &src2PR, &src1PR, mask);
 
254
              break;
 
255
 
 
256
            case GIMP_RGBA_IMAGE:
 
257
            case GIMP_GRAYA_IMAGE:
 
258
              project_intensity_alpha (proj, layer, &src2PR, &src1PR, mask);
 
259
              break;
 
260
 
 
261
            case GIMP_INDEXED_IMAGE:
 
262
              project_indexed (proj, layer, &src2PR, &src1PR, mask);
 
263
              break;
 
264
 
 
265
            case GIMP_INDEXEDA_IMAGE:
 
266
              project_indexed_alpha (proj, layer, &src2PR, &src1PR, mask);
 
267
              break;
 
268
 
 
269
            default:
 
270
              break;
 
271
            }
 
272
        }
289
273
 
290
274
      proj->construct_flag = TRUE;  /*  something was projected  */
291
275
    }
300
284
                                    gint            w,
301
285
                                    gint            h)
302
286
{
303
 
  GimpChannel *channel;
304
 
  PixelRegion  src1PR;
305
 
  PixelRegion  src2PR;
306
 
  GList       *list;
307
 
  GList       *reverse_list = NULL;
 
287
  GList *list;
 
288
  GList *reverse_list = NULL;
308
289
 
309
290
  /*  reverse the channel list  */
310
 
  for (list = GIMP_LIST (proj->gimage->channels)->list;
 
291
  for (list = GIMP_LIST (proj->image->channels)->list;
311
292
       list;
312
293
       list = g_list_next (list))
313
294
    {
316
297
 
317
298
  for (list = reverse_list; list; list = g_list_next (list))
318
299
    {
319
 
      channel = (GimpChannel *) list->data;
 
300
      GimpChannel *channel = list->data;
320
301
 
321
302
      if (gimp_item_get_visible (GIMP_ITEM (channel)))
322
 
        {
323
 
          /* configure the pixel regions  */
324
 
          pixel_region_init (&src1PR,
325
 
                             gimp_projection_get_tiles (proj),
326
 
                             x, y, w, h,
327
 
                             TRUE);
328
 
          pixel_region_init (&src2PR,
329
 
                             gimp_drawable_data (GIMP_DRAWABLE (channel)),
330
 
                             x, y, w, h,
331
 
                             FALSE);
332
 
 
333
 
          project_channel (proj, channel, &src1PR, &src2PR);
334
 
 
335
 
          proj->construct_flag = TRUE;
336
 
        }
 
303
        {
 
304
          PixelRegion  src1PR;
 
305
          PixelRegion  src2PR;
 
306
 
 
307
          /* configure the pixel regions  */
 
308
          pixel_region_init (&src1PR,
 
309
                             gimp_projection_get_tiles (proj),
 
310
                             x, y, w, h,
 
311
                             TRUE);
 
312
          pixel_region_init (&src2PR,
 
313
                             gimp_drawable_get_tiles (GIMP_DRAWABLE (channel)),
 
314
                             x, y, w, h,
 
315
                             FALSE);
 
316
 
 
317
          project_channel (proj, channel, &src1PR, &src2PR);
 
318
 
 
319
          proj->construct_flag = TRUE;
 
320
        }
337
321
    }
338
322
 
339
323
  g_list_free (reverse_list);
355
339
   *  the projection is initialized to transparent
356
340
   */
357
341
 
358
 
  for (list = GIMP_LIST (proj->gimage->layers)->list;
 
342
  for (list = GIMP_LIST (proj->image->layers)->list;
359
343
       list;
360
344
       list = g_list_next (list))
361
345
    {
365
349
      gimp_item_offsets (item, &off_x, &off_y);
366
350
 
367
351
      if (gimp_item_get_visible (item)                     &&
368
 
          ! gimp_drawable_has_alpha (GIMP_DRAWABLE (item)) &&
369
 
          (off_x <= x)                                     &&
370
 
          (off_y <= y)                                     &&
371
 
          (off_x + gimp_item_width  (item) >= x + w)       &&
372
 
          (off_y + gimp_item_height (item) >= y + h))
373
 
        {
374
 
          coverage = TRUE;
375
 
          break;
376
 
        }
 
352
          ! gimp_drawable_has_alpha (GIMP_DRAWABLE (item)) &&
 
353
          (off_x <= x)                                     &&
 
354
          (off_y <= y)                                     &&
 
355
          (off_x + gimp_item_width  (item) >= x + w)       &&
 
356
          (off_y + gimp_item_height (item) >= y + h))
 
357
        {
 
358
          coverage = TRUE;
 
359
          break;
 
360
        }
377
361
    }
378
362
 
379
363
  if (!coverage)
382
366
      guchar      clear[4] = { 0, 0, 0, 0 };
383
367
 
384
368
      pixel_region_init (&PR, gimp_projection_get_tiles (proj),
385
 
                         x, y, w, h, TRUE);
 
369
                         x, y, w, h, TRUE);
386
370
      color_region (&PR, clear);
387
371
    }
388
372
}
389
373
 
390
374
static void
391
375
project_intensity (GimpProjection *proj,
392
 
                   GimpLayer      *layer,
393
 
                   PixelRegion    *src,
394
 
                   PixelRegion    *dest,
395
 
                   PixelRegion    *mask)
 
376
                   GimpLayer      *layer,
 
377
                   PixelRegion    *src,
 
378
                   PixelRegion    *dest,
 
379
                   PixelRegion    *mask)
396
380
{
397
381
  if (! proj->construct_flag)
398
382
    initial_region (src, dest, mask, NULL,
399
383
                    layer->opacity * 255.999,
400
384
                    layer->mode,
401
 
                    proj->gimage->visible,
 
385
                    proj->image->visible,
402
386
                    INITIAL_INTENSITY);
403
387
  else
404
388
    combine_regions (dest, src, dest, mask, NULL,
405
389
                     layer->opacity * 255.999,
406
390
                     layer->mode,
407
 
                     proj->gimage->visible,
 
391
                     proj->image->visible,
408
392
                     COMBINE_INTEN_A_INTEN);
409
393
}
410
394
 
411
395
static void
412
396
project_intensity_alpha (GimpProjection *proj,
413
 
                         GimpLayer      *layer,
414
 
                         PixelRegion    *src,
415
 
                         PixelRegion    *dest,
416
 
                         PixelRegion    *mask)
 
397
                         GimpLayer      *layer,
 
398
                         PixelRegion    *src,
 
399
                         PixelRegion    *dest,
 
400
                         PixelRegion    *mask)
417
401
{
418
402
  if (! proj->construct_flag)
419
403
    initial_region (src, dest, mask, NULL,
420
404
                    layer->opacity * 255.999,
421
405
                    layer->mode,
422
 
                    proj->gimage->visible,
 
406
                    proj->image->visible,
423
407
                    INITIAL_INTENSITY_ALPHA);
424
408
  else
425
409
    combine_regions (dest, src, dest, mask, NULL,
426
410
                     layer->opacity * 255.999,
427
411
                     layer->mode,
428
 
                     proj->gimage->visible,
 
412
                     proj->image->visible,
429
413
                     COMBINE_INTEN_A_INTEN_A);
430
414
}
431
415
 
432
416
static void
433
417
project_indexed (GimpProjection *proj,
434
 
                 GimpLayer      *layer,
435
 
                 PixelRegion    *src,
436
 
                 PixelRegion    *dest)
 
418
                 GimpLayer      *layer,
 
419
                 PixelRegion    *src,
 
420
                 PixelRegion    *dest,
 
421
                 PixelRegion    *mask)
437
422
{
438
 
  g_return_if_fail (proj->gimage->cmap != NULL);
 
423
  g_return_if_fail (proj->image->cmap != NULL);
439
424
 
440
425
  if (! proj->construct_flag)
441
 
    initial_region (src, dest, NULL, proj->gimage->cmap,
 
426
    initial_region (src, dest, mask, proj->image->cmap,
442
427
                    layer->opacity * 255.999,
443
428
                    layer->mode,
444
 
                    proj->gimage->visible,
 
429
                    proj->image->visible,
445
430
                    INITIAL_INDEXED);
446
431
  else
447
 
    g_warning ("%s: unable to project indexed image.", G_STRFUNC);
 
432
    combine_regions (dest, src, dest, mask, proj->image->cmap,
 
433
                     layer->opacity * 255.999,
 
434
                     layer->mode,
 
435
                     proj->image->visible,
 
436
                     COMBINE_INTEN_A_INDEXED);
448
437
}
449
438
 
450
439
static void
451
440
project_indexed_alpha (GimpProjection *proj,
452
 
                       GimpLayer      *layer,
453
 
                       PixelRegion    *src,
454
 
                       PixelRegion    *dest,
455
 
                       PixelRegion    *mask)
 
441
                       GimpLayer      *layer,
 
442
                       PixelRegion    *src,
 
443
                       PixelRegion    *dest,
 
444
                       PixelRegion    *mask)
456
445
{
457
 
  g_return_if_fail (proj->gimage->cmap != NULL);
 
446
  g_return_if_fail (proj->image->cmap != NULL);
458
447
 
459
448
  if (! proj->construct_flag)
460
 
    initial_region (src, dest, mask, proj->gimage->cmap,
 
449
    initial_region (src, dest, mask, proj->image->cmap,
461
450
                    layer->opacity * 255.999,
462
451
                    layer->mode,
463
 
                    proj->gimage->visible,
 
452
                    proj->image->visible,
464
453
                    INITIAL_INDEXED_ALPHA);
465
454
  else
466
 
    combine_regions (dest, src, dest, mask, proj->gimage->cmap,
 
455
    combine_regions (dest, src, dest, mask, proj->image->cmap,
467
456
                     layer->opacity * 255.999,
468
457
                     layer->mode,
469
 
                     proj->gimage->visible,
 
458
                     proj->image->visible,
470
459
                     COMBINE_INTEN_A_INDEXED_A);
471
460
}
472
461
 
473
462
static void
474
463
project_channel (GimpProjection *proj,
475
 
                 GimpChannel    *channel,
476
 
                 PixelRegion    *src,
477
 
                 PixelRegion    *src2)
 
464
                 GimpChannel    *channel,
 
465
                 PixelRegion    *src,
 
466
                 PixelRegion    *src2)
478
467
{
479
468
  guchar  col[3];
480
469
  guchar  opacity;
481
470
  gint    type;
482
471
 
483
472
  gimp_rgba_get_uchar (&channel->color,
484
 
                       &col[0], &col[1], &col[2], &opacity);
 
473
                       &col[0], &col[1], &col[2], &opacity);
485
474
 
486
475
  if (! proj->construct_flag)
487
476
    {
488
477
      type = (channel->show_masked) ?
489
 
        INITIAL_CHANNEL_MASK : INITIAL_CHANNEL_SELECTION;
 
478
        INITIAL_CHANNEL_MASK : INITIAL_CHANNEL_SELECTION;
490
479
 
491
480
      initial_region (src2, src, NULL, col,
492
481
                      opacity,
497
486
  else
498
487
    {
499
488
      type = (channel->show_masked) ?
500
 
        COMBINE_INTEN_A_CHANNEL_MASK : COMBINE_INTEN_A_CHANNEL_SELECTION;
 
489
        COMBINE_INTEN_A_CHANNEL_MASK : COMBINE_INTEN_A_CHANNEL_SELECTION;
501
490
 
502
491
      combine_regions (src, src2, src, NULL, col,
503
492
                       opacity,