home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / gimpimage.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  11.7 KB  |  296 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 __GIMPIMAGE_H__
  20. #define __GIMPIMAGE_H__
  21.  
  22. #include "apptypes.h"
  23. #include "procedural_db.h"
  24. #include "boundary.h"
  25. #include "drawable.h"
  26. #include "channel.h"
  27. #include "layer.h"
  28. #include "plug_in.h"
  29. #include "temp_buf.h"
  30. #include "tile_manager.h"
  31. #include "path.h"
  32.  
  33. #include "libgimp/gimpparasite.h"
  34. #include "libgimp/gimpunit.h"
  35.  
  36.  
  37. #define GIMP_TYPE_IMAGE    gimp_image_get_type()
  38. #define GIMP_IMAGE(obj)    GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage)
  39. #define GIMP_IS_IMAGE(obj) GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE)
  40.      
  41. #define GIMP_IMAGE_TYPE_HAS_ALPHA(t)  ((t)==RGBA_GIMAGE || (t)==GRAYA_GIMAGE || (t)==INDEXEDA_GIMAGE)
  42.  
  43. #define GRAY_PIX         0
  44. #define ALPHA_G_PIX      1
  45. #define RED_PIX          0
  46. #define GREEN_PIX        1
  47. #define BLUE_PIX         2
  48. #define ALPHA_PIX        3
  49. #define INDEXED_PIX      0
  50. #define ALPHA_I_PIX      1
  51.  
  52. #define COLORMAP_SIZE    768
  53.  
  54. typedef enum /*< skip >*/
  55. { 
  56.   ORIENTATION_UNKNOWN,
  57.   ORIENTATION_HORIZONTAL,
  58.   ORIENTATION_VERTICAL
  59. } InternalOrientationType;
  60.  
  61. typedef enum
  62. {
  63.   HORIZONTAL,
  64.   VERTICAL,
  65.   UNKNOWN
  66. } OrientationType;
  67.  
  68. typedef enum
  69. {
  70.   RED_CHANNEL,
  71.   GREEN_CHANNEL,
  72.   BLUE_CHANNEL,
  73.   GRAY_CHANNEL,
  74.   INDEXED_CHANNEL,
  75.   AUXILLARY_CHANNEL
  76. } ChannelType;
  77.  
  78. typedef enum
  79. {
  80.   EXPAND_AS_NECESSARY,
  81.   CLIP_TO_IMAGE,
  82.   CLIP_TO_BOTTOM_LAYER,
  83.   FLATTEN_IMAGE
  84. } MergeType;
  85.  
  86.  
  87. /* Ugly! Move this someplace else! Prolly to gdisplay.. */
  88.  
  89. struct _Guide
  90. {
  91.   int ref_count;
  92.   int position;
  93.   int orientation;
  94.   guint32 guide_ID;
  95. };
  96.  
  97.  
  98. typedef struct _GimpImageRepaintArg
  99. {
  100.   Layer *layer;
  101.   guint  x;
  102.   guint  y;
  103.   guint  width;
  104.   guint  height;
  105. } GimpImageRepaintArg;
  106.     
  107.     
  108. GtkType gimp_image_get_type (void);
  109.  
  110.  
  111. /* function declarations */
  112.  
  113. GimpImage *     gimp_image_new                    (gint, gint,
  114.                            GimpImageBaseType);
  115. void            gimp_image_set_filename           (GimpImage *, gchar *);
  116. void            gimp_image_set_resolution         (GimpImage *,
  117.                            gdouble, gdouble);
  118. void            gimp_image_get_resolution         (GimpImage *,
  119.                            gdouble *, gdouble *);
  120. void            gimp_image_set_unit               (GimpImage *, GimpUnit);
  121. GimpUnit        gimp_image_get_unit               (GimpImage *);
  122. void            gimp_image_set_save_proc      (GimpImage *,
  123.                            PlugInProcDef *);
  124. PlugInProcDef * gimp_image_get_save_proc      (GimpImage *);
  125. gint        gimp_image_get_width          (const GimpImage *);
  126. gint        gimp_image_get_height          (const GimpImage *);
  127. void            gimp_image_resize                 (GimpImage *,
  128.                            gint, gint, gint, gint);
  129. void            gimp_image_scale                  (GimpImage *, gint, gint);
  130. GimpImage *     gimp_image_get_named              (gchar *);
  131. GimpImage *     gimp_image_get_ID                 (gint);
  132. TileManager *   gimp_image_shadow                 (GimpImage *,
  133.                            gint, gint, gint);
  134. void            gimp_image_free_shadow            (GimpImage *);
  135. void            gimp_image_apply_image            (GimpImage *, GimpDrawable *,
  136.                            PixelRegion *, gint,
  137.                            gint,
  138.                            LayerModeEffects,
  139.                            TileManager *, gint, gint);
  140. void            gimp_image_replace_image          (GimpImage *, GimpDrawable *,
  141.                            PixelRegion *, gint, gint,
  142.                            PixelRegion *, gint, gint);
  143. void            gimp_image_get_foreground         (GimpImage *, GimpDrawable *,
  144.                            guchar *);
  145. void            gimp_image_get_background         (GimpImage *, GimpDrawable *,
  146.                            guchar *);
  147. guchar *        gimp_image_get_color_at           (GimpImage *, gint, gint);
  148.                            
  149. void            gimp_image_get_color              (GimpImage *,
  150.                            GimpImageType,
  151.                            guchar *,
  152.                            guchar *);
  153. void            gimp_image_transform_color        (GimpImage *,
  154.                            GimpDrawable *,
  155.                            guchar *,
  156.                            guchar *,
  157.                            GimpImageBaseType);
  158. Guide*          gimp_image_add_hguide             (GimpImage *);
  159. Guide*          gimp_image_add_vguide             (GimpImage *);
  160. void            gimp_image_add_guide              (GimpImage *, Guide *);
  161. void            gimp_image_remove_guide           (GimpImage *, Guide *);
  162. void            gimp_image_delete_guide           (GimpImage *, Guide *);
  163.  
  164. GimpParasite *  gimp_image_parasite_find          (const GimpImage *,
  165.                            const gchar *name);
  166. gchar **        gimp_image_parasite_list          (GimpImage *gimage,
  167.                                                    gint *count);
  168. void            gimp_image_parasite_attach        (GimpImage *,
  169.                            GimpParasite *);
  170. void            gimp_image_parasite_detach        (GimpImage *, const gchar *);
  171.  
  172. Tattoo          gimp_image_get_new_tattoo         (GimpImage *);
  173. gboolean        gimp_image_set_tattoo_state       (GimpImage *, Tattoo);
  174. Tattoo          gimp_image_get_tattoo_state       (GimpImage *);
  175.  
  176. void            gimp_image_set_paths              (GimpImage *, PathList *);
  177. PathList *      gimp_image_get_paths              (GimpImage *);
  178.  
  179. /* Temporary hack till colormap manipulation is encapsulated in functions.
  180.    Call this whenever you modify an image's colormap. The ncol argument
  181.    specifies which color has changed, or negative if there's a bigger change.
  182.    Currently, use this also when the image's base type is changed to/from
  183.    indexed.  */
  184.  
  185. void        gimp_image_colormap_changed      (GimpImage * image,
  186.                            gint ncol);
  187.  
  188.  
  189. /*  layer/channel functions  */
  190.  
  191. gint            gimp_image_get_layer_index        (GimpImage *, Layer *);
  192. gint            gimp_image_get_channel_index      (GimpImage *, Channel *);
  193. Layer *         gimp_image_get_active_layer       (GimpImage *);
  194. Channel *       gimp_image_get_active_channel     (GimpImage *);
  195. Layer *         gimp_image_get_layer_by_tattoo    (GimpImage *, Tattoo);
  196. Channel *       gimp_image_get_channel_by_tattoo  (GimpImage *, Tattoo);
  197. Channel *       gimp_image_get_channel_by_name    (GimpImage *, gchar *);
  198. Channel *       gimp_image_get_mask               (GimpImage *);
  199. gint            gimp_image_get_component_active   (GimpImage *, ChannelType);
  200. gint            gimp_image_get_component_visible  (GimpImage *, ChannelType);
  201. gboolean        gimp_image_layer_boundary         (GimpImage *, BoundSeg **,
  202.                            gint *);
  203. Layer *         gimp_image_set_active_layer       (GimpImage *, Layer *);
  204. Channel *       gimp_image_set_active_channel     (GimpImage *, Channel *);
  205. Channel *       gimp_image_unset_active_channel   (GimpImage *);
  206. void            gimp_image_set_component_active   (GimpImage *, ChannelType,
  207.                            gint);
  208. void            gimp_image_set_component_visible  (GimpImage *, ChannelType,
  209.                            gint);
  210. Layer *         gimp_image_pick_correlate_layer   (GimpImage *, gint, gint);
  211. void            gimp_image_set_layer_mask_apply   (GimpImage *, gint);
  212. void            gimp_image_set_layer_mask_edit    (GimpImage *, Layer *, gint);
  213. void            gimp_image_set_layer_mask_show    (GimpImage *, gint);
  214. Layer *         gimp_image_raise_layer            (GimpImage *, Layer *);
  215. Layer *         gimp_image_lower_layer            (GimpImage *, Layer *);
  216. Layer *         gimp_image_raise_layer_to_top     (GimpImage *, Layer *);
  217. Layer *         gimp_image_lower_layer_to_bottom  (GimpImage *, Layer *);
  218. Layer *         gimp_image_position_layer         (GimpImage *, Layer *,
  219.                            gint, gboolean);
  220. Layer *         gimp_image_merge_visible_layers   (GimpImage *, MergeType);
  221. Layer *         gimp_image_merge_down             (GimpImage *, Layer *,
  222.                            MergeType);
  223. Layer *         gimp_image_flatten                (GimpImage *);
  224. Layer *         gimp_image_merge_layers           (GimpImage *, GSList *,
  225.                            MergeType);
  226. Layer *         gimp_image_add_layer              (GimpImage *, Layer *, gint);
  227. Layer *         gimp_image_remove_layer           (GimpImage *, Layer *);
  228. LayerMask *     gimp_image_add_layer_mask         (GimpImage *, Layer *,
  229.                            LayerMask *);
  230. Channel *       gimp_image_remove_layer_mask      (GimpImage *, Layer *,
  231.                            MaskApplyMode);
  232. Channel *       gimp_image_raise_channel          (GimpImage *, Channel *);
  233. Channel *       gimp_image_lower_channel          (GimpImage *, Channel *);
  234. Channel *       gimp_image_position_channel       (GimpImage *, Channel *, gint);
  235. Channel *       gimp_image_add_channel            (GimpImage *, Channel *, gint);
  236. Channel *       gimp_image_remove_channel         (GimpImage *, Channel *);
  237. void            gimp_image_construct              (GimpImage *,
  238.                            gint, gint, gint, gint,
  239.                            gboolean);
  240.  
  241. void            gimp_image_invalidate_without_render (GimpImage *, gint, gint,
  242.                               gint, gint, gint,
  243.                               gint, gint, gint);
  244. void            gimp_image_invalidate                (GimpImage *, gint, gint,
  245.                               gint, gint, gint,
  246.                               gint, gint, gint);
  247. void            gimp_image_validate                  (TileManager *, Tile *);
  248.  
  249. /*  Access functions  */
  250.  
  251. gboolean           gimp_image_is_empty             (GimpImage *);
  252. GimpDrawable *     gimp_image_active_drawable      (GimpImage *);
  253.  
  254. GimpImageBaseType  gimp_image_base_type            (GimpImage *gimage);
  255. GimpImageType       gimp_image_base_type_with_alpha (GimpImage *gimage);
  256.  
  257. gchar *            gimp_image_filename             (GimpImage *);
  258. gboolean           gimp_image_undo_is_enabled      (GimpImage *);
  259. gboolean           gimp_image_undo_enable          (GimpImage *);
  260. gboolean           gimp_image_undo_disable         (GimpImage *);
  261. gboolean           gimp_image_undo_freeze          (GimpImage *);
  262. gboolean           gimp_image_undo_thaw            (GimpImage *);
  263. void           gimp_image_undo_event       (GimpImage *, gint);
  264. gint               gimp_image_dirty                (GimpImage *);
  265. gint               gimp_image_clean                (GimpImage *);
  266. void               gimp_image_clean_all            (GimpImage *);
  267. Layer *            gimp_image_floating_sel         (GimpImage *);
  268. guchar *           gimp_image_cmap                 (GimpImage *);
  269.  
  270. /*  projection access functions  */
  271.  
  272. TileManager *   gimp_image_projection             (GimpImage *);
  273. GimpImageType    gimp_image_projection_type        (GimpImage *);
  274. gint            gimp_image_projection_bytes       (GimpImage *);
  275. gint            gimp_image_projection_opacity     (GimpImage *);
  276. void            gimp_image_projection_realloc     (GimpImage *);
  277.  
  278.  
  279. /*  composite access functions  */
  280.  
  281. TileManager *   gimp_image_composite              (GimpImage *);
  282. GimpImageType    gimp_image_composite_type         (GimpImage *);
  283. gint            gimp_image_composite_bytes        (GimpImage *);
  284. TempBuf *       gimp_image_composite_preview      (GimpImage *, ChannelType,
  285.                            gint, gint);
  286.  
  287. gint            gimp_image_preview_valid          (GimpImage *, ChannelType);
  288. void            gimp_image_invalidate_preview     (GimpImage *);
  289.  
  290. void            gimp_image_invalidate_previews    (void);
  291.  
  292. TempBuf *       gimp_image_construct_composite_preview (GimpImage *,
  293.                             gint , gint);
  294.  
  295. #endif /* __GIMPIMAGE_H__ */
  296.