1 /* LIBGIMP - The GIMP Library 2 * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball 3 * 4 * This library is free software: you can redistribute it and/or 5 * modify it under the terms of the GNU Lesser General Public 6 * License as published by the Free Software Foundation; either 7 * version 3 of the License, or (at your option) any later version. 8 * 9 * This library 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 GNU 12 * Library General Public License for more details. 13 * 14 * You should have received a copy of the GNU Lesser General Public 15 * License along with this library. If not, see 16 * <https://www.gnu.org/licenses/>. 17 */ 18 19 #ifndef __GIMP_BASE_ENUMS_H__ 20 #define __GIMP_BASE_ENUMS_H__ 21 22 23 /** 24 * SECTION: gimpbaseenums 25 * @title: gimpbaseenums 26 * @short_description: Basic GIMP enumeration data types. 27 * 28 * Basic GIMP enumeration data types. 29 **/ 30 31 32 G_BEGIN_DECLS 33 34 /* For information look into the C source or the html documentation */ 35 36 37 /** 38 * GimpAddMaskType: 39 * @GIMP_ADD_MASK_WHITE: White (full opacity) 40 * @GIMP_ADD_MASK_BLACK: Black (full transparency) 41 * @GIMP_ADD_MASK_ALPHA: Layer's alpha channel 42 * @GIMP_ADD_MASK_ALPHA_TRANSFER: Transfer layer's alpha channel 43 * @GIMP_ADD_MASK_SELECTION: Selection 44 * @GIMP_ADD_MASK_COPY: Grayscale copy of layer 45 * @GIMP_ADD_MASK_CHANNEL: Channel 46 * @GIMP_ADD_WHITE_MASK: Deprecated alias for @GIMP_ADD_MASK_WHITE 47 * @GIMP_ADD_BLACK_MASK: Deprecated alias for @GIMP_ADD_MASK_BLACK 48 * @GIMP_ADD_ALPHA_MASK: Deprecated alias for @GIMP_ADD_MASK_ALPHA 49 * @GIMP_ADD_ALPHA_TRANSFER_MASK: Deprecated alias for 50 * @GIMP_ADD_MASK_ALPHA_TRANSFER 51 * @GIMP_ADD_SELECTION_MASK: Deprecated alias for @GIMP_ADD_MASK_SELECTION 52 * @GIMP_ADD_COPY_MASK: Deprecated alias for @GIMP_ADD_MASK_COPY 53 * @GIMP_ADD_CHANNEL_MASK: Deprecated aliaa for @GIMP_ADD_MASK_CHANNEL 54 * 55 * Modes of initialising a layer mask. 56 **/ 57 #define GIMP_TYPE_ADD_MASK_TYPE (gimp_add_mask_type_get_type ()) 58 59 GType gimp_add_mask_type_get_type (void) G_GNUC_CONST; 60 61 typedef enum 62 { 63 GIMP_ADD_MASK_WHITE, /*< desc="_White (full opacity)" >*/ 64 GIMP_ADD_MASK_BLACK, /*< desc="_Black (full transparency)" >*/ 65 GIMP_ADD_MASK_ALPHA, /*< desc="Layer's _alpha channel" >*/ 66 GIMP_ADD_MASK_ALPHA_TRANSFER, /*< desc="_Transfer layer's alpha channel" >*/ 67 GIMP_ADD_MASK_SELECTION, /*< desc="_Selection" >*/ 68 GIMP_ADD_MASK_COPY, /*< desc="_Grayscale copy of layer" >*/ 69 GIMP_ADD_MASK_CHANNEL, /*< desc="C_hannel" >*/ 70 71 #ifndef GIMP_DISABLE_DEPRECATED 72 GIMP_ADD_WHITE_MASK = GIMP_ADD_MASK_WHITE, /*< skip, pdb-skip >*/ 73 GIMP_ADD_BLACK_MASK = GIMP_ADD_MASK_BLACK, /*< skip, pdb-skip >*/ 74 GIMP_ADD_ALPHA_MASK = GIMP_ADD_MASK_ALPHA, /*< skip, pdb-skip >*/ 75 GIMP_ADD_ALPHA_TRANSFER_MASK = GIMP_ADD_MASK_ALPHA_TRANSFER, /*< skip, pdb-skip >*/ 76 GIMP_ADD_SELECTION_MASK = GIMP_ADD_MASK_SELECTION, /*< skip, pdb-skip >*/ 77 GIMP_ADD_COPY_MASK = GIMP_ADD_MASK_COPY, /*< skip, pdb-skip >*/ 78 GIMP_ADD_CHANNEL_MASK = GIMP_ADD_MASK_CHANNEL /*< skip, pdb-skip >*/ 79 #endif /* GIMP_DISABLE_DEPRECATED */ 80 } GimpAddMaskType; 81 82 83 /** 84 * GimpBlendMode: 85 * @GIMP_BLEND_FG_BG_RGB: FG to BG (RGB) 86 * @GIMP_BLEND_FG_BG_HSV: FG to BG (HSV) 87 * @GIMP_BLEND_FG_TRANSPARENT: FG to transparent 88 * @GIMP_BLEND_CUSTOM: Custom gradient 89 * @GIMP_FG_BG_RGB_MODE: Deprecated alias for @GIMP_BLEND_FG_BG_RGB 90 * @GIMP_FG_BG_HSV_MODE: Deprecated alias for @GIMP_BLEND_FG_BG_HSV 91 * @GIMP_FG_TRANSPARENT_MODE: Deprecated alias for @GIMP_BLEND_FG_TRANSPARENT 92 * @GIMP_CUSTOM_MODE: Deprecated alias for @GIMP_BLEND_CUSTOM 93 * 94 * Types of gradients. 95 **/ 96 #define GIMP_TYPE_BLEND_MODE (gimp_blend_mode_get_type ()) 97 98 GType gimp_blend_mode_get_type (void) G_GNUC_CONST; 99 100 typedef enum 101 { 102 GIMP_BLEND_FG_BG_RGB, /*< desc="FG to BG (RGB)" >*/ 103 GIMP_BLEND_FG_BG_HSV, /*< desc="FG to BG (HSV)" >*/ 104 GIMP_BLEND_FG_TRANSPARENT, /*< desc="FG to transparent" >*/ 105 GIMP_BLEND_CUSTOM, /*< desc="Custom gradient" >*/ 106 107 #ifndef GIMP_DISABLE_DEPRECATED 108 GIMP_FG_BG_RGB_MODE = GIMP_BLEND_FG_BG_RGB, /*< skip, pdb-skip >*/ 109 GIMP_FG_BG_HSV_MODE = GIMP_BLEND_FG_BG_HSV, /*< skip, pdb-skip >*/ 110 GIMP_FG_TRANSPARENT_MODE = GIMP_BLEND_FG_TRANSPARENT, /*< skip, pdb-skip >*/ 111 GIMP_CUSTOM_MODE = GIMP_BLEND_CUSTOM /*< skip, pdb-skip >*/ 112 #endif /* GIMP_DISABLE_DEPRECATED */ 113 } GimpBlendMode; 114 115 116 /** 117 * GimpBrushGeneratedShape: 118 * @GIMP_BRUSH_GENERATED_CIRCLE: Circle 119 * @GIMP_BRUSH_GENERATED_SQUARE: Square 120 * @GIMP_BRUSH_GENERATED_DIAMOND: Diamond 121 * 122 * Shapes of generated brushes. 123 **/ 124 #define GIMP_TYPE_BRUSH_GENERATED_SHAPE (gimp_brush_generated_shape_get_type ()) 125 126 GType gimp_brush_generated_shape_get_type (void) G_GNUC_CONST; 127 128 typedef enum 129 { 130 GIMP_BRUSH_GENERATED_CIRCLE, /*< desc="Circle" >*/ 131 GIMP_BRUSH_GENERATED_SQUARE, /*< desc="Square" >*/ 132 GIMP_BRUSH_GENERATED_DIAMOND /*< desc="Diamond" >*/ 133 } GimpBrushGeneratedShape; 134 135 136 /** 137 * GimpBucketFillMode: 138 * @GIMP_BUCKET_FILL_FG: FG color fill 139 * @GIMP_BUCKET_FILL_BG: BG color fill 140 * @GIMP_BUCKET_FILL_PATTERN: Pattern fill 141 * @GIMP_FG_BUCKET_FILL: Deprecated alias for @GIMP_BUCKET_FILL_FG 142 * @GIMP_BG_BUCKET_FILL: Deprecated alias for @GIMP_BUCKET_FILL_BG 143 * @GIMP_PATTERN_BUCKET_FILL: Deprecated alias for @GIMP_BUCKET_FILL_PATTERN 144 * 145 * Bucket fill modes. 146 */ 147 #define GIMP_TYPE_BUCKET_FILL_MODE (gimp_bucket_fill_mode_get_type ()) 148 149 GType gimp_bucket_fill_mode_get_type (void) G_GNUC_CONST; 150 151 typedef enum 152 { 153 GIMP_BUCKET_FILL_FG, /*< desc="FG color fill" >*/ 154 GIMP_BUCKET_FILL_BG, /*< desc="BG color fill" >*/ 155 GIMP_BUCKET_FILL_PATTERN, /*< desc="Pattern fill" >*/ 156 157 #ifndef GIMP_DISABLE_DEPRECATED 158 GIMP_FG_BUCKET_FILL = GIMP_BUCKET_FILL_FG, /*< skip, pdb-skip >*/ 159 GIMP_BG_BUCKET_FILL = GIMP_BUCKET_FILL_BG, /*< skip, pdb-skip >*/ 160 GIMP_PATTERN_BUCKET_FILL = GIMP_BUCKET_FILL_PATTERN /*< skip, pdb-skip >*/ 161 #endif /* GIMP_DISABLE_DEPRECATED */ 162 } GimpBucketFillMode; 163 164 165 /** 166 * GimpCapStyle: 167 * @GIMP_CAP_BUTT: Butt 168 * @GIMP_CAP_ROUND: Round 169 * @GIMP_CAP_SQUARE: Square 170 * 171 * Style of line endings. 172 **/ 173 #define GIMP_TYPE_CAP_STYLE (gimp_cap_style_get_type ()) 174 175 GType gimp_cap_style_get_type (void) G_GNUC_CONST; 176 177 typedef enum 178 { 179 GIMP_CAP_BUTT, /*< desc="Butt" >*/ 180 GIMP_CAP_ROUND, /*< desc="Round" >*/ 181 GIMP_CAP_SQUARE /*< desc="Square" >*/ 182 } GimpCapStyle; 183 184 185 /** 186 * GimpChannelOps: 187 * @GIMP_CHANNEL_OP_ADD: Add to the current selection 188 * @GIMP_CHANNEL_OP_SUBTRACT: Subtract from the current selection 189 * @GIMP_CHANNEL_OP_REPLACE: Replace the current selection 190 * @GIMP_CHANNEL_OP_INTERSECT: Intersect with the current selection 191 * 192 * Operations to combine channels and selections. 193 **/ 194 #define GIMP_TYPE_CHANNEL_OPS (gimp_channel_ops_get_type ()) 195 196 GType gimp_channel_ops_get_type (void) G_GNUC_CONST; 197 198 typedef enum 199 { 200 GIMP_CHANNEL_OP_ADD, /*< desc="Add to the current selection" >*/ 201 GIMP_CHANNEL_OP_SUBTRACT, /*< desc="Subtract from the current selection" >*/ 202 GIMP_CHANNEL_OP_REPLACE, /*< desc="Replace the current selection" >*/ 203 GIMP_CHANNEL_OP_INTERSECT /*< desc="Intersect with the current selection" >*/ 204 } GimpChannelOps; 205 206 207 /** 208 * GimpChannelType: 209 * @GIMP_CHANNEL_RED: Red 210 * @GIMP_CHANNEL_GREEN: Green 211 * @GIMP_CHANNEL_BLUE: Blue 212 * @GIMP_CHANNEL_GRAY: Gray 213 * @GIMP_CHANNEL_INDEXED: Indexed 214 * @GIMP_CHANNEL_ALPHA: Alpha 215 * @GIMP_RED_CHANNEL: Deprecated alias for @GIMP_CHANNEL_RED 216 * @GIMP_GREEN_CHANNEL: Deprecated alias for @GIMP_CHANNEL_GREEN 217 * @GIMP_BLUE_CHANNEL: Deprecated alias for @GIMP_CHANNEL_BLUE 218 * @GIMP_GRAY_CHANNEL: Deprecated alias for @GIMP_CHANNEL_GRAY 219 * @GIMP_INDEXED_CHANNEL: Deprecated alias for @GIMP_CHANNEL_INDEXED 220 * @GIMP_ALPHA_CHANNEL: Deprecated alias for @GIMP_CHANNEL_ALPHA 221 * 222 * Channels (as in color components). 223 **/ 224 #define GIMP_TYPE_CHANNEL_TYPE (gimp_channel_type_get_type ()) 225 226 GType gimp_channel_type_get_type (void) G_GNUC_CONST; 227 228 typedef enum 229 { 230 GIMP_CHANNEL_RED, /*< desc="Red" >*/ 231 GIMP_CHANNEL_GREEN, /*< desc="Green" >*/ 232 GIMP_CHANNEL_BLUE, /*< desc="Blue" >*/ 233 GIMP_CHANNEL_GRAY, /*< desc="Gray" >*/ 234 GIMP_CHANNEL_INDEXED, /*< desc="Indexed" >*/ 235 GIMP_CHANNEL_ALPHA, /*< desc="Alpha" >*/ 236 237 #ifndef GIMP_DISABLE_DEPRECATED 238 GIMP_RED_CHANNEL = GIMP_CHANNEL_RED, /*< skip, pdb-skip >*/ 239 GIMP_GREEN_CHANNEL = GIMP_CHANNEL_GREEN, /*< skip, pdb-skip >*/ 240 GIMP_BLUE_CHANNEL = GIMP_CHANNEL_BLUE, /*< skip, pdb-skip >*/ 241 GIMP_GRAY_CHANNEL = GIMP_CHANNEL_GRAY, /*< skip, pdb-skip >*/ 242 GIMP_INDEXED_CHANNEL = GIMP_CHANNEL_INDEXED, /*< skip, pdb-skip >*/ 243 GIMP_ALPHA_CHANNEL = GIMP_CHANNEL_ALPHA /*< skip, pdb-skip >*/ 244 #endif /* GIMP_DISABLE_DEPRECATED */ 245 } GimpChannelType; 246 247 248 /** 249 * GimpCheckSize: 250 * @GIMP_CHECK_SIZE_SMALL_CHECKS: Small 251 * @GIMP_CHECK_SIZE_MEDIUM_CHECKS: Medium 252 * @GIMP_CHECK_SIZE_LARGE_CHECKS: Large 253 * 254 * Size of the checkerboard indicating transparency. 255 **/ 256 #define GIMP_TYPE_CHECK_SIZE (gimp_check_size_get_type ()) 257 258 GType gimp_check_size_get_type (void) G_GNUC_CONST; 259 260 typedef enum /*< pdb-skip >*/ 261 { 262 GIMP_CHECK_SIZE_SMALL_CHECKS = 0, /*< desc="Small" >*/ 263 GIMP_CHECK_SIZE_MEDIUM_CHECKS = 1, /*< desc="Medium" >*/ 264 GIMP_CHECK_SIZE_LARGE_CHECKS = 2 /*< desc="Large" >*/ 265 } GimpCheckSize; 266 267 268 /** 269 * GimpCheckType: 270 * @GIMP_CHECK_TYPE_LIGHT_CHECKS: Light checks 271 * @GIMP_CHECK_TYPE_GRAY_CHECKS: Mid-tone checks 272 * @GIMP_CHECK_TYPE_DARK_CHECKS: Dark checks 273 * @GIMP_CHECK_TYPE_WHITE_ONLY: White only 274 * @GIMP_CHECK_TYPE_GRAY_ONLY: Gray only 275 * @GIMP_CHECK_TYPE_BLACK_ONLY: Black only 276 * 277 * Color/Brightness of the checkerboard indicating transparency. 278 **/ 279 #define GIMP_TYPE_CHECK_TYPE (gimp_check_type_get_type ()) 280 281 GType gimp_check_type_get_type (void) G_GNUC_CONST; 282 283 typedef enum /*< pdb-skip >*/ 284 { 285 GIMP_CHECK_TYPE_LIGHT_CHECKS = 0, /*< desc="Light checks" >*/ 286 GIMP_CHECK_TYPE_GRAY_CHECKS = 1, /*< desc="Mid-tone checks" >*/ 287 GIMP_CHECK_TYPE_DARK_CHECKS = 2, /*< desc="Dark checks" >*/ 288 GIMP_CHECK_TYPE_WHITE_ONLY = 3, /*< desc="White only" >*/ 289 GIMP_CHECK_TYPE_GRAY_ONLY = 4, /*< desc="Gray only" >*/ 290 GIMP_CHECK_TYPE_BLACK_ONLY = 5 /*< desc="Black only" >*/ 291 } GimpCheckType; 292 293 294 /** 295 * GimpCloneType: 296 * @GIMP_CLONE_IMAGE: Clone from an image/drawable source 297 * @GIMP_CLONE_PATTERN: Clone from a pattern source 298 * @GIMP_IMAGE_CLONE: Deprecated alias for @GIMP_CLONE_IMAGE 299 * @GIMP_PATTERN_CLONE: Deprecated alias for @GIMP_CLONE_PATTERN 300 * 301 * Clone sources. 302 **/ 303 #define GIMP_TYPE_CLONE_TYPE (gimp_clone_type_get_type ()) 304 305 GType gimp_clone_type_get_type (void) G_GNUC_CONST; 306 307 typedef enum 308 { 309 GIMP_CLONE_IMAGE, /*< desc="Image" >*/ 310 GIMP_CLONE_PATTERN, /*< desc="Pattern" >*/ 311 312 #ifndef GIMP_DISABLE_DEPRECATED 313 GIMP_IMAGE_CLONE = GIMP_CLONE_IMAGE, /*< skip, pdb-skip >*/ 314 GIMP_PATTERN_CLONE = GIMP_CLONE_PATTERN /*< skip, pdb-skip >*/ 315 #endif /* GIMP_DISABLE_DEPRECATED */ 316 } GimpCloneType; 317 318 319 /** 320 * GimpColorTag: 321 * @GIMP_COLOR_TAG_NONE: None 322 * @GIMP_COLOR_TAG_BLUE: Blue 323 * @GIMP_COLOR_TAG_GREEN: Green 324 * @GIMP_COLOR_TAG_YELLOW: Yellow 325 * @GIMP_COLOR_TAG_ORANGE: Orange 326 * @GIMP_COLOR_TAG_BROWN: Brown 327 * @GIMP_COLOR_TAG_RED: Red 328 * @GIMP_COLOR_TAG_VIOLET: Violet 329 * @GIMP_COLOR_TAG_GRAY: Gray 330 * 331 * Possible tag colors. 332 * 333 * Since: 2.10 334 **/ 335 #define GIMP_TYPE_COLOR_TAG (gimp_color_tag_get_type ()) 336 337 GType gimp_color_tag_get_type (void) G_GNUC_CONST; 338 339 typedef enum 340 { 341 GIMP_COLOR_TAG_NONE, /*< desc="None" >*/ 342 GIMP_COLOR_TAG_BLUE, /*< desc="Blue" >*/ 343 GIMP_COLOR_TAG_GREEN, /*< desc="Green" >*/ 344 GIMP_COLOR_TAG_YELLOW, /*< desc="Yellow" >*/ 345 GIMP_COLOR_TAG_ORANGE, /*< desc="Orange" >*/ 346 GIMP_COLOR_TAG_BROWN, /*< desc="Brown" >*/ 347 GIMP_COLOR_TAG_RED, /*< desc="Red" >*/ 348 GIMP_COLOR_TAG_VIOLET, /*< desc="Violet" >*/ 349 GIMP_COLOR_TAG_GRAY /*< desc="Gray" >*/ 350 } GimpColorTag; 351 352 353 /** 354 * GimpComponentType: 355 * @GIMP_COMPONENT_TYPE_U8: 8-bit integer 356 * @GIMP_COMPONENT_TYPE_U16: 16-bit integer 357 * @GIMP_COMPONENT_TYPE_U32: 32-bit integer 358 * @GIMP_COMPONENT_TYPE_HALF: 16-bit floating point 359 * @GIMP_COMPONENT_TYPE_FLOAT: 32-bit floating point 360 * @GIMP_COMPONENT_TYPE_DOUBLE: 64-bit floating point 361 * 362 * Encoding types of image components. 363 * 364 * Since: 2.10 365 **/ 366 #define GIMP_TYPE_COMPONENT_TYPE (gimp_component_type_get_type ()) 367 368 GType gimp_component_type_get_type (void) G_GNUC_CONST; 369 370 typedef enum 371 { 372 GIMP_COMPONENT_TYPE_U8 = 100, /*< desc="8-bit integer" >*/ 373 GIMP_COMPONENT_TYPE_U16 = 200, /*< desc="16-bit integer" >*/ 374 GIMP_COMPONENT_TYPE_U32 = 300, /*< desc="32-bit integer" >*/ 375 GIMP_COMPONENT_TYPE_HALF = 500, /*< desc="16-bit floating point" >*/ 376 GIMP_COMPONENT_TYPE_FLOAT = 600, /*< desc="32-bit floating point" >*/ 377 GIMP_COMPONENT_TYPE_DOUBLE = 700 /*< desc="64-bit floating point" >*/ 378 } GimpComponentType; 379 380 381 /** 382 * GimpConvertPaletteType: 383 * @GIMP_CONVERT_PALETTE_GENERATE: Generate optimum palette 384 * @GIMP_CONVERT_PALETTE_REUSE: Don't use this one 385 * @GIMP_CONVERT_PALETTE_WEB: Use web-optimized palette 386 * @GIMP_CONVERT_PALETTE_MONO: Use black and white (1-bit) palette 387 * @GIMP_CONVERT_PALETTE_CUSTOM: Use custom palette 388 * @GIMP_MAKE_PALETTE: Deprecated alias for 389 * @GIMP_CONVERT_PALETTE_GENERATE 390 * @GIMP_REUSE_PALETTE: Deprecated alias for 391 * @GIMP_CONVERT_PALETTE_REUSE 392 * @GIMP_WEB_PALETTE: Deprecated alias for 393 * @GIMP_CONVERT_PALETTE_WEB 394 * @GIMP_MONO_PALETTE: Deprecated alias for 395 @GIMP_CONVERT_PALETTE_MONO 396 * @GIMP_CUSTOM_PALETTE: Deprecated alias for 397 * @GIMP_CONVERT_PALETTE_CUSTOM 398 * 399 * Types of palettes for indexed conversion. 400 **/ 401 #define GIMP_TYPE_CONVERT_PALETTE_TYPE (gimp_convert_palette_type_get_type ()) 402 403 GType gimp_convert_palette_type_get_type (void) G_GNUC_CONST; 404 405 typedef enum 406 { 407 GIMP_CONVERT_PALETTE_GENERATE, /*< desc="Generate optimum palette" >*/ 408 GIMP_CONVERT_PALETTE_REUSE, /*< skip >*/ 409 GIMP_CONVERT_PALETTE_WEB, /*< desc="Use web-optimized palette" >*/ 410 GIMP_CONVERT_PALETTE_MONO, /*< desc="Use black and white (1-bit) palette" >*/ 411 GIMP_CONVERT_PALETTE_CUSTOM, /*< desc="Use custom palette" >*/ 412 413 #ifndef GIMP_DISABLE_DEPRECATED 414 GIMP_MAKE_PALETTE = GIMP_CONVERT_PALETTE_GENERATE, /*< skip, pdb-skip >*/ 415 GIMP_REUSE_PALETTE = GIMP_CONVERT_PALETTE_REUSE, /*< skip, pdb-skip >*/ 416 GIMP_WEB_PALETTE = GIMP_CONVERT_PALETTE_WEB, /*< skip, pdb-skip >*/ 417 GIMP_MONO_PALETTE = GIMP_CONVERT_PALETTE_MONO, /*< skip, pdb-skip >*/ 418 GIMP_CUSTOM_PALETTE = GIMP_CONVERT_PALETTE_CUSTOM /*< skip, pdb-skip >*/ 419 #endif /* GIMP_DISABLE_DEPRECATED */ 420 } GimpConvertPaletteType; 421 422 423 /** 424 * GimpConvolveType: 425 * @GIMP_CONVOLVE_BLUR: Blur 426 * @GIMP_CONVOLVE_SHARPEN: Sharpen 427 * @GIMP_BLUR_CONVOLVE: Deprecated alias for @GIMP_CONVOLVE_BLUR 428 * @GIMP_SHARPEN_CONVOLVE: Deprecated alias for @GIMP_CONVOLVE_SHARPEN 429 * 430 * Types of convolutions. 431 **/ 432 #define GIMP_TYPE_CONVOLVE_TYPE (gimp_convolve_type_get_type ()) 433 434 GType gimp_convolve_type_get_type (void) G_GNUC_CONST; 435 436 typedef enum 437 { 438 GIMP_CONVOLVE_BLUR, /*< desc="Blur" >*/ 439 GIMP_CONVOLVE_SHARPEN, /*< desc="Sharpen" >*/ 440 441 #ifndef GIMP_DISABLE_DEPRECATED 442 GIMP_BLUR_CONVOLVE = GIMP_CONVOLVE_BLUR, /*< skip, pdb-skip >*/ 443 GIMP_SHARPEN_CONVOLVE = GIMP_CONVOLVE_SHARPEN /*< skip, pdb-skip >*/ 444 #endif /* GIMP_DISABLE_DEPRECATED */ 445 } GimpConvolveType; 446 447 448 /** 449 * GimpDesaturateMode: 450 * @GIMP_DESATURATE_LIGHTNESS: Lightness (HSL) 451 * @GIMP_DESATURATE_LUMA: Luma 452 * @GIMP_DESATURATE_AVERAGE: Average (HSI Intensity) 453 * @GIMP_DESATURATE_LUMINANCE: Luminance 454 * @GIMP_DESATURATE_VALUE: Value (HSV) 455 * @GIMP_DESATURATE_LUMINOSITY: Deprecated alias for @GIMP_DESATURATE_LUMA 456 * 457 * Grayscale conversion methods. 458 **/ 459 #define GIMP_TYPE_DESATURATE_MODE (gimp_desaturate_mode_get_type ()) 460 461 GType gimp_desaturate_mode_get_type (void) G_GNUC_CONST; 462 463 typedef enum 464 { 465 GIMP_DESATURATE_LIGHTNESS, /*< desc="Lightness (HSL)" >*/ 466 GIMP_DESATURATE_LUMA, /*< desc="Luma" >*/ 467 GIMP_DESATURATE_AVERAGE, /*< desc="Average (HSI Intensity)" >*/ 468 GIMP_DESATURATE_LUMINANCE, /*< desc="Luminance" >*/ 469 GIMP_DESATURATE_VALUE, /*< desc="Value (HSV)" >*/ 470 471 #ifndef GIMP_DISABLE_DEPRECATED 472 GIMP_DESATURATE_LUMINOSITY = GIMP_DESATURATE_LUMA /*< skip, pdb-skip >*/ 473 #endif /* GIMP_DISABLE_DEPRECATED */ 474 } GimpDesaturateMode; 475 476 477 /** 478 * GimpDodgeBurnType: 479 * @GIMP_DODGE_BURN_TYPE_DODGE: Dodge 480 * @GIMP_DODGE_BURN_TYPE_BURN: Burn 481 * @GIMP_DODGE: Deprecated alias for @GIMP_DODGE_BURN_TYPE_DODGE 482 * @GIMP_BURN: Deprecated alias for @GIMP_DODGE_BURN_TYPE_BURN 483 * 484 * Methods for the dodge/burn operation. 485 **/ 486 #define GIMP_TYPE_DODGE_BURN_TYPE (gimp_dodge_burn_type_get_type ()) 487 488 GType gimp_dodge_burn_type_get_type (void) G_GNUC_CONST; 489 490 typedef enum 491 { 492 GIMP_DODGE_BURN_TYPE_DODGE, /*< desc="Dodge" >*/ 493 GIMP_DODGE_BURN_TYPE_BURN, /*< desc="Burn" >*/ 494 495 #ifndef GIMP_DISABLE_DEPRECATED 496 GIMP_DODGE = GIMP_DODGE_BURN_TYPE_DODGE, /*< skip, pdb-skip >*/ 497 GIMP_BURN = GIMP_DODGE_BURN_TYPE_BURN /*< skip, pdb-skip >*/ 498 #endif /* GIMP_DISABLE_DEPRECATED */ 499 } GimpDodgeBurnType; 500 501 502 /** 503 * GimpFillType: 504 * @GIMP_FILL_FOREGROUND: Foreground color 505 * @GIMP_FILL_BACKGROUND: Background color 506 * @GIMP_FILL_WHITE: White 507 * @GIMP_FILL_TRANSPARENT: Transparency 508 * @GIMP_FILL_PATTERN: Pattern 509 * @GIMP_FOREGROUND_FILL: Deprecated alias for @GIMP_FILL_FOREGROUND 510 * @GIMP_BACKGROUND_FILL: Deprecated alias for @GIMP_FILL_BACKGROUND 511 * @GIMP_WHITE_FILL: Deprecated alias for @GIMP_FILL_WHITE 512 * @GIMP_TRANSPARENT_FILL: Deprecated alias for @GIMP_FILL_TRANSPARENT 513 * @GIMP_PATTERN_FILL: Deprecated alias for @GIMP_FILL_PATTERN 514 * 515 * Types of filling. 516 **/ 517 #define GIMP_TYPE_FILL_TYPE (gimp_fill_type_get_type ()) 518 519 GType gimp_fill_type_get_type (void) G_GNUC_CONST; 520 521 typedef enum 522 { 523 GIMP_FILL_FOREGROUND, /*< desc="Foreground color" >*/ 524 GIMP_FILL_BACKGROUND, /*< desc="Background color" >*/ 525 GIMP_FILL_WHITE, /*< desc="White" >*/ 526 GIMP_FILL_TRANSPARENT, /*< desc="Transparency" >*/ 527 GIMP_FILL_PATTERN, /*< desc="Pattern" >*/ 528 529 #ifndef GIMP_DISABLE_DEPRECATED 530 GIMP_FOREGROUND_FILL = GIMP_FILL_FOREGROUND, /*< skip, pdb-skip >*/ 531 GIMP_BACKGROUND_FILL = GIMP_FILL_BACKGROUND, /*< skip, pdb-skip >*/ 532 GIMP_WHITE_FILL = GIMP_FILL_WHITE, /*< skip, pdb-skip >*/ 533 GIMP_TRANSPARENT_FILL = GIMP_FILL_TRANSPARENT, /*< skip, pdb-skip >*/ 534 GIMP_PATTERN_FILL = GIMP_FILL_PATTERN /*< skip, pdb-skip >*/ 535 #endif /* GIMP_DISABLE_DEPRECATED */ 536 } GimpFillType; 537 538 539 /** 540 * GimpForegroundExtractMode: 541 * @GIMP_FOREGROUND_EXTRACT_SIOX: Siox 542 * @GIMP_FOREGROUND_EXTRACT_MATTING: Matting (Since 2.10) 543 * 544 * Foreground extraxt engines. 545 **/ 546 #define GIMP_TYPE_FOREGROUND_EXTRACT_MODE (gimp_foreground_extract_mode_get_type ()) 547 548 GType gimp_foreground_extract_mode_get_type (void) G_GNUC_CONST; 549 550 typedef enum 551 { 552 GIMP_FOREGROUND_EXTRACT_SIOX, 553 GIMP_FOREGROUND_EXTRACT_MATTING 554 } GimpForegroundExtractMode; 555 556 557 /** 558 * GimpGradientBlendColorSpace: 559 * @GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL: Perceptual RGB 560 * @GIMP_GRADIENT_BLEND_RGB_LINEAR: Linear RGB 561 * @GIMP_GRADIENT_BLEND_CIE_LAB: CIE Lab 562 * 563 * Color space for blending gradients. 564 * 565 * Since: 2.10 566 */ 567 #define GIMP_TYPE_GRADIENT_BLEND_COLOR_SPACE (gimp_gradient_blend_color_space_get_type ()) 568 569 GType gimp_gradient_blend_color_space_get_type (void) G_GNUC_CONST; 570 571 typedef enum 572 { 573 GIMP_GRADIENT_BLEND_RGB_PERCEPTUAL, /*< desc="Perceptual RGB", nick=rgb-perceptual >*/ 574 GIMP_GRADIENT_BLEND_RGB_LINEAR, /*< desc="Linear RGB", nick=rgb-linear >*/ 575 GIMP_GRADIENT_BLEND_CIE_LAB /*< desc="CIE Lab", nick=cie-lab >*/ 576 } GimpGradientBlendColorSpace; 577 578 579 /** 580 * GimpGradientSegmentColor: 581 * @GIMP_GRADIENT_SEGMENT_RGB: RGB 582 * @GIMP_GRADIENT_SEGMENT_HSV_CCW: HSV (counter-clockwise hue) 583 * @GIMP_GRADIENT_SEGMENT_HSV_CW: HSV (clockwise hue) 584 * 585 * Coloring types for gradient segments. 586 **/ 587 #define GIMP_TYPE_GRADIENT_SEGMENT_COLOR (gimp_gradient_segment_color_get_type ()) 588 589 GType gimp_gradient_segment_color_get_type (void) G_GNUC_CONST; 590 591 typedef enum 592 { 593 GIMP_GRADIENT_SEGMENT_RGB, /*< desc="RGB" >*/ 594 GIMP_GRADIENT_SEGMENT_HSV_CCW, /*< desc="HSV (counter-clockwise hue)", abbrev="HSV (ccw)" >*/ 595 GIMP_GRADIENT_SEGMENT_HSV_CW /*< desc="HSV (clockwise hue)", abbrev="HSV (cw)" >*/ 596 } GimpGradientSegmentColor; 597 598 599 /** 600 * GimpGradientSegmentType: 601 * @GIMP_GRADIENT_SEGMENT_LINEAR: Linear 602 * @GIMP_GRADIENT_SEGMENT_CURVED: Curved 603 * @GIMP_GRADIENT_SEGMENT_SINE: Sinusoidal 604 * @GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING: Spherical (increasing) 605 * @GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING: Spherical (decreasing) 606 * @GIMP_GRADIENT_SEGMENT_STEP: Step 607 * 608 * Transition functions for gradient segments. 609 **/ 610 #define GIMP_TYPE_GRADIENT_SEGMENT_TYPE (gimp_gradient_segment_type_get_type ()) 611 612 GType gimp_gradient_segment_type_get_type (void) G_GNUC_CONST; 613 614 typedef enum 615 { 616 GIMP_GRADIENT_SEGMENT_LINEAR, /*< desc="Linear" >*/ 617 GIMP_GRADIENT_SEGMENT_CURVED, /*< desc="Curved" >*/ 618 GIMP_GRADIENT_SEGMENT_SINE, /*< desc="Sinusoidal" >*/ 619 GIMP_GRADIENT_SEGMENT_SPHERE_INCREASING, /*< desc="Spherical (increasing)", abbrev="Spherical (inc)" >*/ 620 GIMP_GRADIENT_SEGMENT_SPHERE_DECREASING, /*< desc="Spherical (decreasing)", abbrev="Spherical (dec)" >*/ 621 GIMP_GRADIENT_SEGMENT_STEP /*< desc="Step" >*/ 622 } GimpGradientSegmentType; 623 624 625 /** 626 * GimpGradientType: 627 * @GIMP_GRADIENT_LINEAR: Linear 628 * @GIMP_GRADIENT_BILINEAR: Bi-linear 629 * @GIMP_GRADIENT_RADIAL: Radial 630 * @GIMP_GRADIENT_SQUARE: Square 631 * @GIMP_GRADIENT_CONICAL_SYMMETRIC: Conical (symmetric) 632 * @GIMP_GRADIENT_CONICAL_ASYMMETRIC: Conical (asymmetric) 633 * @GIMP_GRADIENT_SHAPEBURST_ANGULAR: Shaped (angular) 634 * @GIMP_GRADIENT_SHAPEBURST_SPHERICAL: Shaped (spherical) 635 * @GIMP_GRADIENT_SHAPEBURST_DIMPLED: Shaped (dimpled) 636 * @GIMP_GRADIENT_SPIRAL_CLOCKWISE: Spiral (clockwise) 637 * @GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE: Spiral (counter-clockwise) 638 * 639 * Gradient shapes. 640 **/ 641 #define GIMP_TYPE_GRADIENT_TYPE (gimp_gradient_type_get_type ()) 642 643 GType gimp_gradient_type_get_type (void) G_GNUC_CONST; 644 645 typedef enum 646 { 647 GIMP_GRADIENT_LINEAR, /*< desc="Linear" >*/ 648 GIMP_GRADIENT_BILINEAR, /*< desc="Bi-linear" >*/ 649 GIMP_GRADIENT_RADIAL, /*< desc="Radial" >*/ 650 GIMP_GRADIENT_SQUARE, /*< desc="Square" >*/ 651 GIMP_GRADIENT_CONICAL_SYMMETRIC, /*< desc="Conical (symmetric)", abbrev="Conical (sym)" >*/ 652 GIMP_GRADIENT_CONICAL_ASYMMETRIC, /*< desc="Conical (asymmetric)", abbrev="Conical (asym)" >*/ 653 GIMP_GRADIENT_SHAPEBURST_ANGULAR, /*< desc="Shaped (angular)" >*/ 654 GIMP_GRADIENT_SHAPEBURST_SPHERICAL, /*< desc="Shaped (spherical)" >*/ 655 GIMP_GRADIENT_SHAPEBURST_DIMPLED, /*< desc="Shaped (dimpled)" >*/ 656 GIMP_GRADIENT_SPIRAL_CLOCKWISE, /*< desc="Spiral (clockwise)", abbrev="Spiral (cw)" >*/ 657 GIMP_GRADIENT_SPIRAL_ANTICLOCKWISE /*< desc="Spiral (counter-clockwise)", abbrev="Spiral (ccw)" >*/ 658 } GimpGradientType; 659 660 661 /** 662 * GimpGridStyle: 663 * @GIMP_GRID_DOTS: Intersections (dots) 664 * @GIMP_GRID_INTERSECTIONS: Intersections (crosshairs) 665 * @GIMP_GRID_ON_OFF_DASH: Dashed 666 * @GIMP_GRID_DOUBLE_DASH: Double dashed 667 * @GIMP_GRID_SOLID: Solid 668 * 669 * Rendering types for the display grid. 670 **/ 671 #define GIMP_TYPE_GRID_STYLE (gimp_grid_style_get_type ()) 672 673 GType gimp_grid_style_get_type (void) G_GNUC_CONST; 674 675 typedef enum 676 { 677 GIMP_GRID_DOTS, /*< desc="Intersections (dots)" >*/ 678 GIMP_GRID_INTERSECTIONS, /*< desc="Intersections (crosshairs)" >*/ 679 GIMP_GRID_ON_OFF_DASH, /*< desc="Dashed" >*/ 680 GIMP_GRID_DOUBLE_DASH, /*< desc="Double dashed" >*/ 681 GIMP_GRID_SOLID /*< desc="Solid" >*/ 682 } GimpGridStyle; 683 684 685 /** 686 * GimpHueRange: 687 * @GIMP_HUE_RANGE_ALL: All hues 688 * @GIMP_HUE_RANGE_RED: Red hues 689 * @GIMP_HUE_RANGE_YELLOW: Yellow hues 690 * @GIMP_HUE_RANGE_GREEN: Green hues 691 * @GIMP_HUE_RANGE_CYAN: Cyan hues 692 * @GIMP_HUE_RANGE_BLUE: Blue hues 693 * @GIMP_HUE_RANGE_MAGENTA: Magenta hues 694 * @GIMP_ALL_HUES: Deprecated alias for @GIMP_HUE_RANGE_ALL 695 * @GIMP_RED_HUES: Deprecated alias for @GIMP_HUE_RANGE_RED 696 * @GIMP_YELLOW_HUES: Deprecated alias for @GIMP_HUE_RANGE_YELLOW 697 * @GIMP_GREEN_HUES: Deprecated alias for @GIMP_HUE_RANGE_GREEN 698 * @GIMP_CYAN_HUES: Deprecated alias for @GIMP_HUE_RANGE_CYAN 699 * @GIMP_BLUE_HUES: Deprecated alias for @GIMP_HUE_RANGE_BLUE 700 * @GIMP_MAGENTA_HUES: Deprecated alias for @GIMP_HUE_RANGE_MAGENTA 701 * 702 * Hue ranges. 703 **/ 704 #define GIMP_TYPE_HUE_RANGE (gimp_hue_range_get_type ()) 705 706 GType gimp_hue_range_get_type (void) G_GNUC_CONST; 707 708 typedef enum 709 { 710 GIMP_HUE_RANGE_ALL, 711 GIMP_HUE_RANGE_RED, 712 GIMP_HUE_RANGE_YELLOW, 713 GIMP_HUE_RANGE_GREEN, 714 GIMP_HUE_RANGE_CYAN, 715 GIMP_HUE_RANGE_BLUE, 716 GIMP_HUE_RANGE_MAGENTA, 717 718 #ifndef GIMP_DISABLE_DEPRECATED 719 GIMP_ALL_HUES = GIMP_HUE_RANGE_ALL, /*< skip, pdb-skip >*/ 720 GIMP_RED_HUES = GIMP_HUE_RANGE_RED, /*< skip, pdb-skip >*/ 721 GIMP_YELLOW_HUES = GIMP_HUE_RANGE_YELLOW, /*< skip, pdb-skip >*/ 722 GIMP_GREEN_HUES = GIMP_HUE_RANGE_GREEN, /*< skip, pdb-skip >*/ 723 GIMP_CYAN_HUES = GIMP_HUE_RANGE_CYAN, /*< skip, pdb-skip >*/ 724 GIMP_BLUE_HUES = GIMP_HUE_RANGE_BLUE, /*< skip, pdb-skip >*/ 725 GIMP_MAGENTA_HUES = GIMP_HUE_RANGE_MAGENTA /*< skip, pdb-skip >*/ 726 #endif /* GIMP_DISABLE_DEPRECATED */ 727 } GimpHueRange; 728 729 730 /** 731 * GimpIconType: 732 * @GIMP_ICON_TYPE_ICON_NAME: Icon name 733 * @GIMP_ICON_TYPE_INLINE_PIXBUF: Inline pixbuf 734 * @GIMP_ICON_TYPE_IMAGE_FILE: Image file 735 * @GIMP_ICON_TYPE_STOCK_ID: Deprecated alias for 736 * @GIMP_ICON_TYPE_ICON_NAME, old stock IDs 737 * are interpreted as icon names 738 * 739 * Icon types for plug-ins to register. 740 **/ 741 #define GIMP_TYPE_ICON_TYPE (gimp_icon_type_get_type ()) 742 743 GType gimp_icon_type_get_type (void) G_GNUC_CONST; 744 745 typedef enum 746 { 747 GIMP_ICON_TYPE_ICON_NAME, /*< desc="Icon name" >*/ 748 GIMP_ICON_TYPE_INLINE_PIXBUF, /*< desc="Inline pixbuf" >*/ 749 GIMP_ICON_TYPE_IMAGE_FILE, /*< desc="Image file" >*/ 750 751 #ifndef GIMP_DISABLE_DEPRECATED 752 GIMP_ICON_TYPE_STOCK_ID = GIMP_ICON_TYPE_ICON_NAME /*< skip, pdb-skip >*/ 753 #endif /* GIMP_DISABLE_DEPRECATED */ 754 } GimpIconType; 755 756 757 /** 758 * GimpImageBaseType: 759 * @GIMP_RGB: RGB color 760 * @GIMP_GRAY: Grayscale 761 * @GIMP_INDEXED: Indexed color 762 * 763 * Image color models. 764 **/ 765 #define GIMP_TYPE_IMAGE_BASE_TYPE (gimp_image_base_type_get_type ()) 766 767 GType gimp_image_base_type_get_type (void) G_GNUC_CONST; 768 769 typedef enum 770 { 771 GIMP_RGB, /*< desc="RGB color" >*/ 772 GIMP_GRAY, /*< desc="Grayscale" >*/ 773 GIMP_INDEXED /*< desc="Indexed color" >*/ 774 } GimpImageBaseType; 775 776 777 /** 778 * GimpImageType: 779 * @GIMP_RGB_IMAGE: RGB 780 * @GIMP_RGBA_IMAGE: RGB-alpha 781 * @GIMP_GRAY_IMAGE: Grayscale 782 * @GIMP_GRAYA_IMAGE: Grayscale-alpha 783 * @GIMP_INDEXED_IMAGE: Indexed 784 * @GIMP_INDEXEDA_IMAGE: Indexed-alpha 785 * 786 * Possible drawable types. 787 **/ 788 #define GIMP_TYPE_IMAGE_TYPE (gimp_image_type_get_type ()) 789 790 GType gimp_image_type_get_type (void) G_GNUC_CONST; 791 792 typedef enum 793 { 794 GIMP_RGB_IMAGE, /*< desc="RGB" >*/ 795 GIMP_RGBA_IMAGE, /*< desc="RGB-alpha" >*/ 796 GIMP_GRAY_IMAGE, /*< desc="Grayscale" >*/ 797 GIMP_GRAYA_IMAGE, /*< desc="Grayscale-alpha" >*/ 798 GIMP_INDEXED_IMAGE, /*< desc="Indexed" >*/ 799 GIMP_INDEXEDA_IMAGE /*< desc="Indexed-alpha" >*/ 800 } GimpImageType; 801 802 803 /** 804 * GimpInkBlobType: 805 * @GIMP_INK_BLOB_TYPE_CIRCLE: Circle 806 * @GIMP_INK_BLOB_TYPE_SQUARE: Square 807 * @GIMP_INK_BLOB_TYPE_DIAMOND: Diamond 808 * 809 * Ink tool tips. 810 **/ 811 #define GIMP_TYPE_INK_BLOB_TYPE (gimp_ink_blob_type_get_type ()) 812 813 GType gimp_ink_blob_type_get_type (void) G_GNUC_CONST; 814 815 typedef enum 816 { 817 GIMP_INK_BLOB_TYPE_CIRCLE, /*< desc="Circle" >*/ 818 GIMP_INK_BLOB_TYPE_SQUARE, /*< desc="Square" >*/ 819 GIMP_INK_BLOB_TYPE_DIAMOND /*< desc="Diamond" >*/ 820 } GimpInkBlobType; 821 822 823 /** 824 * GimpInterpolationType: 825 * @GIMP_INTERPOLATION_NONE: None 826 * @GIMP_INTERPOLATION_LINEAR: Linear 827 * @GIMP_INTERPOLATION_CUBIC: Cubic 828 * @GIMP_INTERPOLATION_NOHALO: NoHalo 829 * @GIMP_INTERPOLATION_LOHALO: LoHalo 830 * @GIMP_INTERPOLATION_LANCZOS: Deprecated alias for @GIMP_INTERPOLATION_NOHALO 831 * 832 * Interpolation types. 833 **/ 834 #define GIMP_TYPE_INTERPOLATION_TYPE (gimp_interpolation_type_get_type ()) 835 836 GType gimp_interpolation_type_get_type (void) G_GNUC_CONST; 837 838 typedef enum 839 { 840 GIMP_INTERPOLATION_NONE, /*< desc="None" >*/ 841 GIMP_INTERPOLATION_LINEAR, /*< desc="Linear" >*/ 842 GIMP_INTERPOLATION_CUBIC, /*< desc="Cubic" >*/ 843 GIMP_INTERPOLATION_NOHALO, /*< desc="NoHalo" >*/ 844 GIMP_INTERPOLATION_LOHALO, /*< desc="LoHalo" >*/ 845 846 #ifndef GIMP_DISABLE_DEPRECATED 847 GIMP_INTERPOLATION_LANCZOS = GIMP_INTERPOLATION_NOHALO /*< skip, pdb-skip >*/ 848 #endif /* GIMP_DISABLE_DEPRECATED */ 849 } GimpInterpolationType; 850 851 852 /** 853 * GimpJoinStyle: 854 * @GIMP_JOIN_MITER: Miter 855 * @GIMP_JOIN_ROUND: Round 856 * @GIMP_JOIN_BEVEL: Bevel 857 * 858 * Line join styles. 859 **/ 860 #define GIMP_TYPE_JOIN_STYLE (gimp_join_style_get_type ()) 861 862 GType gimp_join_style_get_type (void) G_GNUC_CONST; 863 864 typedef enum 865 { 866 GIMP_JOIN_MITER, /*< desc="Miter" >*/ 867 GIMP_JOIN_ROUND, /*< desc="Round" >*/ 868 GIMP_JOIN_BEVEL /*< desc="Bevel" >*/ 869 } GimpJoinStyle; 870 871 872 /** 873 * GimpMaskApplyMode: 874 * @GIMP_MASK_APPLY: Apply the mask 875 * @GIMP_MASK_DISCARD: Discard the mask 876 * 877 * Layer mask apply modes. 878 **/ 879 #define GIMP_TYPE_MASK_APPLY_MODE (gimp_mask_apply_mode_get_type ()) 880 881 GType gimp_mask_apply_mode_get_type (void) G_GNUC_CONST; 882 883 typedef enum 884 { 885 GIMP_MASK_APPLY, 886 GIMP_MASK_DISCARD 887 } GimpMaskApplyMode; 888 889 890 /** 891 * GimpMergeType: 892 * @GIMP_EXPAND_AS_NECESSARY: Expanded as necessary 893 * @GIMP_CLIP_TO_IMAGE: Clipped to image 894 * @GIMP_CLIP_TO_BOTTOM_LAYER: Clipped to bottom layer 895 * @GIMP_FLATTEN_IMAGE: Flatten 896 * 897 * Types of merging layers. 898 **/ 899 #define GIMP_TYPE_MERGE_TYPE (gimp_merge_type_get_type ()) 900 901 GType gimp_merge_type_get_type (void) G_GNUC_CONST; 902 903 typedef enum 904 { 905 GIMP_EXPAND_AS_NECESSARY, /*< desc="Expanded as necessary" >*/ 906 GIMP_CLIP_TO_IMAGE, /*< desc="Clipped to image" >*/ 907 GIMP_CLIP_TO_BOTTOM_LAYER, /*< desc="Clipped to bottom layer" >*/ 908 GIMP_FLATTEN_IMAGE /*< desc="Flatten" >*/ 909 } GimpMergeType; 910 911 912 /** 913 * GimpMessageHandlerType: 914 * @GIMP_MESSAGE_BOX: A popup dialog 915 * @GIMP_CONSOLE: The terminal 916 * @GIMP_ERROR_CONSOLE: The error console dockable 917 * 918 * How to present messages. 919 **/ 920 #define GIMP_TYPE_MESSAGE_HANDLER_TYPE (gimp_message_handler_type_get_type ()) 921 922 GType gimp_message_handler_type_get_type (void) G_GNUC_CONST; 923 924 typedef enum 925 { 926 GIMP_MESSAGE_BOX, 927 GIMP_CONSOLE, 928 GIMP_ERROR_CONSOLE 929 } GimpMessageHandlerType; 930 931 932 /** 933 * GimpOffsetType: 934 * @GIMP_OFFSET_BACKGROUND: Background 935 * @GIMP_OFFSET_TRANSPARENT: Transparent 936 * @GIMP_OFFSET_WRAP_AROUND: Wrap image around 937 * 938 * Background fill types for the offset operation. 939 **/ 940 #define GIMP_TYPE_OFFSET_TYPE (gimp_offset_type_get_type ()) 941 942 GType gimp_offset_type_get_type (void) G_GNUC_CONST; 943 944 typedef enum 945 { 946 GIMP_OFFSET_BACKGROUND, 947 GIMP_OFFSET_TRANSPARENT, 948 GIMP_OFFSET_WRAP_AROUND 949 } GimpOffsetType; 950 951 952 /** 953 * GimpOrientationType: 954 * @GIMP_ORIENTATION_HORIZONTAL: Horizontal 955 * @GIMP_ORIENTATION_VERTICAL: Vertical 956 * @GIMP_ORIENTATION_UNKNOWN: Unknown 957 * 958 * Orientations for various purposes. 959 **/ 960 #define GIMP_TYPE_ORIENTATION_TYPE (gimp_orientation_type_get_type ()) 961 962 GType gimp_orientation_type_get_type (void) G_GNUC_CONST; 963 964 typedef enum 965 { 966 GIMP_ORIENTATION_HORIZONTAL, /*< desc="Horizontal" >*/ 967 GIMP_ORIENTATION_VERTICAL, /*< desc="Vertical" >*/ 968 GIMP_ORIENTATION_UNKNOWN /*< desc="Unknown" >*/ 969 } GimpOrientationType; 970 971 972 /** 973 * GimpPaintApplicationMode: 974 * @GIMP_PAINT_CONSTANT: Constant 975 * @GIMP_PAINT_INCREMENTAL: Incremental 976 * 977 * Paint application modes. 978 **/ 979 #define GIMP_TYPE_PAINT_APPLICATION_MODE (gimp_paint_application_mode_get_type ()) 980 981 GType gimp_paint_application_mode_get_type (void) G_GNUC_CONST; 982 983 typedef enum 984 { 985 GIMP_PAINT_CONSTANT, /*< desc="Constant" >*/ 986 GIMP_PAINT_INCREMENTAL /*< desc="Incremental" >*/ 987 } GimpPaintApplicationMode; 988 989 990 /** 991 * GimpPDBArgType: 992 * @GIMP_PDB_INT32: 32-bit integer 993 * @GIMP_PDB_INT16: 16-bit integer 994 * @GIMP_PDB_INT8: 8-bit integer 995 * @GIMP_PDB_FLOAT: Float 996 * @GIMP_PDB_STRING: String 997 * @GIMP_PDB_INT32ARRAY: Array of INT32 998 * @GIMP_PDB_INT16ARRAY: Array of INT16 999 * @GIMP_PDB_INT8ARRAY: Array of INT8 1000 * @GIMP_PDB_FLOATARRAY: Array of floats 1001 * @GIMP_PDB_STRINGARRAY: Array of strings 1002 * @GIMP_PDB_COLOR: Color 1003 * @GIMP_PDB_ITEM: Item ID 1004 * @GIMP_PDB_DISPLAY: Display ID 1005 * @GIMP_PDB_IMAGE: Image ID 1006 * @GIMP_PDB_LAYER: Layer ID 1007 * @GIMP_PDB_CHANNEL: Channel ID 1008 * @GIMP_PDB_DRAWABLE: Drawable ID 1009 * @GIMP_PDB_SELECTION: Selection ID 1010 * @GIMP_PDB_COLORARRAY: Array of colors 1011 * @GIMP_PDB_VECTORS: Vectors (psath) ID 1012 * @GIMP_PDB_PARASITE: Parasite 1013 * @GIMP_PDB_STATUS: Procedure return status 1014 * @GIMP_PDB_END: Marker for last enum value 1015 * @GIMP_PDB_PATH: Deprecated alias for @GIMP_PDB_VECTORS 1016 * @GIMP_PDB_BOUNDARY: Deprecated alias for @GIMP_PDB_COLORARRAY 1017 * @GIMP_PDB_REGION: Deprecated alias for @GIMP_PDB_ITEM 1018 * 1019 * Parameter types of the PDB. 1020 **/ 1021 #define GIMP_TYPE_PDB_ARG_TYPE (gimp_pdb_arg_type_get_type ()) 1022 1023 GType gimp_pdb_arg_type_get_type (void) G_GNUC_CONST; 1024 1025 typedef enum 1026 { 1027 GIMP_PDB_INT32, 1028 GIMP_PDB_INT16, 1029 GIMP_PDB_INT8, 1030 GIMP_PDB_FLOAT, 1031 GIMP_PDB_STRING, 1032 GIMP_PDB_INT32ARRAY, 1033 GIMP_PDB_INT16ARRAY, 1034 GIMP_PDB_INT8ARRAY, 1035 GIMP_PDB_FLOATARRAY, 1036 GIMP_PDB_STRINGARRAY, 1037 GIMP_PDB_COLOR, 1038 GIMP_PDB_ITEM, 1039 GIMP_PDB_DISPLAY, 1040 GIMP_PDB_IMAGE, 1041 GIMP_PDB_LAYER, 1042 GIMP_PDB_CHANNEL, 1043 GIMP_PDB_DRAWABLE, 1044 GIMP_PDB_SELECTION, 1045 GIMP_PDB_COLORARRAY, 1046 GIMP_PDB_VECTORS, 1047 GIMP_PDB_PARASITE, 1048 GIMP_PDB_STATUS, 1049 GIMP_PDB_END, 1050 1051 #ifndef GIMP_DISABLE_DEPRECATED 1052 GIMP_PDB_PATH = GIMP_PDB_VECTORS, /*< skip >*/ 1053 GIMP_PDB_BOUNDARY = GIMP_PDB_COLORARRAY, /*< skip >*/ 1054 GIMP_PDB_REGION = GIMP_PDB_ITEM /*< skip >*/ 1055 #endif /* GIMP_DISABLE_DEPRECATED */ 1056 } GimpPDBArgType; 1057 1058 1059 /** 1060 * GimpPDBErrorHandler: 1061 * @GIMP_PDB_ERROR_HANDLER_INTERNAL: Internal 1062 * @GIMP_PDB_ERROR_HANDLER_PLUGIN: Plug-In 1063 * 1064 * PDB error handlers. 1065 **/ 1066 #define GIMP_TYPE_PDB_ERROR_HANDLER (gimp_pdb_error_handler_get_type ()) 1067 1068 GType gimp_pdb_error_handler_get_type (void) G_GNUC_CONST; 1069 1070 typedef enum 1071 { 1072 GIMP_PDB_ERROR_HANDLER_INTERNAL, 1073 GIMP_PDB_ERROR_HANDLER_PLUGIN 1074 } GimpPDBErrorHandler; 1075 1076 1077 /** 1078 * GimpPDBProcType: 1079 * @GIMP_INTERNAL: Internal GIMP procedure 1080 * @GIMP_PLUGIN: GIMP Plug-In 1081 * @GIMP_EXTENSION: GIMP Extension 1082 * @GIMP_TEMPORARY: Temporary Procedure 1083 * 1084 * Types of PDB procedures. 1085 **/ 1086 #define GIMP_TYPE_PDB_PROC_TYPE (gimp_pdb_proc_type_get_type ()) 1087 1088 GType gimp_pdb_proc_type_get_type (void) G_GNUC_CONST; 1089 1090 typedef enum 1091 { 1092 GIMP_INTERNAL, /*< desc="Internal GIMP procedure" >*/ 1093 GIMP_PLUGIN, /*< desc="GIMP Plug-In" >*/ 1094 GIMP_EXTENSION, /*< desc="GIMP Extension" >*/ 1095 GIMP_TEMPORARY /*< desc="Temporary Procedure" >*/ 1096 } GimpPDBProcType; 1097 1098 1099 /** 1100 * GimpPDBStatusType: 1101 * @GIMP_PDB_EXECUTION_ERROR: Execution error 1102 * @GIMP_PDB_CALLING_ERROR: Calling error 1103 * @GIMP_PDB_PASS_THROUGH: Pass through 1104 * @GIMP_PDB_SUCCESS: Success 1105 * @GIMP_PDB_CANCEL: User cancel 1106 * 1107 * Return status of PDB calls. 1108 **/ 1109 #define GIMP_TYPE_PDB_STATUS_TYPE (gimp_pdb_status_type_get_type ()) 1110 1111 GType gimp_pdb_status_type_get_type (void) G_GNUC_CONST; 1112 1113 typedef enum 1114 { 1115 GIMP_PDB_EXECUTION_ERROR, 1116 GIMP_PDB_CALLING_ERROR, 1117 GIMP_PDB_PASS_THROUGH, 1118 GIMP_PDB_SUCCESS, 1119 GIMP_PDB_CANCEL 1120 } GimpPDBStatusType; 1121 1122 1123 /** 1124 * GimpPrecision: 1125 * @GIMP_PRECISION_U8_LINEAR: 8-bit linear integer 1126 * @GIMP_PRECISION_U8_GAMMA: 8-bit gamma integer 1127 * @GIMP_PRECISION_U16_LINEAR: 16-bit linear integer 1128 * @GIMP_PRECISION_U16_GAMMA: 16-bit gamma integer 1129 * @GIMP_PRECISION_U32_LINEAR: 32-bit linear integer 1130 * @GIMP_PRECISION_U32_GAMMA: 32-bit gamma integer 1131 * @GIMP_PRECISION_HALF_LINEAR: 16-bit linear floating point 1132 * @GIMP_PRECISION_HALF_GAMMA: 16-bit gamma floating point 1133 * @GIMP_PRECISION_FLOAT_LINEAR: 32-bit linear floating point 1134 * @GIMP_PRECISION_FLOAT_GAMMA: 32-bit gamma floating point 1135 * @GIMP_PRECISION_DOUBLE_LINEAR: 64-bit linear floating point 1136 * @GIMP_PRECISION_DOUBLE_GAMMA: 64-bit gamma floating point 1137 * 1138 * Precisions for pixel encoding. 1139 * 1140 * Since: 2.10 1141 **/ 1142 #define GIMP_TYPE_PRECISION (gimp_precision_get_type ()) 1143 1144 GType gimp_precision_get_type (void) G_GNUC_CONST; 1145 1146 typedef enum 1147 { 1148 GIMP_PRECISION_U8_LINEAR = 100, /*< desc="8-bit linear integer" >*/ 1149 GIMP_PRECISION_U8_GAMMA = 150, /*< desc="8-bit gamma integer" >*/ 1150 GIMP_PRECISION_U16_LINEAR = 200, /*< desc="16-bit linear integer" >*/ 1151 GIMP_PRECISION_U16_GAMMA = 250, /*< desc="16-bit gamma integer" >*/ 1152 GIMP_PRECISION_U32_LINEAR = 300, /*< desc="32-bit linear integer" >*/ 1153 GIMP_PRECISION_U32_GAMMA = 350, /*< desc="32-bit gamma integer" >*/ 1154 GIMP_PRECISION_HALF_LINEAR = 500, /*< desc="16-bit linear floating point" >*/ 1155 GIMP_PRECISION_HALF_GAMMA = 550, /*< desc="16-bit gamma floating point" >*/ 1156 GIMP_PRECISION_FLOAT_LINEAR = 600, /*< desc="32-bit linear floating point" >*/ 1157 GIMP_PRECISION_FLOAT_GAMMA = 650, /*< desc="32-bit gamma floating point" >*/ 1158 GIMP_PRECISION_DOUBLE_LINEAR = 700, /*< desc="64-bit linear floating point" >*/ 1159 GIMP_PRECISION_DOUBLE_GAMMA = 750 /*< desc="64-bit gamma floating point" >*/ 1160 } GimpPrecision; 1161 1162 1163 /** 1164 * GimpProgressCommand: 1165 * @GIMP_PROGRESS_COMMAND_START: Start a progress 1166 * @GIMP_PROGRESS_COMMAND_END: End the progress 1167 * @GIMP_PROGRESS_COMMAND_SET_TEXT: Set the text 1168 * @GIMP_PROGRESS_COMMAND_SET_VALUE: Set the percentage 1169 * @GIMP_PROGRESS_COMMAND_PULSE: Pulse the progress 1170 * @GIMP_PROGRESS_COMMAND_GET_WINDOW: Get the window where the progress is shown 1171 * 1172 * Commands for the progress API. 1173 **/ 1174 #define GIMP_TYPE_PROGRESS_COMMAND (gimp_progress_command_get_type ()) 1175 1176 GType gimp_progress_command_get_type (void) G_GNUC_CONST; 1177 1178 typedef enum 1179 { 1180 GIMP_PROGRESS_COMMAND_START, 1181 GIMP_PROGRESS_COMMAND_END, 1182 GIMP_PROGRESS_COMMAND_SET_TEXT, 1183 GIMP_PROGRESS_COMMAND_SET_VALUE, 1184 GIMP_PROGRESS_COMMAND_PULSE, 1185 GIMP_PROGRESS_COMMAND_GET_WINDOW 1186 } GimpProgressCommand; 1187 1188 1189 /** 1190 * GimpRepeatMode: 1191 * @GIMP_REPEAT_NONE: None (extend) 1192 * @GIMP_REPEAT_SAWTOOTH: Sawtooth wave 1193 * @GIMP_REPEAT_TRIANGULAR: Triangular wave 1194 * @GIMP_REPEAT_TRUNCATE: Truncate 1195 * 1196 * Repeat modes for example for gradients. 1197 **/ 1198 #define GIMP_TYPE_REPEAT_MODE (gimp_repeat_mode_get_type ()) 1199 1200 GType gimp_repeat_mode_get_type (void) G_GNUC_CONST; 1201 1202 typedef enum 1203 { 1204 GIMP_REPEAT_NONE, /*< desc="None (extend)" >*/ 1205 GIMP_REPEAT_SAWTOOTH, /*< desc="Sawtooth wave" >*/ 1206 GIMP_REPEAT_TRIANGULAR, /*< desc="Triangular wave" >*/ 1207 GIMP_REPEAT_TRUNCATE /*< desc="Truncate" >*/ 1208 } GimpRepeatMode; 1209 1210 1211 /** 1212 * GimpRotationType: 1213 * @GIMP_ROTATE_90: 90 degrees 1214 * @GIMP_ROTATE_180: 180 degrees 1215 * @GIMP_ROTATE_270: 270 degrees 1216 * 1217 * Types of simple rotations. 1218 **/ 1219 #define GIMP_TYPE_ROTATION_TYPE (gimp_rotation_type_get_type ()) 1220 1221 GType gimp_rotation_type_get_type (void) G_GNUC_CONST; 1222 1223 typedef enum 1224 { 1225 GIMP_ROTATE_90, 1226 GIMP_ROTATE_180, 1227 GIMP_ROTATE_270 1228 } GimpRotationType; 1229 1230 1231 /** 1232 * GimpRunMode: 1233 * @GIMP_RUN_INTERACTIVE: Run interactively 1234 * @GIMP_RUN_NONINTERACTIVE: Run non-interactively 1235 * @GIMP_RUN_WITH_LAST_VALS: Run with last used values 1236 * 1237 * Run modes for plug-ins. 1238 **/ 1239 #define GIMP_TYPE_RUN_MODE (gimp_run_mode_get_type ()) 1240 1241 GType gimp_run_mode_get_type (void) G_GNUC_CONST; 1242 1243 typedef enum 1244 { 1245 GIMP_RUN_INTERACTIVE, /*< desc="Run interactively" >*/ 1246 GIMP_RUN_NONINTERACTIVE, /*< desc="Run non-interactively" >*/ 1247 GIMP_RUN_WITH_LAST_VALS /*< desc="Run with last used values" >*/ 1248 } GimpRunMode; 1249 1250 1251 /** 1252 * GimpSelectCriterion: 1253 * @GIMP_SELECT_CRITERION_COMPOSITE: Composite 1254 * @GIMP_SELECT_CRITERION_R: Red 1255 * @GIMP_SELECT_CRITERION_G: Green 1256 * @GIMP_SELECT_CRITERION_B: Blue 1257 * @GIMP_SELECT_CRITERION_H: HSV Hue 1258 * @GIMP_SELECT_CRITERION_S: HSV Saturation 1259 * @GIMP_SELECT_CRITERION_V: HSV Value 1260 * @GIMP_SELECT_CRITERION_A: Alpha 1261 * @GIMP_SELECT_CRITERION_LCH_L: LCh Lightness 1262 * @GIMP_SELECT_CRITERION_LCH_C: LCh Chroma 1263 * @GIMP_SELECT_CRITERION_LCH_H: LCh Hue 1264 * 1265 * Criterions for color similarity. 1266 **/ 1267 #define GIMP_TYPE_SELECT_CRITERION (gimp_select_criterion_get_type ()) 1268 1269 GType gimp_select_criterion_get_type (void) G_GNUC_CONST; 1270 1271 typedef enum 1272 { 1273 GIMP_SELECT_CRITERION_COMPOSITE, /*< desc="Composite" >*/ 1274 GIMP_SELECT_CRITERION_R, /*< desc="Red" >*/ 1275 GIMP_SELECT_CRITERION_G, /*< desc="Green" >*/ 1276 GIMP_SELECT_CRITERION_B, /*< desc="Blue" >*/ 1277 GIMP_SELECT_CRITERION_H, /*< desc="HSV Hue" >*/ 1278 GIMP_SELECT_CRITERION_S, /*< desc="HSV Saturation" >*/ 1279 GIMP_SELECT_CRITERION_V, /*< desc="HSV Value" >*/ 1280 GIMP_SELECT_CRITERION_A, /*< desc="Alpha" >*/ 1281 GIMP_SELECT_CRITERION_LCH_L, /*< desc="LCh Lightness" >*/ 1282 GIMP_SELECT_CRITERION_LCH_C, /*< desc="LCh Chroma" >*/ 1283 GIMP_SELECT_CRITERION_LCH_H, /*< desc="LCh Hue" >*/ 1284 } GimpSelectCriterion; 1285 1286 1287 /** 1288 * GimpSizeType: 1289 * @GIMP_PIXELS: Pixels 1290 * @GIMP_POINTS: Points 1291 * 1292 * Size types for the old-style text API. 1293 **/ 1294 #define GIMP_TYPE_SIZE_TYPE (gimp_size_type_get_type ()) 1295 1296 GType gimp_size_type_get_type (void) G_GNUC_CONST; 1297 1298 typedef enum 1299 { 1300 GIMP_PIXELS, /*< desc="Pixels" >*/ 1301 GIMP_POINTS /*< desc="Points" >*/ 1302 } GimpSizeType; 1303 1304 1305 /** 1306 * GimpStackTraceMode: 1307 * @GIMP_STACK_TRACE_NEVER: Never 1308 * @GIMP_STACK_TRACE_QUERY: Ask each time 1309 * @GIMP_STACK_TRACE_ALWAYS: Always 1310 * 1311 * When to generate stack traces in case of an error. 1312 **/ 1313 #define GIMP_TYPE_STACK_TRACE_MODE (gimp_stack_trace_mode_get_type ()) 1314 1315 GType gimp_stack_trace_mode_get_type (void) G_GNUC_CONST; 1316 1317 typedef enum 1318 { 1319 GIMP_STACK_TRACE_NEVER, 1320 GIMP_STACK_TRACE_QUERY, 1321 GIMP_STACK_TRACE_ALWAYS 1322 } GimpStackTraceMode; 1323 1324 1325 /** 1326 * GimpStrokeMethod: 1327 * @GIMP_STROKE_LINE: Stroke line 1328 * @GIMP_STROKE_PAINT_METHOD: Stroke with a paint tool 1329 * 1330 * Methods of stroking selections and paths. 1331 **/ 1332 #define GIMP_TYPE_STROKE_METHOD (gimp_stroke_method_get_type ()) 1333 1334 GType gimp_stroke_method_get_type (void) G_GNUC_CONST; 1335 1336 typedef enum 1337 { 1338 GIMP_STROKE_LINE, /*< desc="Stroke line" >*/ 1339 GIMP_STROKE_PAINT_METHOD /*< desc="Stroke with a paint tool" >*/ 1340 } GimpStrokeMethod; 1341 1342 1343 /** 1344 * GimpTextDirection: 1345 * @GIMP_TEXT_DIRECTION_LTR: From left to right 1346 * @GIMP_TEXT_DIRECTION_RTL: From right to left 1347 * @GIMP_TEXT_DIRECTION_TTB_RTL: Characters are from top to bottom, Lines are from right to left 1348 * @GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT: Upright characters are from top to bottom, Lines are from right to left 1349 * @GIMP_TEXT_DIRECTION_TTB_LTR: Characters are from top to bottom, Lines are from left to right 1350 * @GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT: Upright characters are from top to bottom, Lines are from left to right 1351 * 1352 * Text directions. 1353 **/ 1354 #define GIMP_TYPE_TEXT_DIRECTION (gimp_text_direction_get_type ()) 1355 1356 GType gimp_text_direction_get_type (void) G_GNUC_CONST; 1357 1358 typedef enum 1359 { 1360 GIMP_TEXT_DIRECTION_LTR, /*< desc="From left to right" >*/ 1361 GIMP_TEXT_DIRECTION_RTL, /*< desc="From right to left" >*/ 1362 GIMP_TEXT_DIRECTION_TTB_RTL, /*< desc="Vertical, right to left (mixed orientation)" >*/ 1363 GIMP_TEXT_DIRECTION_TTB_RTL_UPRIGHT, /*< desc="Vertical, right to left (upright orientation)" >*/ 1364 GIMP_TEXT_DIRECTION_TTB_LTR, /*< desc="Vertical, left to right (mixed orientation)" >*/ 1365 GIMP_TEXT_DIRECTION_TTB_LTR_UPRIGHT /*< desc="Vertical, left to right (upright orientation)" >*/ 1366 } GimpTextDirection; 1367 1368 1369 /** 1370 * GimpTextHintStyle: 1371 * @GIMP_TEXT_HINT_STYLE_NONE: None 1372 * @GIMP_TEXT_HINT_STYLE_SLIGHT: Slight 1373 * @GIMP_TEXT_HINT_STYLE_MEDIUM: Medium 1374 * @GIMP_TEXT_HINT_STYLE_FULL: Full 1375 * 1376 * Text hint strengths. 1377 **/ 1378 #define GIMP_TYPE_TEXT_HINT_STYLE (gimp_text_hint_style_get_type ()) 1379 1380 GType gimp_text_hint_style_get_type (void) G_GNUC_CONST; 1381 1382 typedef enum 1383 { 1384 GIMP_TEXT_HINT_STYLE_NONE, /*< desc="None" >*/ 1385 GIMP_TEXT_HINT_STYLE_SLIGHT, /*< desc="Slight" >*/ 1386 GIMP_TEXT_HINT_STYLE_MEDIUM, /*< desc="Medium" >*/ 1387 GIMP_TEXT_HINT_STYLE_FULL /*< desc="Full" >*/ 1388 } GimpTextHintStyle; 1389 1390 1391 /** 1392 * GimpTextJustification: 1393 * @GIMP_TEXT_JUSTIFY_LEFT: Left justified 1394 * @GIMP_TEXT_JUSTIFY_RIGHT: Right justified 1395 * @GIMP_TEXT_JUSTIFY_CENTER: Centered 1396 * @GIMP_TEXT_JUSTIFY_FILL: Filled 1397 * 1398 * Text justifications. 1399 **/ 1400 #define GIMP_TYPE_TEXT_JUSTIFICATION (gimp_text_justification_get_type ()) 1401 1402 GType gimp_text_justification_get_type (void) G_GNUC_CONST; 1403 1404 typedef enum 1405 { 1406 GIMP_TEXT_JUSTIFY_LEFT, /*< desc="Left justified" >*/ 1407 GIMP_TEXT_JUSTIFY_RIGHT, /*< desc="Right justified" >*/ 1408 GIMP_TEXT_JUSTIFY_CENTER, /*< desc="Centered" >*/ 1409 GIMP_TEXT_JUSTIFY_FILL /*< desc="Filled" >*/ 1410 } GimpTextJustification; 1411 1412 1413 /** 1414 * GimpTransferMode: 1415 * @GIMP_TRANSFER_SHADOWS: Shadows 1416 * @GIMP_TRANSFER_MIDTONES: Midtones 1417 * @GIMP_TRANSFER_HIGHLIGHTS: Highlights 1418 * @GIMP_SHADOWS: Deprecated alias for @GIMP_TRANSFER_SHADOWS 1419 * @GIMP_MIDTONES: Deprecated alias for @GIMP_TRANSFER_MIDTONES 1420 * @GIMP_HIGHLIGHTS: Deprecated alias for @GIMP_TRANSFER_HIGHLIGHTS 1421 * 1422 * For choosing which brightness ranges to transform. 1423 **/ 1424 #define GIMP_TYPE_TRANSFER_MODE (gimp_transfer_mode_get_type ()) 1425 1426 GType gimp_transfer_mode_get_type (void) G_GNUC_CONST; 1427 1428 typedef enum 1429 { 1430 GIMP_TRANSFER_SHADOWS, /*< desc="Shadows" >*/ 1431 GIMP_TRANSFER_MIDTONES, /*< desc="Midtones" >*/ 1432 GIMP_TRANSFER_HIGHLIGHTS, /*< desc="Highlights" >*/ 1433 1434 #ifndef GIMP_DISABLE_DEPRECATED 1435 GIMP_SHADOWS = GIMP_TRANSFER_SHADOWS, /*< skip, pdb-skip >*/ 1436 GIMP_MIDTONES = GIMP_TRANSFER_MIDTONES, /*< skip, pdb-skip >*/ 1437 GIMP_HIGHLIGHTS = GIMP_TRANSFER_HIGHLIGHTS /*< skip, pdb-skip >*/ 1438 #endif /* GIMP_DISABLE_DEPRECATED */ 1439 } GimpTransferMode; 1440 1441 1442 /** 1443 * GimpTransformDirection: 1444 * @GIMP_TRANSFORM_FORWARD: Normal (Forward) 1445 * @GIMP_TRANSFORM_BACKWARD: Corrective (Backward) 1446 * 1447 * Transform directions. 1448 **/ 1449 #define GIMP_TYPE_TRANSFORM_DIRECTION (gimp_transform_direction_get_type ()) 1450 1451 GType gimp_transform_direction_get_type (void) G_GNUC_CONST; 1452 1453 typedef enum 1454 { 1455 GIMP_TRANSFORM_FORWARD, /*< desc="Normal (Forward)" >*/ 1456 GIMP_TRANSFORM_BACKWARD /*< desc="Corrective (Backward)" >*/ 1457 } GimpTransformDirection; 1458 1459 1460 /** 1461 * GimpTransformResize: 1462 * @GIMP_TRANSFORM_RESIZE_ADJUST: Adjust 1463 * @GIMP_TRANSFORM_RESIZE_CLIP: Clip 1464 * @GIMP_TRANSFORM_RESIZE_CROP: Crop to result 1465 * @GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT: Crop with aspect 1466 * 1467 * Ways of clipping the result when transforming drawables. 1468 **/ 1469 #define GIMP_TYPE_TRANSFORM_RESIZE (gimp_transform_resize_get_type ()) 1470 1471 GType gimp_transform_resize_get_type (void) G_GNUC_CONST; 1472 1473 typedef enum 1474 { 1475 GIMP_TRANSFORM_RESIZE_ADJUST, /*< desc="Adjust" >*/ 1476 GIMP_TRANSFORM_RESIZE_CLIP, /*< desc="Clip" >*/ 1477 GIMP_TRANSFORM_RESIZE_CROP, /*< desc="Crop to result" >*/ 1478 GIMP_TRANSFORM_RESIZE_CROP_WITH_ASPECT /*< desc="Crop with aspect" >*/ 1479 } GimpTransformResize; 1480 1481 1482 /** 1483 * GimpUnit: 1484 * @GIMP_UNIT_PIXEL: Pixels 1485 * @GIMP_UNIT_INCH: Inches 1486 * @GIMP_UNIT_MM: Millimeters 1487 * @GIMP_UNIT_POINT: Points 1488 * @GIMP_UNIT_PICA: Picas 1489 * @GIMP_UNIT_END: Marker for end-of-builtin-units 1490 * @GIMP_UNIT_PERCENT: Pseudo-unit percent 1491 * 1492 * Units used for dimensions in images. 1493 **/ 1494 typedef enum /*< skip >*/ 1495 { 1496 GIMP_UNIT_PIXEL = 0, 1497 1498 GIMP_UNIT_INCH = 1, 1499 GIMP_UNIT_MM = 2, 1500 GIMP_UNIT_POINT = 3, 1501 GIMP_UNIT_PICA = 4, 1502 1503 GIMP_UNIT_END = 5, 1504 1505 GIMP_UNIT_PERCENT = 65536 /*< pdb-skip >*/ 1506 } GimpUnit; 1507 1508 1509 #ifndef GIMP_DISABLE_DEPRECATED 1510 /** 1511 * GimpUserDirectory: 1512 * @GIMP_USER_DIRECTORY_DESKTOP: Deprecated 1513 * @GIMP_USER_DIRECTORY_DOCUMENTS: Deprecated 1514 * @GIMP_USER_DIRECTORY_DOWNLOAD: Deprecated 1515 * @GIMP_USER_DIRECTORY_MUSIC: Deprecated 1516 * @GIMP_USER_DIRECTORY_PICTURES: Deprecated 1517 * @GIMP_USER_DIRECTORY_PUBLIC_SHARE: Deprecated 1518 * @GIMP_USER_DIRECTORY_TEMPLATES: Deprecated 1519 * @GIMP_USER_DIRECTORY_VIDEOS: Deprecated 1520 * 1521 * Deprecated enum, don't use. 1522 **/ 1523 #define GIMP_TYPE_USER_DIRECTORY (gimp_user_directory_get_type ()) 1524 1525 GType gimp_user_directory_get_type (void) G_GNUC_CONST; 1526 1527 typedef enum 1528 { 1529 GIMP_USER_DIRECTORY_DESKTOP, 1530 GIMP_USER_DIRECTORY_DOCUMENTS, 1531 GIMP_USER_DIRECTORY_DOWNLOAD, 1532 GIMP_USER_DIRECTORY_MUSIC, 1533 GIMP_USER_DIRECTORY_PICTURES, 1534 GIMP_USER_DIRECTORY_PUBLIC_SHARE, 1535 GIMP_USER_DIRECTORY_TEMPLATES, 1536 GIMP_USER_DIRECTORY_VIDEOS 1537 } GimpUserDirectory; 1538 #endif /* !GIMP_DISABLE_DEPRECATED */ 1539 1540 1541 /** 1542 * GimpVectorsStrokeType: 1543 * @GIMP_VECTORS_STROKE_TYPE_BEZIER: A bezier stroke 1544 * 1545 * Possible type of strokes in vectors objects. 1546 **/ 1547 #define GIMP_TYPE_VECTORS_STROKE_TYPE (gimp_vectors_stroke_type_get_type ()) 1548 1549 GType gimp_vectors_stroke_type_get_type (void) G_GNUC_CONST; 1550 1551 typedef enum 1552 { 1553 GIMP_VECTORS_STROKE_TYPE_BEZIER 1554 } GimpVectorsStrokeType; 1555 1556 G_END_DECLS 1557 1558 #endif /* __GIMP_BASE_ENUMS_H__ */ 1559