home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / channel.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  6.8 KB  |  211 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. #ifndef __CHANNEL_H__
  20. #define __CHANNEL_H__
  21.  
  22. #include "apptypes.h"
  23. #include "drawable.h"
  24. #include "boundary.h"
  25. #include "temp_buf.h"
  26. #include "tile_manager.h"
  27.  
  28.  
  29. /* OPERATIONS */
  30.  
  31. typedef enum
  32. {
  33.   ADD,
  34.   SUB,
  35.   REPLACE,
  36.   INTERSECT
  37. } ChannelOps;
  38.  
  39. /*  Half way point where a region is no longer visible in a selection  */
  40. #define HALF_WAY 127
  41.  
  42. /*  structure declarations  */
  43.  
  44. #define GIMP_TYPE_CHANNEL             (gimp_channel_get_type ())
  45. #define GIMP_CHANNEL(obj)             (GTK_CHECK_CAST ((obj), GIMP_TYPE_CHANNEL, GimpChannel))
  46. #define GIMP_CHANNEL_CLASS(klass)     (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_CHANNEL, GimpChannelClass))
  47. #define GIMP_IS_CHANNEL(obj)          (GTK_CHECK_TYPE ((obj), GIMP_TYPE_CHANNEL))
  48. #define GIMP_IS_CHANNEL_CLASS(klass)  (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_CHANNEL))
  49.  
  50. GtkType gimp_channel_get_type (void);
  51.  
  52.  
  53. /*  Special undo type  */
  54. typedef struct _ChannelUndo ChannelUndo;
  55.  
  56. struct _ChannelUndo
  57. {
  58.   Channel          *channel;         /*  the actual channel          */
  59.   gint              prev_position;   /*  former position in list     */
  60.   Channel          *prev_channel;    /*  previous active channel     */
  61. };
  62.  
  63. /*  Special undo type  */
  64. typedef struct _MaskUndo MaskUndo;
  65.  
  66. struct _MaskUndo
  67. {
  68.   TileManager *tiles;       /*  the actual mask            */
  69.   gint         x, y;        /*  offsets                    */
  70. };
  71.  
  72.  
  73. /*  function declarations  */
  74.  
  75. Channel *       channel_new         (GimpImage *gimage,
  76.                      gint       width,
  77.                      gint       height,
  78.                      gchar     *name,
  79.                      gint       opacity,
  80.                      guchar    *col);
  81. Channel *       channel_copy        (Channel   *channel);
  82. Channel *    channel_ref         (Channel   *channel);
  83. void           channel_unref       (Channel   *channel);
  84.  
  85. gchar *         channel_get_name    (Channel   *channel);
  86. void            channel_set_name    (Channel   *channel, 
  87.                      gchar     *name);
  88.  
  89. gint            channel_get_opacity (Channel   *channel);
  90. void        channel_set_opacity (Channel   *channel, 
  91.                      gint       opacity);
  92.  
  93. guchar *        channel_get_color   (Channel   *channel);
  94. void         channel_set_color   (Channel   *channel, 
  95.                      guchar    *color);
  96.  
  97. Channel *       channel_get_ID      (gint       ID);
  98. void            channel_delete      (Channel   *channel);
  99. void            channel_removed     (Channel   *channel, 
  100.                      gpointer   data);
  101. void            channel_scale       (Channel   *channel, 
  102.                      gint       new_width, 
  103.                      gint       new_height);
  104. void            channel_resize      (Channel   *channel, 
  105.                      gint       new_width,
  106.                      gint       new_height,
  107.                      gint       offx,
  108.                      gint       offy);
  109. void            channel_update      (Channel   *channel);
  110.  
  111. /*  access functions  */
  112.  
  113. gboolean        channel_toggle_visibility   (Channel *channel);
  114. TempBuf *       channel_preview             (Channel *channel, 
  115.                          gint     width,
  116.                          gint     height);
  117.  
  118. void            channel_invalidate_previews (GimpImage *gimage);
  119.  
  120. Tattoo          channel_get_tattoo          (const Channel *channel);
  121. void            channel_set_tattoo          (const Channel *channel,
  122.                          Tattoo         value);
  123.  
  124. /* selection mask functions  */
  125.  
  126. Channel *       channel_new_mask        (GimpImage  *gimage,
  127.                      gint        width,
  128.                      gint        height);
  129. gboolean        channel_boundary        (Channel    *mask,
  130.                      BoundSeg  **segs_in,
  131.                      BoundSeg  **segs_out,
  132.                      gint       *num_segs_in,
  133.                      gint       *num_segs_out,
  134.                      gint        x1,
  135.                      gint        y1,
  136.                      gint        x2,
  137.                      gint        y2);
  138. gboolean        channel_bounds          (Channel    *mask,
  139.                      gint       *x1,
  140.                      gint       *y1,
  141.                      gint       *x2,
  142.                      gint       *y2);
  143. gint            channel_value           (Channel    *mask, 
  144.                      gint        x, 
  145.                      gint        y);
  146. gboolean        channel_is_empty        (Channel    *mask);
  147. void            channel_add_segment     (Channel    *mask,
  148.                      gint        x,
  149.                      gint        y,
  150.                      gint        width,
  151.                      gint        value);
  152. void            channel_sub_segment     (Channel    *mask,
  153.                      gint        x,
  154.                      gint        y,
  155.                      gint        width,
  156.                      gint        value);
  157. void            channel_combine_rect    (Channel    *mask,
  158.                      ChannelOps  op,
  159.                      gint        x,
  160.                      gint        y,
  161.                      gint        w,
  162.                      gint        h);
  163. void            channel_combine_ellipse (Channel    *mask,
  164.                      ChannelOps  op,
  165.                      gint        x,
  166.                      gint        y,
  167.                      gint        w,
  168.                      gint        h,
  169.                      gboolean    antialias);
  170. void            channel_combine_mask    (Channel    *mask,
  171.                      Channel    *add_on,
  172.                      ChannelOps  op,
  173.                      gint        off_x,
  174.                      gint        off_y);
  175. void            channel_feather         (Channel    *input,
  176.                      Channel    *output,
  177.                      gdouble     radius_x,
  178.                      gdouble     radius_y,
  179.                      ChannelOps  op,
  180.                      gint        off_x,
  181.                      gint        off_y);
  182.  
  183. void            channel_push_undo       (Channel    *mask);
  184. void            channel_clear           (Channel    *mask);
  185. void            channel_invert          (Channel    *mask);
  186. void            channel_sharpen         (Channel    *mask);
  187. void            channel_all             (Channel    *mask);
  188.  
  189. void            channel_border          (Channel   *mask,
  190.                      gint       radius_x,
  191.                      gint       radius_y);
  192. void            channel_grow            (Channel   *mask,
  193.                      gint       radius_x,
  194.                      gint       radius_y);
  195. void            channel_shrink          (Channel   *mask,
  196.                      gint       radius_x,
  197.                      gint       radius_y,
  198.                      gboolean   edge_lock);
  199.  
  200. void            channel_translate       (Channel   *mask,
  201.                      gint       off_x,
  202.                      gint       off_y);
  203. void            channel_load            (Channel   *mask,
  204.                      Channel   *channel);
  205.  
  206. void        channel_invalidate_bounds (Channel *channel);
  207.  
  208. #define drawable_channel GIMP_IS_CHANNEL
  209.  
  210. #endif /* __CHANNEL_H__ */
  211.