/usr/lib/x86_64-linux-gnu/perl5/5.20/Imager/include/imdatatypes.h is in libimager-perl 1.000+dfsg-2+b3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 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 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 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 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 | #ifndef _DATATYPES_H_
#define _DATATYPES_H_
#include <stddef.h>
#include "imconfig.h"
#define MAXCHANNELS 4
typedef struct im_context_tag *im_context_t;
typedef ptrdiff_t im_slot_t;
typedef void (*im_slot_destroy_t)(void *);
/* used for palette indices in some internal code (which might be
exposed at some point
*/
typedef unsigned char i_palidx;
/* We handle 2 types of sample, this is hopefully the most common, and the
smaller of the ones we support */
typedef unsigned char i_sample_t;
typedef struct { i_sample_t gray_color; } gray_color;
typedef struct { i_sample_t r,g,b; } rgb_color;
typedef struct { i_sample_t r,g,b,a; } rgba_color;
typedef struct { i_sample_t c,m,y,k; } cmyk_color;
typedef int undef_int; /* special value to put in typemaps to retun undef on 0 and 1 on 1 */
/*
=item i_img_dim
=category Data Types
=synopsis i_img_dim x, y;
=order 90
A signed integer type that represents an image dimension or ordinate.
May be larger than int on some platforms.
=cut
*/
typedef ptrdiff_t i_img_dim;
typedef size_t i_img_dim_u;
#define i_img_dim_MAX ((i_img_dim)(~(i_img_dim_u)0 >> 1))
/*
=item i_color
=category Data Types
=synopsis i_color black;
=synopsis black.rgba.r = black.rgba.g = black.rgba.b = black.rgba.a = 0;
Type for 8-bit/sample color.
Samples as per;
i_color c;
i_color is a union of:
=over
=item *
gray - contains a single element gray_color, eg. C<c.gray.gray_color>
=item *
C<rgb> - contains three elements C<r>, C<g>, C<b>, eg. C<c.rgb.r>
=item *
C<rgba> - contains four elements C<r>, C<g>, C<b>, C<a>, eg. C<c.rgba.a>
=item *
C<cmyk> - contains four elements C<c>, C<m>, C<y>, C<k>,
eg. C<c.cmyk.y>. Note that Imager never uses CMYK colors except when
reading/writing files.
=item *
channels - an array of four channels, eg C<c.channels[2]>.
=back
=cut
*/
typedef union {
gray_color gray;
rgb_color rgb;
rgba_color rgba;
cmyk_color cmyk;
i_sample_t channel[MAXCHANNELS];
unsigned int ui;
} i_color;
/* this is the larger sample type, it should be able to accurately represent
any sample size we use */
typedef double i_fsample_t;
typedef struct { i_fsample_t gray_color; } i_fgray_color_t;
typedef struct { i_fsample_t r, g, b; } i_frgb_color_t;
typedef struct { i_fsample_t r, g, b, a; } i_frgba_color_t;
typedef struct { i_fsample_t c, m, y, k; } i_fcmyk_color_t;
/*
=item i_fcolor
=category Data Types
This is the double/sample color type.
Its layout exactly corresponds to i_color.
=cut
*/
typedef union {
i_fgray_color_t gray;
i_frgb_color_t rgb;
i_frgba_color_t rgba;
i_fcmyk_color_t cmyk;
i_fsample_t channel[MAXCHANNELS];
} i_fcolor;
typedef enum {
i_direct_type, /* direct colour, keeps RGB values per pixel */
i_palette_type /* keeps a palette index per pixel */
} i_img_type_t;
typedef enum {
/* bits per sample, not per pixel */
/* a paletted image might have one bit per sample */
i_8_bits = 8,
i_16_bits = 16,
i_double_bits = sizeof(double) * 8
} i_img_bits_t;
typedef struct {
char *name; /* name of a given tag, might be NULL */
int code; /* number of a given tag, -1 if it has no meaning */
char *data; /* value of a given tag if it's not an int, may be NULL */
int size; /* size of the data */
int idata; /* value of a given tag if data is NULL */
} i_img_tag;
typedef struct {
int count; /* how many tags have been set */
int alloc; /* how many tags have been allocated for */
i_img_tag *tags;
} i_img_tags;
typedef struct i_img_ i_img;
typedef int (*i_f_ppix_t)(i_img *im, i_img_dim x, i_img_dim y, const i_color *pix);
typedef int (*i_f_ppixf_t)(i_img *im, i_img_dim x, i_img_dim y, const i_fcolor *pix);
typedef i_img_dim (*i_f_plin_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, const i_color *vals);
typedef i_img_dim (*i_f_plinf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, const i_fcolor *vals);
typedef int (*i_f_gpix_t)(i_img *im, i_img_dim x, i_img_dim y, i_color *pix);
typedef int (*i_f_gpixf_t)(i_img *im, i_img_dim x, i_img_dim y, i_fcolor *pix);
typedef i_img_dim (*i_f_glin_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_color *vals);
typedef i_img_dim (*i_f_glinf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_fcolor *vals);
typedef i_img_dim (*i_f_gsamp_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_sample_t *samp,
const int *chans, int chan_count);
typedef i_img_dim (*i_f_gsampf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_fsample_t *samp,
const int *chan, int chan_count);
typedef i_img_dim (*i_f_gpal_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, i_palidx *vals);
typedef i_img_dim (*i_f_ppal_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, const i_palidx *vals);
typedef int (*i_f_addcolors_t)(i_img *im, const i_color *colors, int count);
typedef int (*i_f_getcolors_t)(i_img *im, int i, i_color *, int count);
typedef int (*i_f_colorcount_t)(i_img *im);
typedef int (*i_f_maxcolors_t)(i_img *im);
typedef int (*i_f_findcolor_t)(i_img *im, const i_color *color, i_palidx *entry);
typedef int (*i_f_setcolors_t)(i_img *im, int index, const i_color *colors,
int count);
typedef void (*i_f_destroy_t)(i_img *im);
typedef i_img_dim (*i_f_gsamp_bits_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, unsigned *samp,
const int *chans, int chan_count, int bits);
typedef i_img_dim (*i_f_psamp_bits_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y, unsigned const *samp,
const int *chans, int chan_count, int bits);
typedef i_img_dim
(*i_f_psamp_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y,
const i_sample_t *samp, const int *chan, int chan_count);
typedef i_img_dim
(*i_f_psampf_t)(i_img *im, i_img_dim x, i_img_dim r, i_img_dim y,
const i_fsample_t *samp, const int *chan, int chan_count);
/*
=item i_img
=category Data Types
=synopsis i_img *img;
=order 10
This is Imager's image type.
It contains the following members:
=over
=item *
C<channels> - the number of channels in the image
=item *
C<xsize>, C<ysize> - the width and height of the image in pixels
=item *
C<bytes> - the number of bytes used to store the image data. Undefined
where virtual is non-zero.
=item *
C<ch_mask> - a mask of writable channels. eg. if this is 6 then only
channels 1 and 2 are writable. There may be bits set for which there
are no channels in the image.
=item *
C<bits> - the number of bits stored per sample. Should be one of
i_8_bits, i_16_bits, i_double_bits.
=item *
C<type> - either i_direct_type for direct color images, or i_palette_type
for paletted images.
=item *
C<virtual> - if zero then this image is-self contained. If non-zero
then this image could be an interface to some other implementation.
=item *
C<idata> - the image data. This should not be directly accessed. A new
image implementation can use this to store its image data.
i_img_destroy() will myfree() this pointer if it's non-null.
=item *
C<tags> - a structure storing the image's tags. This should only be
accessed via the i_tags_*() functions.
=item *
C<ext_data> - a pointer for use internal to an image implementation.
This should be freed by the image's destroy handler.
=item *
C<im_data> - data internal to Imager. This is initialized by
i_img_init().
=item *
i_f_ppix, i_f_ppixf, i_f_plin, i_f_plinf, i_f_gpix, i_f_gpixf,
i_f_glin, i_f_glinf, i_f_gsamp, i_f_gampf - implementations for each
of the required image functions. An image implementation should
initialize these between calling i_img_alloc() and i_img_init().
=item *
i_f_gpal, i_f_ppal, i_f_addcolors, i_f_getcolors, i_f_colorcount,
i_f_maxcolors, i_f_findcolor, i_f_setcolors - implementations for each
paletted image function.
=item *
i_f_destroy - custom image destruction function. This should be used
to release memory if necessary.
=item *
i_f_gsamp_bits - implements i_gsamp_bits() for this image.
=item *
i_f_psamp_bits - implements i_psamp_bits() for this image.
=item *
i_f_psamp - implements psamp() for this image.
=item *
i_f_psampf - implements psamp() for this image.
=item *
C<im_data> - image specific data internal to Imager.
=item *
C<context> - the Imager API context this image belongs to.
=back
=cut
*/
struct i_img_ {
int channels;
i_img_dim xsize,ysize;
size_t bytes;
unsigned int ch_mask;
i_img_bits_t bits;
i_img_type_t type;
int virtual; /* image might not keep any data, must use functions */
unsigned char *idata; /* renamed to force inspection of existing code */
/* can be NULL if virtual is non-zero */
i_img_tags tags;
void *ext_data;
/* interface functions */
i_f_ppix_t i_f_ppix;
i_f_ppixf_t i_f_ppixf;
i_f_plin_t i_f_plin;
i_f_plinf_t i_f_plinf;
i_f_gpix_t i_f_gpix;
i_f_gpixf_t i_f_gpixf;
i_f_glin_t i_f_glin;
i_f_glinf_t i_f_glinf;
i_f_gsamp_t i_f_gsamp;
i_f_gsampf_t i_f_gsampf;
/* only valid for type == i_palette_type */
i_f_gpal_t i_f_gpal;
i_f_ppal_t i_f_ppal;
i_f_addcolors_t i_f_addcolors;
i_f_getcolors_t i_f_getcolors;
i_f_colorcount_t i_f_colorcount;
i_f_maxcolors_t i_f_maxcolors;
i_f_findcolor_t i_f_findcolor;
i_f_setcolors_t i_f_setcolors;
i_f_destroy_t i_f_destroy;
/* as of 0.61 */
i_f_gsamp_bits_t i_f_gsamp_bits;
i_f_psamp_bits_t i_f_psamp_bits;
/* as of 0.88 */
i_f_psamp_t i_f_psamp;
i_f_psampf_t i_f_psampf;
void *im_data;
/* 0.91 */
im_context_t context;
};
/* ext_data for paletted images
*/
typedef struct {
int count; /* amount of space used in palette (in entries) */
int alloc; /* amount of space allocated for palette (in entries) */
i_color *pal;
int last_found;
} i_img_pal_ext;
/* Helper datatypes
The types in here so far are:
doubly linked bucket list - pretty efficient
octtree - no idea about goodness
needed: hashes.
*/
/* bitmap mask */
struct i_bitmap {
i_img_dim xsize,ysize;
char *data;
};
struct i_bitmap* btm_new(i_img_dim xsize,i_img_dim ysize);
void btm_destroy(struct i_bitmap *btm);
int btm_test(struct i_bitmap *btm,i_img_dim x,i_img_dim y);
void btm_set(struct i_bitmap *btm,i_img_dim x,i_img_dim y);
/* Stack/Linked list */
struct llink {
struct llink *p,*n;
void *data;
int fill; /* Number used in this link */
};
struct llist {
struct llink *h,*t;
int multip; /* # of copies in a single chain */
size_t ssize; /* size of each small element */
int count; /* number of elements on the list */
};
/* Lists */
struct llist *llist_new( int multip, size_t ssize );
void llist_destroy( struct llist *l );
void llist_push( struct llist *l, const void *data );
void llist_dump( struct llist *l );
int llist_pop( struct llist *l,void *data );
/* Octtree */
struct octt {
struct octt *t[8];
int cnt;
};
struct octt *octt_new(void);
int octt_add(struct octt *ct,unsigned char r,unsigned char g,unsigned char b);
void octt_dump(struct octt *ct);
void octt_count(struct octt *ct,int *tot,int max,int *overflow);
void octt_delete(struct octt *ct);
void octt_histo(struct octt *ct, unsigned int **col_usage_it_adr);
/* font bounding box results */
enum bounding_box_index_t {
BBOX_NEG_WIDTH,
BBOX_GLOBAL_DESCENT,
BBOX_POS_WIDTH,
BBOX_GLOBAL_ASCENT,
BBOX_DESCENT,
BBOX_ASCENT,
BBOX_ADVANCE_WIDTH,
BBOX_RIGHT_BEARING,
BOUNDING_BOX_COUNT
};
/* Generic fills */
struct i_fill_tag;
typedef void (*i_fill_with_color_f)
(struct i_fill_tag *fill, i_img_dim x, i_img_dim y, i_img_dim width, int channels,
i_color *data);
typedef void (*i_fill_with_fcolor_f)
(struct i_fill_tag *fill, i_img_dim x, i_img_dim y, i_img_dim width, int channels,
i_fcolor *data);
typedef void (*i_fill_destroy_f)(struct i_fill_tag *fill);
/* combine functions modify their target and are permitted to modify
the source to prevent having to perform extra copying/memory
allocations, etc
The out array has I<channels> channels.
The in array has I<channels> channels + an alpha channel if one
isn't included in I<channels>.
*/
typedef void (*i_fill_combine_f)(i_color *out, i_color *in, int channels,
i_img_dim count);
typedef void (*i_fill_combinef_f)(i_fcolor *out, i_fcolor *in, int channels,
i_img_dim count);
/* fountain fill types */
typedef enum {
i_fst_linear,
i_fst_curved,
i_fst_sine,
i_fst_sphere_up,
i_fst_sphere_down,
i_fst_end
} i_fountain_seg_type;
typedef enum {
i_fc_direct,
i_fc_hue_up,
i_fc_hue_down,
i_fc_end
} i_fountain_color;
typedef struct {
double start, middle, end;
i_fcolor c[2];
i_fountain_seg_type type;
i_fountain_color color;
} i_fountain_seg;
typedef enum {
i_fr_none,
i_fr_sawtooth,
i_fr_triangle,
i_fr_saw_both,
i_fr_tri_both
} i_fountain_repeat;
typedef enum {
i_ft_linear,
i_ft_bilinear,
i_ft_radial,
i_ft_radial_square,
i_ft_revolution,
i_ft_conical,
i_ft_end
} i_fountain_type;
typedef enum {
i_fts_none,
i_fts_grid,
i_fts_random,
i_fts_circle
} i_ft_supersample;
/*
=item i_fill_t
=category Data Types
=synopsis i_fill_t *fill;
This is the "abstract" base type for Imager's fill types.
Unless you're implementing a new fill type you'll typically treat this
as an opaque type.
=cut
*/
typedef struct i_fill_tag
{
/* called for 8-bit/sample image (and maybe lower) */
/* this may be NULL, if so call fill_with_fcolor */
i_fill_with_color_f f_fill_with_color;
/* called for other sample sizes */
/* this must be non-NULL */
i_fill_with_fcolor_f f_fill_with_fcolor;
/* called if non-NULL to release any extra resources */
i_fill_destroy_f destroy;
/* if non-zero the caller will fill data with the original data
from the image */
i_fill_combine_f combine;
i_fill_combinef_f combinef;
} i_fill_t;
typedef enum {
ic_none,
ic_normal,
ic_multiply,
ic_dissolve,
ic_add,
ic_subtract,
ic_diff,
ic_lighten,
ic_darken,
ic_hue,
ic_sat,
ic_value,
ic_color
} i_combine_t;
/*
=item i_mutex_t
X<i_mutex>
=category mutex
=synopsis i_mutex_t mutex;
Opaque type for Imager's mutex API.
=cut
*/
typedef struct i_mutex_tag *i_mutex_t;
/*
describes an axis of a MM font.
Modelled on FT2's FT_MM_Axis.
It would be nice to have a default entry too, but FT2
doesn't support it.
*/
typedef struct i_font_mm_axis_tag {
char const *name;
int minimum;
int maximum;
} i_font_mm_axis;
#define IM_FONT_MM_MAX_AXES 4
/*
multiple master information for a font, if any
modelled on FT2's FT_Multi_Master.
*/
typedef struct i_font_mm_tag {
int num_axis;
int num_designs; /* provided but not necessarily useful */
i_font_mm_axis axis[IM_FONT_MM_MAX_AXES];
} i_font_mm;
#ifdef HAVE_LIBTT
struct TT_Fonthandle_;
typedef struct TT_Fonthandle_ TT_Fonthandle;
#endif
/* transparency handling for quantized output */
typedef enum i_transp_tag {
tr_none, /* ignore any alpha channel */
tr_threshold, /* threshold the transparency - uses tr_threshold */
tr_errdiff, /* error diffusion */
tr_ordered /* an ordered dither */
} i_transp;
/* controls how we build the colour map */
typedef enum i_make_colors_tag {
mc_none, /* user supplied colour map only */
mc_web_map, /* Use the 216 colour web colour map */
mc_addi, /* Addi's algorithm */
mc_median_cut, /* median cut - similar to giflib, hopefully */
mc_mono, /* fixed mono color map */
mc_gray, /* 256 gray map */
mc_gray4, /* four step gray map */
mc_gray16, /* sixteen step gray map */
mc_mask = 0xFF /* (mask for generator) */
} i_make_colors;
/* controls how we translate the colours */
typedef enum i_translate_tag {
pt_giflib, /* get gif lib to do it (ignores make_colours) */
pt_closest, /* just use the closest match within the hashbox */
pt_perturb, /* randomly perturb the data - uses perturb_size*/
pt_errdiff /* error diffusion dither - uses errdiff */
} i_translate;
/* Which error diffusion map to use */
typedef enum i_errdiff_tag {
ed_floyd, /* floyd-steinberg */
ed_jarvis, /* Jarvis, Judice and Ninke */
ed_stucki, /* Stucki */
ed_custom, /* the map found in ed_map|width|height|orig */
ed_mask = 0xFF, /* mask to get the map */
ed_bidir = 0x100 /* change direction for each row */
} i_errdiff;
/* which ordered dither map to use
currently only available for transparency
I don't know of a way to do ordered dither of an image against some
general palette
*/
typedef enum i_ord_dith_tag
{
od_random, /* sort of random */
od_dot8, /* large dot */
od_dot4,
od_hline,
od_vline,
od_slashline, /* / line dither */
od_backline, /* \ line dither */
od_tiny, /* small checkerbox */
od_custom /* custom 8x8 map */
} i_ord_dith;
/* passed into i_writegif_gen() to control quantization */
typedef struct i_quantize_tag {
int version;
/* how to handle transparency */
i_transp transp;
/* the threshold at which to make pixels opaque */
int tr_threshold;
i_errdiff tr_errdiff;
i_ord_dith tr_orddith;
unsigned char tr_custom[64];
/* how to make the colour map */
i_make_colors make_colors;
/* any existing colours
mc_existing is an existing colour table
mc_count is the number of existing colours
mc_size is the total size of the array that mc_existing points
at - this must be at least 256
*/
i_color *mc_colors;
int mc_size;
int mc_count;
/* how we translate the colours */
i_translate translate;
/* the error diffusion map to use if translate is mc_errdiff */
i_errdiff errdiff;
/* the following define the error diffusion values to use if
errdiff is ed_custom. ed_orig is the column on the top row that
represents the current
*/
int *ed_map;
int ed_width, ed_height, ed_orig;
/* the amount of perturbation to use for translate is mc_perturb */
int perturb;
/* version 2 members after here */
} i_quantize;
/* distance measures used by some filters */
enum {
i_dmeasure_euclidean = 0,
i_dmeasure_euclidean_squared = 1,
i_dmeasure_manhatten = 2,
i_dmeasure_limit = 2,
};
#include "iolayert.h"
/* error message information returned by im_errors() */
typedef struct {
char *msg;
int code;
} i_errmsg;
typedef struct i_render_tag i_render;
#ifdef IMAGER_FORMAT_ATTR
#define I_FORMAT_ATTR(format_index, va_index) \
__attribute ((format (printf, format_index, va_index)))
#else
#define I_FORMAT_ATTR(format_index, va_index)
#endif
#ifdef _MSC_VER
# ifndef vsnprintf
# define vsnprintf _vsnprintf
# endif
# ifndef snprintf
# define snprintf _snprintf
# endif
#endif
/*
=item i_DF
=category Data Types
=synopsis printf("left %" i_DF "\n", i_DFc(x));
=order 95
This is a constant string that can be used with functions like
printf() to format i_img_dim values after they're been cast with i_DFc().
Does not include the leading C<%>.
=cut
=item i_DFc
=category Data Types
=order 95
Cast an C<i_img_dim> value to a type for use with the i_DF format
string.
=cut
=item i_DFp
=category Data Types
=synopsis printf("point (" i_DFp ")\n", i_DFcp(x, y));
=order 95
Format a pair of C<i_img_dim> values. This format string I<does>
include the leading C<%>.
=cut
=item i_DFcp
=category Data Types
=order 95
Casts two C<i_img_dim> values for use with the i_DF (or i_DFp) format.
=cut
*/
#define i_DFc(x) ((i_dim_format_t)(x))
#define i_DFcp(x, y) i_DFc(x), i_DFc(y)
#define i_DFp "%" i_DF ", %" i_DF
#endif
|