home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / layer.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  7.2 KB  |  176 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 __LAYER_H__
  20. #define __LAYER_H__
  21.  
  22. #include "apptypes.h"
  23. #include "drawable.h"
  24. #include "boundary.h"
  25. #include "channel.h"
  26. #include "temp_buf.h"
  27. #include "tile_manager.h"
  28.  
  29.  
  30. /*  structure declarations  */
  31.  
  32. #define GIMP_TYPE_LAYER             (gimp_layer_get_type ())
  33. #define GIMP_LAYER(obj)             (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER, GimpLayer))
  34. #define GIMP_LAYER_CLASS(klass)     (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER, GimpLayerClass))
  35. #define GIMP_IS_LAYER(obj)          (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER))
  36. #define GIMP_IS_LAYER_CLASS(klass)  (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER))
  37.  
  38. #define GIMP_TYPE_LAYER_MASK             (gimp_layer_mask_get_type ())
  39. #define GIMP_LAYER_MASK(obj)             (GTK_CHECK_CAST ((obj), GIMP_TYPE_LAYER_MASK, GimpLayerMask))
  40. #define GIMP_LAYER_MASK_CLASS(klass)     (GTK_CHECK_CLASS_CAST ((klass), GIMP_TYPE_LAYER_MASK, GimpLayerMaskClass))
  41. #define GIMP_IS_LAYER_MASK(obj)          (GTK_CHECK_TYPE ((obj), GIMP_TYPE_LAYER_MASK))
  42. #define GIMP_IS_LAYER_MASK_CLASS(klass)  (GTK_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_LAYER_MASK))
  43.  
  44. GtkType gimp_layer_get_type      (void);
  45. GtkType gimp_layer_mask_get_type (void);
  46.  
  47. /*  Special undo types  */
  48.  
  49. struct _layer_undo
  50. {
  51.   Layer          *layer;              /*  the actual layer          */
  52.   gint            prev_position;      /*  former position in list   */
  53.   Layer          *prev_layer;         /*  previous active layer     */
  54. };
  55.  
  56. struct _layer_mask_undo
  57. {
  58.   Layer          *layer;         /*  the layer                 */
  59.   gboolean        apply_mask;    /*  apply mask?               */
  60.   gboolean        edit_mask;     /*  edit mask or layer?       */
  61.   gboolean        show_mask;     /*  show the mask?            */
  62.   LayerMask      *mask;          /*  the layer mask            */
  63.   gint            mode;          /*  the application mode      */
  64. };
  65.  
  66. struct _fs_to_layer_undo
  67. {
  68.   Layer        *layer;      /*  the layer                 */
  69.   GimpDrawable *drawable;   /*  drawable of floating sel  */
  70. };
  71.  
  72. /*  function declarations  */
  73.  
  74. Layer *         layer_new   (GimpImage        *gimage,
  75.                  gint              width,
  76.                  gint              height,
  77.                  GimpImageType     type,
  78.                  gchar            *name,
  79.                  gint              opacity,
  80.                  LayerModeEffects  mode);
  81. Layer *         layer_copy  (Layer            *layer,
  82.                  gboolean          add_alpha);
  83. Layer *        layer_ref   (Layer            *layer);
  84. void           layer_unref (Layer            *layer);
  85.  
  86. Layer *         layer_new_from_tiles        (GimpImage        *gimage,
  87.                          GimpImageType     layer_type,
  88.                          TileManager      *tiles,
  89.                          gchar            *name,
  90.                          gint              opacity,
  91.                          LayerModeEffects  mode);
  92. gboolean        layer_check_scaling         (Layer            *layer,
  93.                          gint              new_width,
  94.                          gint              new_height);
  95. LayerMask *     layer_create_mask           (Layer            *layer,
  96.                          AddMaskType       add_mask_type);
  97. LayerMask *     layer_add_mask              (Layer            *layer,
  98.                          LayerMask        *mask);
  99. Layer *         layer_get_ID                (gint              ID);
  100. void            layer_delete                (Layer            *layer);
  101. void            layer_removed               (Layer            *layer, 
  102.                          gpointer          data);
  103. void            layer_apply_mask            (Layer            *layer,
  104.                          MaskApplyMode     mode);
  105. void            layer_translate             (Layer            *layer,
  106.                          gint              off_x,
  107.                          gint              off_y);
  108. void            layer_add_alpha             (Layer            *layer);
  109. gboolean        layer_scale_by_factors      (Layer            *layer, 
  110.                          gdouble           w_factor, 
  111.                          gdouble           h_factor);
  112. void            layer_scale                 (Layer            *layer, 
  113.                          gint              new_width,
  114.                          gint              new_height,
  115.                          gboolean          local_origin);
  116. void            layer_resize                (Layer            *layer,
  117.                          gint              new_width,
  118.                          gint              new_height,
  119.                          gint              offx,
  120.                          gint              offy);
  121. void            layer_resize_to_image       (Layer            *layer);
  122. BoundSeg *      layer_boundary              (Layer            *layer, 
  123.                          gint             *num_segs);
  124. void            layer_invalidate_boundary   (Layer           *layer);
  125. gint            layer_pick_correlate        (Layer           *layer, 
  126.                          gint             x, 
  127.                          gint             y);
  128.  
  129. LayerMask *     layer_mask_new         (GimpImage *gimage,
  130.                       gint       width,
  131.                       gint       height,
  132.                       gchar     *name,
  133.                       gint       opacity,
  134.                       guchar    *col);
  135. LayerMask *    layer_mask_copy         (LayerMask *layer_mask);
  136. void        layer_mask_delete    (LayerMask *layer_mask);
  137. LayerMask *    layer_mask_get_ID    (gint       ID);
  138. LayerMask *    layer_mask_ref       (LayerMask *layer_mask);
  139. void           layer_mask_unref     (LayerMask *layer_mask);
  140. void            layer_mask_set_layer (LayerMask *layer_mask, 
  141.                       Layer     *layer);
  142. Layer *         layer_mask_get_layer (LayerMask *layer_mask);
  143.  
  144. /*  access functions  */
  145.  
  146. void            layer_set_name        (Layer *layer, 
  147.                        gchar *name);
  148. gchar *         layer_get_name        (Layer *layer);
  149. guchar *        layer_data            (Layer *layer);
  150. LayerMask *     layer_get_mask        (Layer *layer);
  151. gboolean        layer_has_alpha       (Layer *layer);
  152. gboolean        layer_is_floating_sel (Layer *layer);
  153. gboolean        layer_linked          (Layer *layer);
  154. TempBuf *       layer_preview         (Layer *layer, 
  155.                        gint   width, 
  156.                        gint   height);
  157. TempBuf *       layer_mask_preview    (Layer *layer, 
  158.                        gint   width, 
  159.                        gint   height);
  160.  
  161. void            layer_invalidate_previews (GimpImage   *gimage);
  162. Tattoo          layer_get_tattoo          (const Layer *layer);
  163. void            layer_set_tattoo          (const Layer *layer, 
  164.                        Tattoo       value);
  165.  
  166. #define drawable_layer      GIMP_IS_LAYER
  167. #define drawable_layer_mask GIMP_IS_LAYER_MASK
  168.  
  169. void            channel_layer_alpha (Channel *mask, 
  170.                      Layer   *layer);
  171. /*  from channel.c  */
  172. void            channel_layer_mask  (Channel *mask, 
  173.                      Layer   *layer);
  174.  
  175. #endif /* __LAYER_H__ */
  176.