home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / channel.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  43.0 KB  |  1,776 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18.  
  19. #include "config.h"
  20.  
  21. #include <stdlib.h>
  22. #include <string.h>
  23.  
  24. #include <gtk/gtk.h>
  25.  
  26. #include "apptypes.h"
  27.  
  28. #include "appenv.h"
  29. #include "channel.h"
  30. #include "drawable.h"
  31. #include "gdisplay.h"
  32. #include "gimage_mask.h"
  33. #include "layer.h"
  34. #include "paint_funcs.h"
  35. #include "parasitelist.h"
  36. #include "temp_buf.h"
  37. #include "undo.h"
  38. #include "gimpsignal.h"
  39. #include "gimppreviewcache.h"
  40.  
  41. #include "channel_pvt.h"
  42. #include "tile.h"
  43.  
  44. #include "gimplut.h"
  45. #include "lut_funcs.h"
  46.  
  47. #include "libgimp/gimpmath.h"
  48.  
  49. #include "libgimp/gimpintl.h"
  50.  
  51.  
  52. enum {
  53.   REMOVED,
  54.   LAST_SIGNAL
  55. };
  56.  
  57. static void gimp_channel_class_init (GimpChannelClass *klass);
  58. static void gimp_channel_init       (GimpChannel      *channel);
  59. static void gimp_channel_destroy    (GtkObject        *object);
  60.  
  61. static TempBuf * channel_preview_private (Channel *channel,
  62.                       gint     width,
  63.                       gint     height);
  64.  
  65. static guint channel_signals[LAST_SIGNAL] = { 0 };
  66.  
  67. static GimpDrawableClass *parent_class = NULL;
  68.  
  69. GtkType
  70. gimp_channel_get_type ()
  71. {
  72.   static GtkType channel_type = 0;
  73.  
  74.   if (!channel_type)
  75.     {
  76.       GtkTypeInfo channel_info =
  77.       {
  78.     "GimpChannel",
  79.     sizeof (GimpChannel),
  80.     sizeof (GimpChannelClass),
  81.     (GtkClassInitFunc) gimp_channel_class_init,
  82.     (GtkObjectInitFunc) gimp_channel_init,
  83.         /* reserved_1 */ NULL,
  84.     /* reserved_2 */ NULL,
  85.     (GtkClassInitFunc) NULL,
  86.       };
  87.  
  88.       channel_type = gtk_type_unique (gimp_drawable_get_type (), &channel_info);
  89.     }
  90.  
  91.   return channel_type;
  92. }
  93.  
  94. static void
  95. gimp_channel_class_init (GimpChannelClass *class)
  96. {
  97.   GtkObjectClass *object_class;
  98.  
  99.   object_class = (GtkObjectClass*) class;
  100.   parent_class = gtk_type_class (gimp_drawable_get_type ());
  101.  
  102.   channel_signals[REMOVED] =
  103.       gimp_signal_new ("removed",
  104.                0, object_class->type, 0, gimp_sigtype_void);
  105.  
  106.   gtk_object_class_add_signals (object_class, channel_signals, LAST_SIGNAL);
  107.  
  108.   object_class->destroy = gimp_channel_destroy;
  109. }
  110.  
  111. static void
  112. gimp_channel_init (GimpChannel *channel)
  113. {
  114. }
  115.  
  116. /**************************/
  117. /*  Function definitions  */
  118. /**************************/
  119.  
  120. static void
  121. channel_validate (TileManager *tm,
  122.           Tile        *tile)
  123. {
  124.   /*  Set the contents of the tile to empty  */
  125.   memset (tile_data_pointer (tile, 0, 0), 
  126.       TRANSPARENT_OPACITY, tile_size (tile));
  127. }
  128.  
  129. Channel *
  130. channel_new (GimpImage *gimage,
  131.          gint       width,
  132.          gint       height,
  133.          gchar     *name,
  134.          gint       opacity,
  135.          guchar    *col)
  136. {
  137.   Channel * channel;
  138.   gint i;
  139.  
  140.   channel = gtk_type_new (gimp_channel_get_type ());
  141.  
  142.   gimp_drawable_configure (GIMP_DRAWABLE (channel), 
  143.                gimage, width, height, GRAY_GIMAGE, name);
  144.  
  145.   /*  set the channel color and opacity  */
  146.   for (i = 0; i < 3; i++)
  147.     channel->col[i] = col[i];
  148.  
  149.   channel->opacity     = opacity;
  150.   channel->show_masked = TRUE;
  151.  
  152.   /*  selection mask variables  */
  153.   channel->empty          = TRUE;
  154.   channel->segs_in        = NULL;
  155.   channel->segs_out       = NULL;
  156.   channel->num_segs_in    = 0;
  157.   channel->num_segs_out   = 0;
  158.   channel->bounds_known   = TRUE;
  159.   channel->boundary_known = TRUE;
  160.   channel->x1             = 0;
  161.   channel->y1             = 0;
  162.   channel->x2             = width;
  163.   channel->y2             = height;
  164.  
  165.   return channel;
  166. }
  167.  
  168. Channel *
  169. channel_ref (Channel *channel)
  170. {
  171.   gtk_object_ref  (GTK_OBJECT (channel));
  172.   gtk_object_sink (GTK_OBJECT (channel));
  173.  
  174.   return channel;
  175. }
  176.  
  177. void
  178. channel_unref (Channel *channel)
  179. {
  180.   gtk_object_unref (GTK_OBJECT (channel));
  181. }
  182.  
  183. Channel *
  184. channel_copy (Channel *channel)
  185. {
  186.   gchar *channel_name;
  187.   Channel *new_channel;
  188.   PixelRegion srcPR, destPR;
  189.   gchar *ext;
  190.   gint number;
  191.   gchar *name;
  192.   gint len;
  193.  
  194.   /*  formulate the new channel name  */
  195.   name = channel_get_name (channel);
  196.   ext = strrchr (name, '#');
  197.   len = strlen (_("copy"));
  198.   if ((strlen (name) >= len &&
  199.        strcmp (&name[strlen (name) - len], _("copy")) == 0) ||
  200.       (ext && (number = atoi (ext + 1)) > 0 && 
  201.        ((int)(log10 (number) + 1)) == strlen (ext + 1)))
  202.     /* don't have redundant "copy"s */
  203.     channel_name = g_strdup (name);
  204.   else
  205.     channel_name = g_strdup_printf (_("%s copy"), name);
  206.  
  207.   /*  allocate a new channel object  */
  208.   new_channel = channel_new (GIMP_DRAWABLE (channel)->gimage, 
  209.                  GIMP_DRAWABLE (channel)->width, 
  210.                  GIMP_DRAWABLE (channel)->height, 
  211.                  channel_name, channel->opacity, channel->col);
  212.   GIMP_DRAWABLE (new_channel)->visible = GIMP_DRAWABLE (channel)->visible;
  213.   new_channel->show_masked = channel->show_masked;
  214.  
  215.   /*  copy the contents across channels  */
  216.   pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles, 0, 0, 
  217.              GIMP_DRAWABLE (channel)->width, 
  218.              GIMP_DRAWABLE (channel)->height, FALSE);
  219.   pixel_region_init (&destPR, GIMP_DRAWABLE (new_channel)->tiles,
  220.              0, 0,
  221.              GIMP_DRAWABLE (channel)->width,
  222.              GIMP_DRAWABLE (channel)->height, TRUE);
  223.   copy_region (&srcPR, &destPR);
  224.  
  225.   /* copy the parasites */
  226.   GIMP_DRAWABLE (new_channel)->parasites 
  227.     = parasite_list_copy (GIMP_DRAWABLE (channel)->parasites);
  228.  
  229.   /*  free up the channel_name memory  */
  230.   g_free (channel_name);
  231.  
  232.   return new_channel;
  233. }
  234.  
  235. void
  236. channel_set_name (Channel *channel,
  237.           gchar   *name)
  238. {
  239.   gimp_drawable_set_name (GIMP_DRAWABLE (channel), name);
  240. }
  241.  
  242. gchar *
  243. channel_get_name (Channel *channel)
  244. {
  245.   return gimp_drawable_get_name (GIMP_DRAWABLE (channel));
  246. }
  247.  
  248. void 
  249. channel_set_color (Channel *channel,
  250.            guchar  *color)
  251. {
  252.   gint i;
  253.  
  254.   if (color)
  255.     {  
  256.       for (i = 0; i < 3; i++)
  257.     channel->col[i] = color[i];
  258.     }
  259. }
  260.  
  261. guchar *
  262. channel_get_color (Channel *channel)
  263. {
  264.   return (GIMP_CHANNEL (channel)->col); 
  265. }
  266.  
  267. int
  268. channel_get_opacity (Channel *channel)
  269. { 
  270.   return channel->opacity;
  271. }
  272.  
  273. void 
  274. channel_set_opacity (Channel *channel,
  275.              gint     opacity)
  276. {
  277.   if (opacity >=0 && opacity <= 100)
  278.     channel->opacity = (gint) (opacity * 255) / 100;
  279. }
  280.  
  281. Channel *
  282. channel_get_ID (gint ID)
  283. {
  284.   GimpDrawable *drawable;
  285.  
  286.   drawable = drawable_get_ID (ID);
  287.   if (drawable && GIMP_IS_CHANNEL (drawable)) 
  288.     return GIMP_CHANNEL (drawable);
  289.   else
  290.     return NULL;
  291. }
  292.  
  293. void
  294. channel_delete (Channel *channel)
  295. {
  296.   gtk_object_unref (GTK_OBJECT (channel));
  297. }
  298.  
  299. static void
  300. gimp_channel_destroy (GtkObject *object)
  301. {
  302.   GimpChannel *channel;
  303.  
  304.   g_return_if_fail (object != NULL);
  305.   g_return_if_fail (GIMP_IS_CHANNEL (object));
  306.  
  307.   channel = GIMP_CHANNEL (object);
  308.  
  309.   /* free the segments?  */
  310.   if (channel->segs_in)
  311.     g_free (channel->segs_in);
  312.   if (channel->segs_out)
  313.     g_free (channel->segs_out);
  314.  
  315.   if (GTK_OBJECT_CLASS (parent_class)->destroy)
  316.     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
  317.   
  318. }
  319.  
  320. /* The removed signal is sent out when the channel is no longer
  321.  * associcated with an image.  It's needed because channels aren't
  322.  * destroyed immediately, but kept around for undo purposes.  Connect
  323.  * to the removed signal to update bits of UI that are tied to a
  324.  * particular layer. */
  325. void
  326. channel_removed (Channel  *channel,
  327.          gpointer  data)
  328. {
  329.   g_return_if_fail (channel != NULL);
  330.   g_return_if_fail (GIMP_IS_CHANNEL (channel));
  331.  
  332.   gtk_signal_emit (GTK_OBJECT (channel), channel_signals[REMOVED]);
  333. }
  334.  
  335.  
  336. void
  337. channel_scale (Channel *channel,
  338.            gint     new_width,
  339.            gint     new_height)
  340. {
  341.   PixelRegion srcPR, destPR;
  342.   TileManager *new_tiles;
  343.  
  344.   if (new_width == 0 || new_height == 0)
  345.     return;
  346.  
  347.   /*  Update the old channel position  */
  348.   drawable_update (GIMP_DRAWABLE (channel),
  349.            0, 0,
  350.            GIMP_DRAWABLE (channel)->width,
  351.            GIMP_DRAWABLE (channel)->height);
  352.  
  353.   /*  Configure the pixel regions  */
  354.   pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
  355.              0, 0,
  356.              GIMP_DRAWABLE (channel)->width,
  357.              GIMP_DRAWABLE (channel)->height, FALSE);
  358.  
  359.   /*  Allocate the new channel, configure dest region  */
  360.   new_tiles = tile_manager_new (new_width, new_height, 1);
  361.   pixel_region_init (&destPR, new_tiles, 0, 0, new_width, new_height, TRUE);
  362.  
  363.   /*  Add an alpha channel  */
  364.   scale_region (&srcPR, &destPR);
  365.  
  366.   /*  Push the channel on the undo stack  */
  367.   undo_push_channel_mod (GIMP_DRAWABLE (channel)->gimage, channel);
  368.  
  369.   /*  Configure the new channel  */
  370.   GIMP_DRAWABLE (channel)->tiles = new_tiles;
  371.   GIMP_DRAWABLE (channel)->width = new_width;
  372.   GIMP_DRAWABLE (channel)->height = new_height;
  373.  
  374.   /*  bounds are now unknown  */
  375.   channel->bounds_known = FALSE;
  376.  
  377.   /*  Update the new channel position  */
  378.   drawable_update (GIMP_DRAWABLE (channel),
  379.            0, 0,
  380.            GIMP_DRAWABLE (channel)->width,
  381.            GIMP_DRAWABLE (channel)->height);
  382. }
  383.  
  384. void
  385. channel_resize (Channel *channel,
  386.         gint     new_width,
  387.         gint     new_height,
  388.         gint     offx,
  389.         gint     offy)
  390. {
  391.   PixelRegion srcPR, destPR;
  392.   TileManager *new_tiles;
  393.   guchar bg = 0;
  394.   gint clear;
  395.   gint w, h;
  396.   gint x1, y1, x2, y2;
  397.  
  398.   if (!new_width || !new_height)
  399.     return;
  400.  
  401.   x1 = CLAMP (offx, 0, new_width);
  402.   y1 = CLAMP (offy, 0, new_height);
  403.   x2 = CLAMP ((offx + GIMP_DRAWABLE (channel)->width), 0, new_width);
  404.   y2 = CLAMP ((offy + GIMP_DRAWABLE (channel)->height), 0, new_height);
  405.   w = x2 - x1;
  406.   h = y2 - y1;
  407.  
  408.   if (offx > 0)
  409.     {
  410.       x1 = 0;
  411.       x2 = offx;
  412.     }
  413.   else
  414.     {
  415.       x1 = -offx;
  416.       x2 = 0;
  417.     }
  418.  
  419.   if (offy > 0)
  420.     {
  421.       y1 = 0;
  422.       y2 = offy;
  423.     }
  424.   else
  425.     {
  426.       y1 = -offy;
  427.       y2 = 0;
  428.     }
  429.  
  430.   /*  Update the old channel position  */
  431.   drawable_update (GIMP_DRAWABLE (channel),
  432.            0, 0,
  433.            GIMP_DRAWABLE (channel)->width,
  434.            GIMP_DRAWABLE (channel)->height);
  435.  
  436.   /*  Configure the pixel regions  */
  437.   pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
  438.              x1, y1, w, h, FALSE);
  439.  
  440.   /*  Determine whether the new channel needs to be initially cleared  */
  441.   if ((new_width  > GIMP_DRAWABLE (channel)->width) ||
  442.       (new_height > GIMP_DRAWABLE (channel)->height) ||
  443.       (x2 || y2))
  444.     clear = TRUE;
  445.   else
  446.     clear = FALSE;
  447.  
  448.   /*  Allocate the new channel, configure dest region  */
  449.   new_tiles = tile_manager_new (new_width, new_height, 1);
  450.  
  451.   /*  Set to black (empty--for selections)  */
  452.   if (clear)
  453.     {
  454.       pixel_region_init (&destPR, new_tiles, 0, 0, new_width, new_height, TRUE);
  455.       color_region (&destPR, &bg);
  456.     }
  457.  
  458.   /*  copy from the old to the new  */
  459.   pixel_region_init (&destPR, new_tiles, x2, y2, w, h, TRUE);
  460.   if (w && h)
  461.     copy_region (&srcPR, &destPR);
  462.  
  463.   /*  Push the channel on the undo stack  */
  464.   undo_push_channel_mod (GIMP_DRAWABLE (channel)->gimage, channel);
  465.  
  466.   /*  Configure the new channel  */
  467.   GIMP_DRAWABLE (channel)->tiles  = new_tiles;
  468.   GIMP_DRAWABLE (channel)->width  = new_width;
  469.   GIMP_DRAWABLE (channel)->height = new_height;
  470.  
  471.   /*  bounds are now unknown  */
  472.   channel->bounds_known = FALSE;
  473.  
  474.   /*  update the new channel area  */
  475.   drawable_update (GIMP_DRAWABLE (channel),
  476.            0, 0,
  477.            GIMP_DRAWABLE (channel)->width,
  478.            GIMP_DRAWABLE (channel)->height);
  479. }
  480.  
  481. void            
  482. channel_update (Channel *channel)
  483. {
  484.   drawable_update (GIMP_DRAWABLE (channel),
  485.            0, 0,
  486.            GIMP_DRAWABLE (channel)->width,
  487.            GIMP_DRAWABLE (channel)->height);
  488.   gdisplays_flush ();
  489. }
  490.  
  491. /**********************/
  492. /*  access functions  */
  493. /**********************/
  494.  
  495. gboolean
  496. channel_toggle_visibility (Channel *channel)
  497. {
  498.   GIMP_DRAWABLE (channel)->visible = !GIMP_DRAWABLE (channel)->visible;
  499.  
  500.   return GIMP_DRAWABLE (channel)->visible;
  501. }
  502.  
  503. TempBuf *
  504. channel_preview (Channel *channel,
  505.          gint     width,
  506.          gint     height)
  507. {
  508.   /* Ok prime the cache with a large preview if the cache is invalid */
  509.   if (! GIMP_DRAWABLE (channel)->preview_valid &&
  510.       width  <= PREVIEW_CACHE_PRIME_WIDTH    &&
  511.       height <= PREVIEW_CACHE_PRIME_HEIGHT   &&
  512.       GIMP_DRAWABLE (channel)->gimage          &&
  513.       GIMP_DRAWABLE (channel)->gimage->width  > PREVIEW_CACHE_PRIME_WIDTH   &&
  514.       GIMP_DRAWABLE (channel)->gimage->height > PREVIEW_CACHE_PRIME_HEIGHT)
  515.     {
  516.       TempBuf * tb = channel_preview_private (channel,
  517.                           PREVIEW_CACHE_PRIME_WIDTH,
  518.                           PREVIEW_CACHE_PRIME_HEIGHT);
  519.       
  520.       /* Save the 2nd call */
  521.       if (width  == PREVIEW_CACHE_PRIME_WIDTH &&
  522.       height == PREVIEW_CACHE_PRIME_HEIGHT)
  523.     return tb;
  524.     }
  525.  
  526.   /* Second call - should NOT visit the tile cache...*/
  527.   return channel_preview_private (channel, width, height);
  528. }
  529.  
  530. static TempBuf *
  531. channel_preview_private (Channel *channel,
  532.              gint     width,
  533.              gint     height)
  534. {
  535.   MaskBuf     *preview_buf;
  536.   PixelRegion  srcPR;
  537.   PixelRegion  destPR;
  538.   gint         subsample;
  539.   TempBuf     *ret_buf;
  540.  
  541.   g_return_val_if_fail (channel != NULL, NULL);
  542.   g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL);
  543.   
  544.   /*  The easy way  */
  545.   if (GIMP_DRAWABLE (channel)->preview_valid &&
  546.       (ret_buf =
  547.        gimp_preview_cache_get (& (GIMP_DRAWABLE (channel)->preview_cache),
  548.                    width, height)))
  549.     return ret_buf;
  550.   /*  The hard way  */
  551.   else
  552.     {
  553.       /*  calculate 'acceptable' subsample  */
  554.       subsample = 1;
  555.       if (width < 1) width = 1;
  556.       if (height < 1) height = 1;
  557.       while ((width  * (subsample + 1) * 2 < GIMP_DRAWABLE (channel)->width) &&
  558.          (height * (subsample + 1) * 2 < GIMP_DRAWABLE (channel)->height))
  559.     subsample = subsample + 1;
  560.  
  561.       pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
  562.              0, 0,
  563.              GIMP_DRAWABLE (channel)->width,
  564.              GIMP_DRAWABLE (channel)->height, FALSE);
  565.  
  566.       preview_buf = mask_buf_new (width, height);
  567.       destPR.bytes     = 1;
  568.       destPR.x         = 0;
  569.       destPR.y         = 0;
  570.       destPR.w         = width;
  571.       destPR.h         = height;
  572.       destPR.rowstride = width;
  573.       destPR.data      = mask_buf_data (preview_buf);
  574.  
  575.       subsample_region (&srcPR, &destPR, subsample);
  576.  
  577.       if (!GIMP_DRAWABLE (channel)->preview_valid)
  578.     gimp_preview_cache_invalidate (&(GIMP_DRAWABLE(channel)->preview_cache));
  579.  
  580.       GIMP_DRAWABLE (channel)->preview_valid = TRUE;
  581.       gimp_preview_cache_add (&(GIMP_DRAWABLE (channel)->preview_cache),
  582.                   preview_buf);
  583.       return preview_buf;
  584.     }
  585. }
  586.  
  587. void
  588. channel_invalidate_previews (GimpImage* gimage)
  589. {
  590.   GSList * tmp;
  591.   Channel * channel;
  592.  
  593.   g_return_if_fail (gimage != NULL);
  594.  
  595.   tmp = gimage->channels;
  596.  
  597.   while (tmp)
  598.     {
  599.       channel = (Channel *) tmp->data;
  600.       gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
  601.       tmp = g_slist_next (tmp);
  602.     }
  603. }
  604.  
  605. Tattoo
  606. channel_get_tattoo (const Channel *channel)
  607. {
  608.   return (gimp_drawable_get_tattoo (GIMP_DRAWABLE (channel)));
  609. }
  610.  
  611. void
  612. channel_set_tattoo (const Channel *channel, 
  613.             Tattoo         value)
  614. {
  615.   gimp_drawable_set_tattoo (GIMP_DRAWABLE (channel), value);
  616. }
  617.  
  618. /******************************/
  619. /*  selection mask functions  */
  620. /******************************/
  621.  
  622. Channel *
  623. channel_new_mask (GimpImage *gimage,
  624.           gint       width,
  625.           gint       height)
  626. {
  627.   guchar black[3] = {0, 0, 0};
  628.   Channel *new_channel;
  629.  
  630.   /*  Create the new channel  */
  631.   new_channel = channel_new (gimage, width, height,
  632.                  _("Selection Mask"), 127, black);
  633.  
  634.   /*  Set the validate procedure  */
  635.   tile_manager_set_validate_proc (GIMP_DRAWABLE (new_channel)->tiles,
  636.                   channel_validate);
  637.  
  638.   return new_channel;
  639. }
  640.  
  641. gboolean
  642. channel_boundary (Channel   *mask,
  643.           BoundSeg **segs_in,
  644.           BoundSeg **segs_out,
  645.           gint      *num_segs_in,
  646.           gint      *num_segs_out,
  647.           gint       x1,
  648.           gint       y1,
  649.           gint       x2,
  650.           gint       y2)
  651. {
  652.   gint x3, y3, x4, y4;
  653.   PixelRegion bPR;
  654.  
  655.   if (! mask->boundary_known)
  656.     {
  657.       /* free the out of date boundary segments */
  658.       if (mask->segs_in)
  659.     g_free (mask->segs_in);
  660.       if (mask->segs_out)
  661.     g_free (mask->segs_out);
  662.  
  663.       if (channel_bounds (mask, &x3, &y3, &x4, &y4))
  664.     {
  665.       pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles,
  666.                  x3, y3, (x4 - x3), (y4 - y3), FALSE);
  667.       mask->segs_out = find_mask_boundary (&bPR, &mask->num_segs_out,
  668.                            IgnoreBounds,
  669.                            x1, y1,
  670.                            x2, y2);
  671.       x1 = MAX (x1, x3);
  672.       y1 = MAX (y1, y3);
  673.       x2 = MIN (x2, x4);
  674.       y2 = MIN (y2, y4);
  675.  
  676.       if (x2 > x1 && y2 > y1)
  677.         {
  678.           pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles,
  679.                  0, 0,
  680.                  GIMP_DRAWABLE (mask)->width,
  681.                  GIMP_DRAWABLE (mask)->height, FALSE);
  682.           mask->segs_in =  find_mask_boundary (&bPR, &mask->num_segs_in,
  683.                            WithinBounds,
  684.                            x1, y1,
  685.                            x2, y2);
  686.         }
  687.       else
  688.         {
  689.           mask->segs_in     = NULL;
  690.           mask->num_segs_in = 0;
  691.         }
  692.     }
  693.       else
  694.     {
  695.       mask->segs_in      = NULL;
  696.       mask->segs_out     = NULL;
  697.       mask->num_segs_in  = 0;
  698.       mask->num_segs_out = 0;
  699.     }
  700.       mask->boundary_known = TRUE;
  701.     }
  702.  
  703.   *segs_in      = mask->segs_in;
  704.   *segs_out     = mask->segs_out;
  705.   *num_segs_in  = mask->num_segs_in;
  706.   *num_segs_out = mask->num_segs_out;
  707.  
  708.   return TRUE;
  709. }
  710.  
  711. gint
  712. channel_value (Channel *mask,
  713.            gint     x,
  714.            gint     y)
  715. {
  716.   Tile *tile;
  717.   gint val;
  718.  
  719.   /*  Some checks to cut back on unnecessary work  */
  720.   if (mask->bounds_known)
  721.     {
  722.       if (mask->empty)
  723.     return 0;
  724.       else if (x < mask->x1 || x >= mask->x2 || y < mask->y1 || y >= mask->y2)
  725.     return 0;
  726.     }
  727.   else
  728.     {
  729.       if (x < 0 || x >= GIMP_DRAWABLE (mask)->width ||
  730.       y < 0 || y >= GIMP_DRAWABLE (mask)->height)
  731.     return 0;
  732.     }
  733.  
  734.   tile = tile_manager_get_tile (GIMP_DRAWABLE (mask)->tiles, x, y, TRUE, FALSE);
  735.   val = *(guchar *) (tile_data_pointer (tile, x % TILE_WIDTH, y % TILE_HEIGHT));
  736.   tile_release (tile, FALSE);
  737.  
  738.   return val;
  739. }
  740.  
  741. gboolean
  742. channel_bounds (Channel *mask,
  743.         gint    *x1,
  744.         gint    *y1,
  745.         gint    *x2,
  746.         gint    *y2)
  747. {
  748.   PixelRegion maskPR;
  749.   guchar *data, *data1;
  750.   gint x, y;
  751.   gint ex, ey;
  752.   gint tx1, tx2, ty1, ty2;
  753.   gint minx, maxx;
  754.   gpointer pr;
  755.  
  756.   /*  if the mask's bounds have already been reliably calculated...  */
  757.   if (mask->bounds_known)
  758.     {
  759.       *x1 = mask->x1;
  760.       *y1 = mask->y1;
  761.       *x2 = mask->x2;
  762.       *y2 = mask->y2;
  763.  
  764.       return !mask->empty;
  765.     }
  766.  
  767.   /*  go through and calculate the bounds  */
  768.   tx1 = GIMP_DRAWABLE (mask)->width;
  769.   ty1 = GIMP_DRAWABLE (mask)->height;
  770.   tx2 = 0;
  771.   ty2 = 0;
  772.  
  773.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  774.              0, 0,
  775.              GIMP_DRAWABLE (mask)->width,
  776.              GIMP_DRAWABLE (mask)->height, FALSE);
  777.   for (pr = pixel_regions_register (1, &maskPR);
  778.        pr != NULL;
  779.        pr = pixel_regions_process (pr))
  780.     {
  781.       data1 = data = maskPR.data;
  782.       ex = maskPR.x + maskPR.w;
  783.       ey = maskPR.y + maskPR.h;
  784.       /* only check the pixels if this tile is not fully within the currently
  785.      computed bounds */
  786.       if (maskPR.x < tx1 || ex > tx2 ||
  787.       maskPR.y < ty1 || ey > ty2)
  788.         {
  789.       /* Check upper left and lower right corners to see if we can
  790.          avoid checking the rest of the pixels in this tile */
  791.       if (data[0] && data[maskPR.rowstride*(maskPR.h - 1) + maskPR.w - 1])
  792.       {
  793.         if (maskPR.x < tx1)
  794.           tx1 = maskPR.x;
  795.         if (ex > tx2)
  796.           tx2 = ex;
  797.         if (maskPR.y < ty1)
  798.           ty1 = maskPR.y;
  799.         if (ey > ty2)
  800.           ty2 = ey;
  801.       }
  802.       else
  803.         for (y = maskPR.y; y < ey; y++, data1 += maskPR.rowstride)
  804.         {
  805.           for (x = maskPR.x, data = data1; x < ex; x++, data++)
  806.         if (*data)
  807.         {
  808.           minx = x;
  809.           maxx = x;
  810.           for (; x < ex; x++, data++)
  811.             if (*data)
  812.               maxx = x;
  813.           if (minx < tx1)
  814.             tx1 = minx;
  815.           if (maxx > tx2)
  816.             tx2 = maxx;
  817.           if (y < ty1)
  818.             ty1 = y;
  819.           if (y > ty2)
  820.             ty2 = y;
  821.           }
  822.         }
  823.     }
  824.     }
  825.  
  826.   tx2 = CLAMP (tx2 + 1, 0, GIMP_DRAWABLE (mask)->width);
  827.   ty2 = CLAMP (ty2 + 1, 0, GIMP_DRAWABLE (mask)->height);
  828.  
  829.   if (tx1 == GIMP_DRAWABLE (mask)->width && ty1 == GIMP_DRAWABLE (mask)->height)
  830.     {
  831.       mask->empty = TRUE;
  832.       mask->x1    = 0;
  833.       mask->y1    = 0;
  834.       mask->x2    = GIMP_DRAWABLE (mask)->width;
  835.       mask->y2    = GIMP_DRAWABLE (mask)->height;
  836.     }
  837.   else
  838.     {
  839.       mask->empty = FALSE;
  840.       mask->x1    = tx1;
  841.       mask->y1    = ty1;
  842.       mask->x2    = tx2;
  843.       mask->y2    = ty2;
  844.     }
  845.   mask->bounds_known = TRUE;
  846.  
  847.   *x1 = tx1;
  848.   *x2 = tx2;
  849.   *y1 = ty1;
  850.   *y2 = ty2;
  851.  
  852.   return !mask->empty;
  853. }
  854.  
  855. gboolean
  856. channel_is_empty (Channel *mask)
  857. {
  858.   PixelRegion maskPR;
  859.   guchar * data;
  860.   gint x, y;
  861.   gpointer pr;
  862.  
  863.   if (mask->bounds_known)
  864.     return mask->empty;
  865.  
  866.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  867.              0, 0,
  868.              GIMP_DRAWABLE (mask)->width,
  869.              GIMP_DRAWABLE (mask)->height, FALSE);
  870.   for (pr = pixel_regions_register (1, &maskPR);
  871.        pr != NULL;
  872.        pr = pixel_regions_process (pr))
  873.     {
  874.       /*  check if any pixel in the mask is non-zero  */
  875.       data = maskPR.data;
  876.       for (y = 0; y < maskPR.h; y++)
  877.     for (x = 0; x < maskPR.w; x++)
  878.       if (*data++)
  879.         {
  880.           pixel_regions_process_stop (pr);
  881.           return FALSE;
  882.         }
  883.     }
  884.  
  885.   /*  The mask is empty, meaning we can set the bounds as known  */
  886.   if (mask->segs_in)
  887.     g_free (mask->segs_in);
  888.   if (mask->segs_out)
  889.     g_free (mask->segs_out);
  890.  
  891.   mask->empty          = TRUE;
  892.   mask->segs_in        = NULL;
  893.   mask->segs_out       = NULL;
  894.   mask->num_segs_in    = 0;
  895.   mask->num_segs_out   = 0;
  896.   mask->bounds_known   = TRUE;
  897.   mask->boundary_known = TRUE;
  898.   mask->x1             = 0;
  899.   mask->y1             = 0;
  900.   mask->x2             = GIMP_DRAWABLE (mask)->width;
  901.   mask->y2             = GIMP_DRAWABLE (mask)->height;
  902.  
  903.   return TRUE;
  904. }
  905.  
  906. void
  907. channel_add_segment (Channel *mask,
  908.              gint     x,
  909.              gint     y,
  910.              gint     width,
  911.              gint     value)
  912. {
  913.   PixelRegion maskPR;
  914.   guchar *data;
  915.   gint val;
  916.   gint x2;
  917.   gpointer pr;
  918.  
  919.   /*  check horizontal extents...  */
  920.   x2 = x + width;
  921.   if (x2 < 0) x2 = 0;
  922.   if (x2 > GIMP_DRAWABLE (mask)->width) x2 = GIMP_DRAWABLE (mask)->width;
  923.   if (x < 0) x = 0;
  924.   if (x > GIMP_DRAWABLE (mask)->width) x = GIMP_DRAWABLE (mask)->width;
  925.   width = x2 - x;
  926.   if (!width) return;
  927.  
  928.   if (y < 0 || y > GIMP_DRAWABLE (mask)->height)
  929.     return;
  930.  
  931.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  932.              x, y, width, 1, TRUE);
  933.   for (pr = pixel_regions_register (1, &maskPR);
  934.        pr != NULL;
  935.        pr = pixel_regions_process (pr))
  936.     {
  937.       data = maskPR.data;
  938.       width = maskPR.w;
  939.       while (width--)
  940.     {
  941.       val = *data + value;
  942.       if (val > 255)
  943.         val = 255;
  944.       *data++ = val;
  945.     }
  946.     }
  947. }
  948.  
  949. void
  950. channel_sub_segment (Channel *mask,
  951.              gint     x,
  952.              gint     y,
  953.              gint     width,
  954.              gint     value)
  955. {
  956.   PixelRegion maskPR;
  957.   guchar *data;
  958.   gint val;
  959.   gint x2;
  960.   gpointer pr;
  961.  
  962.   /*  check horizontal extents...  */
  963.   x2 = x + width;
  964.   if (x2 < 0) x2 = 0;
  965.   if (x2 > GIMP_DRAWABLE (mask)->width) x2 = GIMP_DRAWABLE (mask)->width;
  966.   if (x < 0) x = 0;
  967.   if (x > GIMP_DRAWABLE (mask)->width) x = GIMP_DRAWABLE (mask)->width;
  968.   width = x2 - x;
  969.   if (!width) return;
  970.  
  971.   if (y < 0 || y > GIMP_DRAWABLE (mask)->height)
  972.     return;
  973.  
  974.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles, x, y, width, 1, TRUE);
  975.   for (pr = pixel_regions_register (1, &maskPR);
  976.        pr != NULL;
  977.        pr = pixel_regions_process (pr))
  978.     {
  979.       data = maskPR.data;
  980.       width = maskPR.w;
  981.       while (width--)
  982.     {
  983.       val = *data - value;
  984.       if (val < 0)
  985.         val = 0;
  986.       *data++ = val;
  987.     }
  988.     }
  989. }
  990.  
  991. void
  992. channel_combine_rect (Channel    *mask,
  993.               ChannelOps  op,
  994.               gint        x,
  995.               gint        y,
  996.               gint        w,
  997.               gint        h)
  998. {
  999.   gint x2, y2;
  1000.   PixelRegion maskPR;
  1001.   guchar color;
  1002.  
  1003.   y2 = y + h;
  1004.   x2 = x + w;
  1005.  
  1006.   x  = CLAMP (x,  0, GIMP_DRAWABLE (mask)->width);
  1007.   y  = CLAMP (y,  0, GIMP_DRAWABLE (mask)->height);
  1008.   x2 = CLAMP (x2, 0, GIMP_DRAWABLE (mask)->width);
  1009.   y2 = CLAMP (y2, 0, GIMP_DRAWABLE (mask)->height);
  1010.  
  1011.   if (x2 - x <= 0 || y2 - y <= 0)
  1012.     return;
  1013.  
  1014.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1015.              x, y, x2 - x, y2 - y, TRUE);
  1016.   if (op == ADD  || op == REPLACE)
  1017.     color = 255;
  1018.   else
  1019.     color = 0;
  1020.   color_region (&maskPR, &color);
  1021.  
  1022.   /*  Determine new boundary  */
  1023.   if (mask->bounds_known && (op == ADD) && !mask->empty)
  1024.     {
  1025.       if (x < mask->x1)
  1026.     mask->x1 = x;
  1027.       if (y < mask->y1)
  1028.     mask->y1 = y;
  1029.       if ((x + w) > mask->x2)
  1030.     mask->x2 = (x + w);
  1031.       if ((y + h) > mask->y2)
  1032.     mask->y2 = (y + h);
  1033.     }
  1034.   else if (op == REPLACE || mask->empty)
  1035.     {
  1036.       mask->empty = FALSE;
  1037.       mask->x1 = x;
  1038.       mask->y1 = y;
  1039.       mask->x2 = x + w;
  1040.       mask->y2 = y + h;
  1041.     }
  1042.   else
  1043.     mask->bounds_known = FALSE;
  1044.  
  1045.   mask->x1 = CLAMP (mask->x1, 0, GIMP_DRAWABLE (mask)->width);
  1046.   mask->y1 = CLAMP (mask->y1, 0, GIMP_DRAWABLE (mask)->height);
  1047.   mask->x2 = CLAMP (mask->x2, 0, GIMP_DRAWABLE (mask)->width);
  1048.   mask->y2 = CLAMP (mask->y2, 0, GIMP_DRAWABLE (mask)->height);
  1049. }
  1050.  
  1051. void
  1052. channel_combine_ellipse (Channel    *mask,
  1053.              ChannelOps  op,
  1054.              gint        x,
  1055.              gint        y,
  1056.              gint        w,
  1057.              gint        h,
  1058.              gboolean    antialias)
  1059. {
  1060.   gint i, j;
  1061.   gint x0, x1, x2;
  1062.   gint val, last;
  1063.   gfloat a_sqr, b_sqr, aob_sqr;
  1064.   gfloat w_sqr, h_sqr;
  1065.   gfloat y_sqr;
  1066.   gfloat t0, t1;
  1067.   gfloat r;
  1068.   gfloat cx, cy;
  1069.   gfloat rad;
  1070.   gfloat dist;
  1071.  
  1072.   if (!w || !h)
  1073.     return;
  1074.  
  1075.   a_sqr = (w * w / 4.0);
  1076.   b_sqr = (h * h / 4.0);
  1077.   aob_sqr = a_sqr / b_sqr;
  1078.  
  1079.   cx = x + w / 2.0;
  1080.   cy = y + h / 2.0;
  1081.  
  1082.   for (i = y; i < (y + h); i++)
  1083.     {
  1084.       if (i >= 0 && i < GIMP_DRAWABLE (mask)->height)
  1085.     {
  1086.       /*  Non-antialiased code  */
  1087.       if (!antialias)
  1088.         {
  1089.           y_sqr = (i + 0.5 - cy) * (i + 0.5 - cy);
  1090.           rad = sqrt (a_sqr - a_sqr * y_sqr / (double) b_sqr);
  1091.           x1 = ROUND (cx - rad);
  1092.           x2 = ROUND (cx + rad);
  1093.  
  1094.           switch (op)
  1095.         {
  1096.         case ADD: case REPLACE:
  1097.           channel_add_segment (mask, x1, i, (x2 - x1), 255);
  1098.           break;
  1099.         case SUB :
  1100.           channel_sub_segment (mask, x1, i, (x2 - x1), 255);
  1101.           break;
  1102.         default:
  1103.           g_warning ("Only ADD, REPLACE and SUB are valid for channel_combine!");
  1104.           break;
  1105.         }
  1106.         }
  1107.       /*  antialiasing  */
  1108.       else
  1109.         {
  1110.           x0 = x;
  1111.           last = 0;
  1112.           h_sqr = (i + 0.5 - cy) * (i + 0.5 - cy);
  1113.           for (j = x; j < (x + w); j++)
  1114.         {
  1115.           w_sqr = (j + 0.5 - cx) * (j + 0.5 - cx);
  1116.  
  1117.           if (h_sqr != 0)
  1118.             {
  1119.               t0 = w_sqr / h_sqr;
  1120.               t1 = a_sqr / (t0 + aob_sqr);
  1121.               r = sqrt (t1 + t0 * t1);
  1122.               rad = sqrt (w_sqr + h_sqr);
  1123.               dist = rad - r;
  1124.             }
  1125.           else
  1126.             dist = -1.0;
  1127.  
  1128.           if (dist < -0.5)
  1129.             val = 255;
  1130.           else if (dist < 0.5)
  1131.             val = (int) (255 * (1 - (dist + 0.5)));
  1132.           else
  1133.             val = 0;
  1134.           
  1135.           if (last != val && last)
  1136.             {
  1137.               switch (op)
  1138.             {
  1139.             case ADD: case REPLACE:
  1140.               channel_add_segment (mask, x0, i, j - x0, last);
  1141.               break;
  1142.             case SUB:
  1143.               channel_sub_segment (mask, x0, i, j - x0, last);
  1144.               break;
  1145.             default:
  1146.               g_warning ("Only ADD, REPLACE and SUB are valid for channel_combine!");
  1147.               break;
  1148.             }
  1149.             }
  1150.  
  1151.           if (last != val)
  1152.             {
  1153.               x0 = j;
  1154.               last = val;
  1155.               /* because we are symetric accross the y axis we can
  1156.              skip ahead a bit if we are inside the ellipse*/
  1157.               if (val == 255 && j < cx)
  1158.             j = cx + (cx - j) - 1;
  1159.             }
  1160.         }
  1161.  
  1162.           if (last)
  1163.         {
  1164.           if (op == ADD || op == REPLACE)
  1165.             channel_add_segment (mask, x0, i, j - x0, last);
  1166.           else if (op == SUB)
  1167.             channel_sub_segment (mask, x0, i, j - x0, last);
  1168.           else
  1169.             g_warning ("Only ADD, REPLACE and SUB are valid for channel_combine!");
  1170.         }
  1171.         }
  1172.  
  1173.     }
  1174.     }
  1175.  
  1176.   /*  Determine new boundary  */
  1177.   if (mask->bounds_known && (op == ADD) && !mask->empty)
  1178.     {
  1179.       if (x < mask->x1)
  1180.     mask->x1 = x;
  1181.       if (y < mask->y1)
  1182.     mask->y1 = y;
  1183.       if ((x + w) > mask->x2)
  1184.     mask->x2 = (x + w);
  1185.       if ((y + h) > mask->y2)
  1186.     mask->y2 = (y + h);
  1187.     }
  1188.   else if (op == REPLACE || mask->empty)
  1189.     {
  1190.       mask->empty = FALSE;
  1191.       mask->x1 = x;
  1192.       mask->y1 = y;
  1193.       mask->x2 = x + w;
  1194.       mask->y2 = y + h;
  1195.     }
  1196.   else
  1197.     mask->bounds_known = FALSE;
  1198.  
  1199.   mask->x1 = CLAMP (mask->x1, 0, GIMP_DRAWABLE (mask)->width);
  1200.   mask->y1 = CLAMP (mask->y1, 0, GIMP_DRAWABLE (mask)->height);
  1201.   mask->x2 = CLAMP (mask->x2, 0, GIMP_DRAWABLE (mask)->width);
  1202.   mask->y2 = CLAMP (mask->y2, 0, GIMP_DRAWABLE (mask)->height);
  1203. }
  1204.  
  1205. static void
  1206. channel_combine_sub_region_add (void        *unused,
  1207.                 PixelRegion *srcPR,
  1208.                 PixelRegion *destPR)
  1209. {
  1210.   guchar *src, *dest;
  1211.   gint x, y, val;
  1212.  
  1213.   src  = srcPR->data;
  1214.   dest = destPR->data;
  1215.  
  1216.   for (y = 0; y < srcPR->h; y++)
  1217.     {
  1218.       for (x = 0; x < srcPR->w; x++)
  1219.     {
  1220.       val = dest[x] + src[x];
  1221.       if (val > 255)
  1222.         dest[x] = 255;
  1223.       else
  1224.         dest[x] = val;
  1225.     }
  1226.       src  += srcPR->rowstride;
  1227.       dest += destPR->rowstride;
  1228.     }
  1229. }
  1230.  
  1231. static void
  1232. channel_combine_sub_region_sub (void        *unused,
  1233.                 PixelRegion *srcPR,
  1234.                 PixelRegion *destPR)
  1235. {
  1236.   guchar *src, *dest;
  1237.   gint x, y;
  1238.  
  1239.   src  = srcPR->data;
  1240.   dest = destPR->data;
  1241.  
  1242.   for (y = 0; y < srcPR->h; y++)
  1243.     {
  1244.       for (x = 0; x < srcPR->w; x++)
  1245.     {
  1246.       if (src[x] > dest[x])
  1247.         dest[x] = 0;
  1248.       else
  1249.         dest[x]-= src[x];
  1250.     }
  1251.       src  += srcPR->rowstride;
  1252.       dest += destPR->rowstride;
  1253.     }
  1254. }
  1255.  
  1256. static void
  1257. channel_combine_sub_region_intersect (void        *unused,
  1258.                       PixelRegion *srcPR,
  1259.                       PixelRegion *destPR)
  1260. {
  1261.   guchar *src, *dest;
  1262.   gint x, y;
  1263.  
  1264.   src  = srcPR->data;
  1265.   dest = destPR->data;
  1266.  
  1267.   for (y = 0; y < srcPR->h; y++)
  1268.     {
  1269.       for (x = 0; x < srcPR->w; x++)
  1270.     {
  1271.       dest[x] = MIN (dest[x], src[x]);
  1272.     }
  1273.       src  += srcPR->rowstride;
  1274.       dest += destPR->rowstride;
  1275.   }
  1276. }
  1277.  
  1278. void
  1279. channel_combine_mask (Channel    *mask,
  1280.               Channel    *add_on,
  1281.               ChannelOps  op,
  1282.               gint        off_x,
  1283.               gint        off_y)
  1284. {
  1285.   PixelRegion srcPR, destPR;
  1286.   gint x1, y1, x2, y2;
  1287.   gint w, h;
  1288.  
  1289.   x1 = CLAMP (off_x, 0, GIMP_DRAWABLE (mask)->width);
  1290.   y1 = CLAMP (off_y, 0, GIMP_DRAWABLE (mask)->height);
  1291.   x2 = CLAMP (off_x + GIMP_DRAWABLE (add_on)->width, 0,
  1292.           GIMP_DRAWABLE (mask)->width);
  1293.   y2 = CLAMP (off_y + GIMP_DRAWABLE (add_on)->height, 0,
  1294.           GIMP_DRAWABLE (mask)->height);
  1295.  
  1296.   w = (x2 - x1);
  1297.   h = (y2 - y1);
  1298.  
  1299.   pixel_region_init (&srcPR, GIMP_DRAWABLE (add_on)->tiles,
  1300.              (x1 - off_x), (y1 - off_y), w, h, FALSE);
  1301.   pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles, x1, y1, w, h, TRUE);
  1302.  
  1303.   switch (op)
  1304.     {
  1305.     case ADD: case REPLACE:
  1306.       pixel_regions_process_parallel ((p_func) channel_combine_sub_region_add,
  1307.                       NULL, 2, &srcPR, &destPR);
  1308.       break;
  1309.     case SUB:
  1310.       pixel_regions_process_parallel ((p_func) channel_combine_sub_region_sub,
  1311.                       NULL, 2, &srcPR, &destPR);
  1312.       break;
  1313.     case INTERSECT:
  1314.       pixel_regions_process_parallel ((p_func)
  1315.                       channel_combine_sub_region_intersect,
  1316.                       NULL, 2, &srcPR, &destPR);
  1317.       break;
  1318.     default:
  1319.       g_message ("Error: unknown opperation type in channel_combine_mask\n");
  1320.       break;
  1321.     }
  1322.   mask->bounds_known = FALSE;
  1323. }
  1324.  
  1325. void
  1326. channel_feather (Channel    *input,
  1327.          Channel    *output,
  1328.          gdouble     radius_x,
  1329.          gdouble     radius_y,
  1330.          ChannelOps  op,
  1331.          gint        off_x,
  1332.          gint        off_y)
  1333. {
  1334.   gint x1, y1, x2, y2;
  1335.   PixelRegion srcPR;
  1336.  
  1337.   x1 = CLAMP (off_x, 0, GIMP_DRAWABLE (output)->width);
  1338.   y1 = CLAMP (off_y, 0, GIMP_DRAWABLE (output)->height);
  1339.   x2 = CLAMP (off_x + GIMP_DRAWABLE (input)->width, 0,
  1340.           GIMP_DRAWABLE (output)->width);
  1341.   y2 = CLAMP (off_y + GIMP_DRAWABLE (input)->height, 0,
  1342.           GIMP_DRAWABLE (output)->height);
  1343.  
  1344.   pixel_region_init (&srcPR, GIMP_DRAWABLE (input)->tiles,
  1345.              (x1 - off_x), (y1 - off_y), (x2 - x1), (y2 - y1), FALSE);
  1346.   gaussian_blur_region (&srcPR, radius_x, radius_y);
  1347.  
  1348.   if (input != output) 
  1349.     channel_combine_mask (output, input, op, 0, 0);
  1350.  
  1351.   output->bounds_known = FALSE;
  1352. }
  1353.  
  1354. void
  1355. channel_push_undo (Channel *mask)
  1356. {
  1357.   gint x1, y1, x2, y2;
  1358.   MaskUndo *mask_undo;
  1359.   TileManager *undo_tiles;
  1360.   PixelRegion srcPR, destPR;
  1361.   GImage *gimage;
  1362.  
  1363.   mask_undo = g_new (MaskUndo, 1);
  1364.   if (channel_bounds (mask, &x1, &y1, &x2, &y2))
  1365.     {
  1366.       undo_tiles = tile_manager_new ((x2 - x1), (y2 - y1), 1);
  1367.       pixel_region_init (&srcPR, GIMP_DRAWABLE (mask)->tiles,
  1368.              x1, y1, (x2 - x1), (y2 - y1), FALSE);
  1369.       pixel_region_init (&destPR, undo_tiles, 0, 0, (x2 - x1), (y2 - y1), TRUE);
  1370.       copy_region (&srcPR, &destPR);
  1371.     }
  1372.   else
  1373.     undo_tiles = NULL;
  1374.  
  1375.   mask_undo->tiles = undo_tiles;
  1376.   mask_undo->x     = x1;
  1377.   mask_undo->y     = y1;
  1378.  
  1379.   /* push the undo buffer onto the undo stack */
  1380.   gimage = GIMP_DRAWABLE (mask)->gimage;
  1381.   undo_push_mask (gimage, mask_undo);
  1382.   gimage_mask_invalidate (gimage);
  1383.  
  1384.   /*  invalidate the preview  */
  1385.   GIMP_DRAWABLE (mask)->preview_valid = FALSE;
  1386. }
  1387.  
  1388. void
  1389. channel_clear (Channel *mask)
  1390. {
  1391.   PixelRegion maskPR;
  1392.   guchar bg = 0;
  1393.  
  1394.   /*  push the current channel onto the undo stack  */
  1395.   channel_push_undo (mask);
  1396.  
  1397.   if (mask->bounds_known && !mask->empty)
  1398.     {
  1399.       pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1400.              mask->x1, mask->y1,
  1401.              (mask->x2 - mask->x1), (mask->y2 - mask->y1), TRUE);
  1402.       color_region (&maskPR, &bg);
  1403.     }
  1404.   else
  1405.     {
  1406.       /*  clear the mask  */
  1407.       pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1408.              0, 0,
  1409.              GIMP_DRAWABLE (mask)->width,
  1410.              GIMP_DRAWABLE (mask)->height, TRUE);
  1411.       color_region (&maskPR, &bg);
  1412.     }
  1413.  
  1414.   /*  we know the bounds  */
  1415.   mask->bounds_known = TRUE;
  1416.   mask->empty        = TRUE;
  1417.   mask->x1           = 0;
  1418.   mask->y1           = 0;
  1419.   mask->x2           = GIMP_DRAWABLE (mask)->width;
  1420.   mask->y2           = GIMP_DRAWABLE (mask)->height;
  1421. }
  1422.  
  1423. void
  1424. channel_invert (Channel *mask)
  1425. {
  1426.   PixelRegion maskPR;
  1427.   GimpLut *lut;
  1428.  
  1429.   /*  push the current channel onto the undo stack  */
  1430.   channel_push_undo (mask);
  1431.  
  1432.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1433.              0, 0,
  1434.              GIMP_DRAWABLE (mask)->width,
  1435.              GIMP_DRAWABLE (mask)->height, TRUE);
  1436.   
  1437.   lut = invert_lut_new (1);
  1438.  
  1439.   pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
  1440.                   lut, 1, &maskPR);
  1441.   gimp_lut_free (lut);
  1442.   mask->bounds_known = FALSE;
  1443. }
  1444.  
  1445. void
  1446. channel_sharpen (Channel *mask)
  1447. {
  1448.   PixelRegion maskPR;
  1449.   GimpLut *lut;
  1450.  
  1451.   /*  push the current channel onto the undo stack  */
  1452.   channel_push_undo (mask);
  1453.  
  1454.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1455.              0, 0,
  1456.              GIMP_DRAWABLE (mask)->width,
  1457.              GIMP_DRAWABLE (mask)->height, TRUE);
  1458.   lut = threshold_lut_new (0.5, 1);
  1459.  
  1460.   pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
  1461.                   lut, 1, &maskPR);
  1462.   gimp_lut_free (lut);
  1463. }
  1464.  
  1465. void
  1466. channel_all (Channel *mask)
  1467. {
  1468.   PixelRegion maskPR;
  1469.   guchar bg = 255;
  1470.  
  1471.   /*  push the current channel onto the undo stack  */
  1472.   channel_push_undo (mask);
  1473.  
  1474.   /*  clear the mask  */
  1475.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1476.              0, 0,
  1477.              GIMP_DRAWABLE (mask)->width,
  1478.              GIMP_DRAWABLE (mask)->height, TRUE);
  1479.   color_region (&maskPR, &bg);
  1480.  
  1481.   /*  we know the bounds  */
  1482.   mask->bounds_known = TRUE;
  1483.   mask->empty        = FALSE;
  1484.   mask->x1           = 0;
  1485.   mask->y1           = 0;
  1486.   mask->x2           = GIMP_DRAWABLE (mask)->width;
  1487.   mask->y2           = GIMP_DRAWABLE (mask)->height;
  1488. }
  1489.  
  1490. void
  1491. channel_border (Channel *mask,
  1492.         gint     radius_x,
  1493.         gint     radius_y)
  1494. {
  1495.   PixelRegion bPR;
  1496.   gint x1, y1, x2, y2;
  1497.  
  1498.   if (radius_x < 0 || radius_y < 0)
  1499.     return;
  1500.  
  1501.   if (! channel_bounds (mask, &x1, &y1, &x2, &y2))
  1502.     return;
  1503.   if (channel_is_empty (mask))
  1504.     return;
  1505.  
  1506.   if (x1 - radius_x < 0)
  1507.     x1 = 0;
  1508.   else
  1509.     x1 -= radius_x;
  1510.   if (x2 + radius_x > GIMP_DRAWABLE (mask)->width)
  1511.     x2 = GIMP_DRAWABLE (mask)->width;
  1512.   else
  1513.     x2 += radius_x;
  1514.  
  1515.   if (y1 - radius_y < 0)
  1516.     y1 = 0;
  1517.   else
  1518.     y1 -= radius_y;
  1519.   if (y2 + radius_y > GIMP_DRAWABLE (mask)->height)
  1520.     y2 = GIMP_DRAWABLE (mask)->height;
  1521.   else
  1522.     y2 += radius_y;
  1523.   /*  push the current channel onto the undo stack  */
  1524.   channel_push_undo (mask);
  1525.  
  1526.   pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles, x1, y1,
  1527.              (x2-x1), (y2-y1), TRUE);
  1528.  
  1529.   border_region (&bPR, radius_x, radius_y);
  1530.  
  1531.   mask->bounds_known = FALSE;
  1532. }
  1533.  
  1534. void
  1535. channel_grow (Channel *mask,
  1536.           gint     radius_x,
  1537.           gint     radius_y)
  1538. {
  1539.   PixelRegion bPR;
  1540.   gint x1, y1, x2, y2;
  1541.  
  1542.   if (radius_x == 0 && radius_y == 0)
  1543.     return;
  1544.  
  1545.   if (radius_x <= 0 && radius_y <= 0)
  1546.     {
  1547.       channel_shrink (mask, -radius_x, -radius_y, FALSE);
  1548.       return;
  1549.     }
  1550.  
  1551.   if (radius_x < 0 || radius_y < 0)
  1552.     return;
  1553.   
  1554.   if (! channel_bounds (mask, &x1, &y1, &x2, &y2))
  1555.     return;
  1556.   if (channel_is_empty (mask))
  1557.     return;
  1558.  
  1559.   if (x1 - radius_x > 0)
  1560.     x1 = x1 - radius_x;
  1561.   else
  1562.     x1 = 0;
  1563.   if (y1 - radius_y > 0)
  1564.     y1 = y1 - radius_y;
  1565.   else
  1566.     y1 = 0;
  1567.   if (x2 + radius_x < GIMP_DRAWABLE (mask)->width)
  1568.     x2 = x2 + radius_x;
  1569.   else
  1570.     x2 = GIMP_DRAWABLE (mask)->width;
  1571.   if (y2 + radius_y < GIMP_DRAWABLE (mask)->height)
  1572.     y2 = y2 + radius_y;
  1573.   else
  1574.     y2 = GIMP_DRAWABLE (mask)->height;
  1575.  
  1576.   /*  push the current channel onto the undo stack  */
  1577.   channel_push_undo (mask);
  1578.  
  1579.   /*  need full extents for grow, not! */
  1580.   pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles, x1, y1, (x2 - x1),
  1581.              (y2 - y1), TRUE);
  1582.  
  1583.   fatten_region (&bPR, radius_x, radius_y);
  1584.  
  1585.   mask->bounds_known = FALSE;
  1586. }
  1587.  
  1588. void
  1589. channel_shrink (Channel  *mask,
  1590.         gint      radius_x,
  1591.         gint      radius_y,
  1592.         gboolean  edge_lock)
  1593. {
  1594.   PixelRegion bPR;
  1595.   gint x1, y1, x2, y2;
  1596.  
  1597.   if (radius_x == 0 && radius_y == 0)
  1598.     return;
  1599.  
  1600.   if (radius_x <= 0 && radius_y <= 0)
  1601.     {
  1602.       channel_grow (mask, -radius_x, -radius_y);
  1603.       return;
  1604.     }
  1605.  
  1606.   if (radius_x < 0 || radius_y < 0)
  1607.     return;
  1608.   
  1609.   if (! channel_bounds (mask, &x1, &y1, &x2, &y2))
  1610.     return;
  1611.   if (channel_is_empty (mask))
  1612.     return;
  1613.  
  1614.   if (x1 > 0)
  1615.     x1--;
  1616.   if (y1 > 0)
  1617.     y1--;
  1618.   if (x2 < GIMP_DRAWABLE (mask)->width)
  1619.     x2++;
  1620.   if (y2 < GIMP_DRAWABLE (mask)->height)
  1621.     y2++;
  1622.  
  1623.   /*  push the current channel onto the undo stack  */
  1624.   channel_push_undo (mask);
  1625.  
  1626.   pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles, x1, y1, (x2 - x1),
  1627.              (y2 - y1), TRUE);
  1628.  
  1629.   thin_region (&bPR, radius_x, radius_y, edge_lock);
  1630.  
  1631.   mask->bounds_known = FALSE;
  1632. }
  1633.  
  1634. void
  1635. channel_translate (Channel *mask,
  1636.            gint     off_x,
  1637.            gint     off_y)
  1638. {
  1639.   gint width, height;
  1640.   Channel *tmp_mask;
  1641.   PixelRegion srcPR, destPR;
  1642.   guchar empty = 0;
  1643.   gint   x1, y1, x2, y2;
  1644.  
  1645.   tmp_mask = NULL;
  1646.  
  1647.   /*  push the current channel onto the undo stack  */
  1648.   channel_push_undo (mask);
  1649.  
  1650.   channel_bounds (mask, &x1, &y1, &x2, &y2);
  1651.   x1 = CLAMP ((x1 + off_x), 0, GIMP_DRAWABLE (mask)->width);
  1652.   y1 = CLAMP ((y1 + off_y), 0, GIMP_DRAWABLE (mask)->height);
  1653.   x2 = CLAMP ((x2 + off_x), 0, GIMP_DRAWABLE (mask)->width);
  1654.   y2 = CLAMP ((y2 + off_y), 0, GIMP_DRAWABLE (mask)->height);
  1655.  
  1656.   width = x2 - x1;
  1657.   height = y2 - y1;
  1658.  
  1659.   /*  make sure width and height are non-zero  */
  1660.   if (width != 0 && height != 0)
  1661.     {
  1662.       /*  copy the portion of the mask we will keep to a
  1663.        *  temporary buffer
  1664.        */
  1665.       tmp_mask = channel_new_mask (GIMP_DRAWABLE (mask)->gimage, width, height);
  1666.  
  1667.       pixel_region_init (&srcPR, GIMP_DRAWABLE (mask)->tiles,
  1668.              x1 - off_x, y1 - off_y, width, height, FALSE);
  1669.       pixel_region_init (&destPR, GIMP_DRAWABLE (tmp_mask)->tiles,
  1670.              0, 0, width, height, TRUE);
  1671.       copy_region (&srcPR, &destPR);
  1672.     }
  1673.  
  1674.   /*  clear the mask  */
  1675.   pixel_region_init (&srcPR, GIMP_DRAWABLE (mask)->tiles,
  1676.              0, 0,
  1677.              GIMP_DRAWABLE (mask)->width,
  1678.              GIMP_DRAWABLE (mask)->height, TRUE);
  1679.   color_region (&srcPR, &empty);
  1680.  
  1681.   if (width != 0 && height != 0)
  1682.     {
  1683.       /*  copy the temp mask back to the mask  */
  1684.       pixel_region_init (&srcPR, GIMP_DRAWABLE (tmp_mask)->tiles,
  1685.              0, 0, width, height, FALSE);
  1686.       pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
  1687.              x1, y1, width, height, TRUE);
  1688.       copy_region (&srcPR, &destPR);
  1689.  
  1690.       /*  free the temporary mask  */
  1691.       channel_delete (tmp_mask);
  1692.     }
  1693.  
  1694.   /*  calculate new bounds  */
  1695.   if (width == 0 || height == 0)
  1696.     {
  1697.       mask->empty = TRUE;
  1698.       mask->x1 = 0; mask->y1 = 0;
  1699.       mask->x2 = GIMP_DRAWABLE (mask)->width;
  1700.       mask->y2 = GIMP_DRAWABLE (mask)->height;
  1701.     }
  1702.   else
  1703.     {
  1704.       mask->x1 = x1;
  1705.       mask->y1 = y1;
  1706.       mask->x2 = x2;
  1707.       mask->y2 = y2;
  1708.     }
  1709. }
  1710.  
  1711. void
  1712. channel_layer_alpha (Channel *mask,
  1713.              Layer   *layer)
  1714. {
  1715.   PixelRegion srcPR, destPR;
  1716.   guchar empty = 0;
  1717.   gint   x1, y1, x2, y2;
  1718.  
  1719.   /*  push the current mask onto the undo stack  */
  1720.   channel_push_undo (mask);
  1721.  
  1722.   /*  clear the mask  */
  1723.   pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
  1724.              0, 0,
  1725.              GIMP_DRAWABLE (mask)->width,
  1726.              GIMP_DRAWABLE (mask)->height, TRUE);
  1727.   color_region (&destPR, &empty);
  1728.  
  1729.   x1 = CLAMP (GIMP_DRAWABLE (layer)->offset_x, 0, GIMP_DRAWABLE (mask)->width);
  1730.   y1 = CLAMP (GIMP_DRAWABLE (layer)->offset_y, 0, GIMP_DRAWABLE (mask)->height);
  1731.   x2 = CLAMP (GIMP_DRAWABLE (layer)->offset_x + GIMP_DRAWABLE (layer)->width,
  1732.           0, GIMP_DRAWABLE (mask)->width);
  1733.   y2 = CLAMP (GIMP_DRAWABLE( layer)->offset_y + GIMP_DRAWABLE (layer)->height,
  1734.           0, GIMP_DRAWABLE (mask)->height);
  1735.  
  1736.   pixel_region_init (&srcPR, GIMP_DRAWABLE (layer)->tiles,
  1737.              (x1 - GIMP_DRAWABLE (layer)->offset_x),
  1738.              (y1 - GIMP_DRAWABLE (layer)->offset_y),
  1739.              (x2 - x1), (y2 - y1), FALSE);
  1740.   pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
  1741.              x1, y1, (x2 - x1), (y2 - y1), TRUE);
  1742.   extract_alpha_region (&srcPR, NULL, &destPR);
  1743.  
  1744.   mask->bounds_known = FALSE;
  1745. }
  1746.  
  1747. void
  1748. channel_load (Channel *mask,
  1749.           Channel *channel)
  1750. {
  1751.   PixelRegion srcPR, destPR;
  1752.  
  1753.   /*  push the current mask onto the undo stack  */
  1754.   channel_push_undo (mask);
  1755.  
  1756.   /*  copy the channel to the mask  */
  1757.   pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
  1758.              0, 0,
  1759.              GIMP_DRAWABLE (channel)->width,
  1760.              GIMP_DRAWABLE (channel)->height, FALSE);
  1761.   pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
  1762.              0, 0,
  1763.              GIMP_DRAWABLE (channel)->width,
  1764.              GIMP_DRAWABLE (channel)->height, TRUE);
  1765.   copy_region (&srcPR, &destPR);
  1766.  
  1767.   mask->bounds_known = FALSE;
  1768. }
  1769.  
  1770. void
  1771. channel_invalidate_bounds (Channel *channel)
  1772. {
  1773.   channel->bounds_known = FALSE;
  1774. }
  1775.  
  1776.