home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gsptype1.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  5.4 KB  |  148 lines
  1. /* Copyright (C) 1997, 1998, 1999 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gsptype1.h,v 1.2 2000/09/19 19:00:31 lpd Exp $ */
  20. /* Client interface to PatternType 1 Patterns */
  21.  
  22. #ifndef gsptype1_INCLUDED
  23. #  define gsptype1_INCLUDED
  24.  
  25. #include "gspcolor.h"
  26. #include "gxbitmap.h"
  27.  
  28. /* ---------------- Types and structures ---------------- */
  29.  
  30. /* PatternType 1 template */
  31.  
  32. typedef struct gs_pattern1_template_s {
  33.     /*
  34.      * The common template must come first.  It defines type, uid,
  35.      * PatternType, and client_data.
  36.      */
  37.     gs_pattern_template_common;
  38.     int PaintType;
  39.     int TilingType;
  40.     gs_rect BBox;
  41.     float XStep;
  42.     float YStep;
  43.     int (*PaintProc) (P2(const gs_client_color *, gs_state *));
  44. } gs_pattern1_template_t;
  45.  
  46. #define private_st_pattern1_template() /* in gspcolor.c */\
  47.   gs_private_st_suffix_add0(st_pattern1_template,\
  48.     gs_pattern1_template_t, "gs_pattern1_template_t",\
  49.     pattern1_template_enum_ptrs, pattern1_template_reloc_ptrs,\
  50.     st_pattern_template)
  51. #define st_pattern1_template_max_ptrs st_pattern_template_max_ptrs
  52.  
  53. /* Backward compatibility */
  54. typedef gs_pattern1_template_t gs_client_pattern;
  55.  
  56. /* ---------------- Procedures ---------------- */
  57.  
  58. /*
  59.  * Construct a PatternType 1 Pattern color space.  If the base space is
  60.  * NULL, the color space can only be used with colored patterns.
  61.  */
  62. extern int gs_cspace_build_Pattern1(P3(
  63.                        gs_color_space ** ppcspace,
  64.                        const gs_color_space * pbase_cspace,
  65.                        gs_memory_t * pmem
  66.                        ));
  67.  
  68. /* Initialize a PatternType 1 pattern. */
  69. void gs_pattern1_init(P1(gs_pattern1_template_t *));
  70.  
  71. /* Backward compatibility */
  72. #define gs_client_pattern_init(ppat) gs_pattern1_init(ppat)
  73.  
  74. /*
  75.  * Define versions of make_pattern and get_pattern specifically for
  76.  * PatternType 1 patterns.
  77.  *
  78.  * The gs_memory_t argument for gs_makepattern may be NULL, meaning use the
  79.  * same allocator as for the gs_state argument.  Note that gs_makepattern
  80.  * uses rc_alloc_struct_1 to allocate pattern instances.
  81.  */
  82. int gs_makepattern(P5(gs_client_color *, const gs_client_pattern *,
  83.               const gs_matrix *, gs_state *, gs_memory_t *));
  84. const gs_client_pattern *gs_getpattern(P1(const gs_client_color *));
  85.  
  86. /*
  87.  * Make a pattern from a bitmap or pixmap. The pattern may be colored or
  88.  * uncolored, as determined by the mask operand. This code is intended
  89.  * primarily for use by PCL.
  90.  *
  91.  * By convention, if pmat is null the identity matrix will be used, and if
  92.  * id is no_UniqueID the code will assign a unique id. Thes conventions allow
  93.  * gs_makebitmappattern to be implemented as a macro. Also, if mem is a
  94.  * null pointer, the memory allocator for the graphic state is used.
  95.  *
  96.  * For mask patterns, pix_depth must be 1, while pcspace and white_index are
  97.  * ignored; the polarity of the mask considers ones part of the mask, while
  98.  * zeros are not. For colored patterns pspace must point to an indexed color
  99.  * space and the image must used the canoncial Decode array for this color
  100.  * space. For both cases no interpolation or adjustment is provided.
  101.  *
  102.  * For backwards compatibility, if mask is false, pcspace is null, and
  103.  * pix_depth is 1, the pattern will be rendered with a color space that maps
  104.  * 0 to white and 1 to black.
  105.  *
  106.  * The image must be described by a gx_tile_bitmap structure (this is actually
  107.  * somewhat awkward, but the only option available at the moment), and the
  108.  * pattern step will exactly match the image size. The client need not maintain
  109.  * the gx_tile_bitmap structure after the completion of this call, but the
  110.  * raw image data itself must be kept until the pattern is no longer needed.
  111.  *
  112.  * NB: For proper handling of transparency in PCL, there must be only a single
  113.  *     white value accessed by the pattern image. If the palette contains
  114.  *     multiple white values, the PCL component must remap the image data to
  115.  *     ensure that all white indices are mapped to the single, given white
  116.  *     index.
  117.  */
  118. extern int gs_makepixmappattern(P9(
  119.                    gs_client_color * pcc,
  120.                    const gs_depth_bitmap * pbitmap,
  121.                    bool mask,
  122.                    const gs_matrix * pmat,
  123.                    long id,
  124.                    const gs_color_space * pcspace,
  125.                    uint white_index,
  126.                    gs_state * pgs,
  127.                    gs_memory_t * mem
  128.                    ));
  129.  
  130. /*
  131.  *  Backwards compatibility feature, to allow the existing
  132.  *  gs_makebitmappattern operation to still function.
  133.  */
  134. extern int gs_makebitmappattern_xform(P7(
  135.                      gs_client_color * pcc,
  136.                      const gx_tile_bitmap * ptile,
  137.                      bool mask,
  138.                      const gs_matrix * pmat,
  139.                      long id,
  140.                      gs_state * pgs,
  141.                      gs_memory_t * mem
  142.                      ));
  143.  
  144. #define gs_makebitmappattern(pcc, tile, mask, pgs, mem)                 \
  145.     gs_makebitmappattern_xform(pcc, tile, mask, 0, no_UniqueID, pgs, mem)
  146.  
  147. #endif /* gsptype1_INCLUDED */
  148.