gimpimage-scale.h 8.56 KB
Newer Older
1 2 3
#ifndef __GIMPIMAGE_H__
#define __GIMPIMAGE_H__

4
#include "procedural_db.h"
5 6 7 8 9 10
#include "gimpimageF.h"

#include "boundary.h"
#include "drawable.h"
#include "channel.h"
#include "layer.h"
11
#include <libgimp/parasiteF.h>
12
#include "plug_in.h"
13 14 15 16
#include "temp_buf.h"
#include "tile_manager.h"


17 18 19
#define GIMP_TYPE_IMAGE gimp_image_get_type()

#define GIMP_IMAGE(obj) GTK_CHECK_CAST (obj, GIMP_TYPE_IMAGE, GimpImage)
20
     
21
#define GIMP_IS_GIMAGE(obj) GTK_CHECK_TYPE (obj, GIMP_TYPE_IMAGE)
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
     

/* the image types */
typedef enum
{
        RGB_GIMAGE,
        RGBA_GIMAGE,
        GRAY_GIMAGE,
        GRAYA_GIMAGE,  
        INDEXED_GIMAGE,
        INDEXEDA_GIMAGE
} GimpImageType;



#define TYPE_HAS_ALPHA(t)  ((t)==RGBA_GIMAGE || (t)==GRAYA_GIMAGE || (t)==INDEXEDA_GIMAGE)

#define GRAY_PIX         0
#define ALPHA_G_PIX      1
#define RED_PIX          0
#define GREEN_PIX        1
#define BLUE_PIX         2
#define ALPHA_PIX        3
#define INDEXED_PIX      0
#define ALPHA_I_PIX      1

typedef enum
{
        RGB,
        GRAY,
        INDEXED
} GimpImageBaseType;


#define COLORMAP_SIZE    768

#define HORIZONTAL_GUIDE 1
#define VERTICAL_GUIDE   2

typedef enum
{
  Red,
  Green,
  Blue,
  Gray,
  Indexed,
  Auxillary
} ChannelType;

typedef enum
{
  ExpandAsNecessary,
  ClipToImage,
  ClipToBottomLayer,
  FlattenImage
} MergeType;


80
/* Ugly! Move this someplace else! Prolly to gdisplay.. */
81 82 83 84 85 86

struct _Guide
{
  int ref_count;
  int position;
  int orientation;
87
  guint32 guide_ID;
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
};


typedef struct _GimpImageRepaintArg{
	Layer* layer;
	guint x;
	guint y;
	guint width;
	guint height;
} GimpImageRepaintArg;
	
	
GtkType gimp_image_get_type(void);


/* function declarations */

GimpImage *        gimp_image_new                    (int, int, int);
void            gimp_image_set_filename           (GimpImage *, char *);
107 108 109 110
void            gimp_image_set_resolution         (GimpImage *, float, float);
void            gimp_image_get_resolution         (GimpImage *,
						   float *,
						   float *);
111 112
void            gimp_image_set_save_proc    (GimpImage *, PlugInProcDef *);
PlugInProcDef * gimp_image_get_save_proc    (GimpImage *);
113 114 115 116 117 118
void            gimp_image_resize                 (GimpImage *, int, int, int, int);
void            gimp_image_scale                  (GimpImage *, int, int);
GimpImage *        gimp_image_get_named              (char *);
GimpImage *        gimp_image_get_ID                 (int);
TileManager *   gimp_image_shadow                 (GimpImage *, int, int, int);
void            gimp_image_free_shadow            (GimpImage *);
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
void            gimp_image_apply_image            (GimpImage *, GimpDrawable *,
						   PixelRegion *, int,
						   int, int,
						   TileManager *, int, int);
void            gimp_image_replace_image          (GimpImage *, GimpDrawable *,
						   PixelRegion *, int, int,
						   PixelRegion *, int, int);
void            gimp_image_get_foreground         (GimpImage *, GimpDrawable *,
						   unsigned char *);
void            gimp_image_get_background         (GimpImage *, GimpDrawable *,
						   unsigned char *);
void            gimp_image_get_color              (GimpImage *, int,
						   unsigned char *,
						   unsigned char *);
void            gimp_image_transform_color        (GimpImage *, GimpDrawable *,
						   unsigned char *,
						   unsigned char *, int);
136 137 138 139 140 141
Guide*          gimp_image_add_hguide             (GimpImage *);
Guide*          gimp_image_add_vguide             (GimpImage *);
void            gimp_image_add_guide              (GimpImage *, Guide *);
void            gimp_image_remove_guide           (GimpImage *, Guide *);
void            gimp_image_delete_guide           (GimpImage *, Guide *);

142
Parasite *      gimp_image_find_parasite          (const GimpImage *,
143
						   const char *name);
144
void            gimp_image_attach_parasite        (GimpImage *, Parasite *);
145 146
void            gimp_image_detach_parasite        (GimpImage *, const char *);

147
Tattoo          gimp_image_get_new_tattoo         (GimpImage *);
148

149 150 151 152 153 154 155

/*  layer/channel functions  */

int             gimp_image_get_layer_index        (GimpImage *, Layer *);
int             gimp_image_get_channel_index      (GimpImage *, Channel *);
Layer *         gimp_image_get_active_layer       (GimpImage *);
Channel *       gimp_image_get_active_channel     (GimpImage *);
156 157
Layer *         gimp_image_get_layer_by_tattoo    (GimpImage *, Tattoo);
Channel *       gimp_image_get_channel_by_tattoo  (GimpImage *, Tattoo);
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
Channel *       gimp_image_get_mask               (GimpImage *);
int             gimp_image_get_component_active   (GimpImage *, ChannelType);
int             gimp_image_get_component_visible  (GimpImage *, ChannelType);
int             gimp_image_layer_boundary         (GimpImage *, BoundSeg **, int *);
Layer *         gimp_image_set_active_layer       (GimpImage *, Layer *);
Channel *       gimp_image_set_active_channel     (GimpImage *, Channel *);
Channel *       gimp_image_unset_active_channel   (GimpImage *);
void            gimp_image_set_component_active   (GimpImage *, ChannelType, int);
void            gimp_image_set_component_visible  (GimpImage *, ChannelType, int);
Layer *         gimp_image_pick_correlate_layer   (GimpImage *, int, int);
void            gimp_image_set_layer_mask_apply   (GimpImage *, int);
void            gimp_image_set_layer_mask_edit    (GimpImage *, Layer *, int);
void            gimp_image_set_layer_mask_show    (GimpImage *, int);
Layer *         gimp_image_raise_layer            (GimpImage *, Layer *);
Layer *         gimp_image_lower_layer            (GimpImage *, Layer *);
173 174
Layer *         gimp_image_raise_layer_to_top     (GimpImage *, Layer *);
Layer *         gimp_image_lower_layer_to_bottom  (GimpImage *, Layer *);
175
Layer *         gimp_image_merge_visible_layers   (GimpImage *, MergeType);
176
Layer *         gimp_image_merge_down   (GimpImage *, Layer *, MergeType);
177 178 179 180 181 182 183 184 185 186 187 188
Layer *         gimp_image_flatten                (GimpImage *);
Layer *         gimp_image_merge_layers           (GimpImage *, GSList *, MergeType);
Layer *         gimp_image_add_layer              (GimpImage *, Layer *, int);
Layer *         gimp_image_remove_layer           (GimpImage *, Layer *);
LayerMask *     gimp_image_add_layer_mask         (GimpImage *, Layer *, LayerMask *);
Channel *       gimp_image_remove_layer_mask      (GimpImage *, Layer *, int);
Channel *       gimp_image_raise_channel          (GimpImage *, Channel *);
Channel *       gimp_image_lower_channel          (GimpImage *, Channel *);
Channel *       gimp_image_add_channel            (GimpImage *, Channel *, int);
Channel *       gimp_image_remove_channel         (GimpImage *, Channel *);
void            gimp_image_construct              (GimpImage *, int, int, int, int);
void            gimp_image_invalidate             (GimpImage *, int, int, int, int, int, int, int, int);
189
void            gimp_image_validate               (TileManager *, Tile *);
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225

/*  Access functions  */

int             gimp_image_is_empty               (GimpImage *);
GimpDrawable *  gimp_image_active_drawable        (GimpImage *);
int             gimp_image_base_type              (GimpImage *);
int             gimp_image_base_type_with_alpha   (GimpImage *);
char *          gimp_image_filename               (GimpImage *);
int             gimp_image_enable_undo            (GimpImage *);
int             gimp_image_disable_undo           (GimpImage *);
int             gimp_image_dirty                  (GimpImage *);
int             gimp_image_clean                  (GimpImage *);
void            gimp_image_clean_all              (GimpImage *);
Layer *         gimp_image_floating_sel           (GimpImage *);
unsigned char * gimp_image_cmap                   (GimpImage *);


/*  projection access functions  */

TileManager *   gimp_image_projection             (GimpImage *);
int             gimp_image_projection_type        (GimpImage *);
int             gimp_image_projection_bytes       (GimpImage *);
int             gimp_image_projection_opacity     (GimpImage *);
void            gimp_image_projection_realloc     (GimpImage *);


/*  composite access functions  */

TileManager *   gimp_image_composite              (GimpImage *);
int             gimp_image_composite_type         (GimpImage *);
int             gimp_image_composite_bytes        (GimpImage *);
TempBuf *       gimp_image_composite_preview      (GimpImage *, ChannelType, int, int);
int             gimp_image_preview_valid          (GimpImage *, ChannelType);
void            gimp_image_invalidate_preview     (GimpImage *);

void            gimp_image_invalidate_previews    (void);
226
TempBuf *       gimp_image_construct_composite_preview (GimpImage *gimage, int width, int height);
227 228

#endif