home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / sharewar / dos / program / gs300sr1 / gs300sr1.exe / GXDCOLOR.H < prev    next >
C/C++ Source or Header  |  1994-07-27  |  9KB  |  233 lines
  1. /* Copyright (C) 1993 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gxdcolor.h */
  20. /* Device color representation for Ghostscript */
  21.  
  22. #ifndef gxdcolor_INCLUDED
  23. #  define gxdcolor_INCLUDED
  24.  
  25. #include "gsrefct.h"
  26. #include "gxbitmap.h"
  27. #include "gsstruct.h"            /* for extern_st */
  28.  
  29. /* Define the type for device color indices. */
  30. typedef unsigned long gx_color_index;
  31. /* Define the 'transparent' color index. */
  32. #define gx_no_color_index_value (-1)    /* no cast -> can be used in #if */
  33. #define gx_no_color_index ((gx_color_index)gx_no_color_index_value)
  34.  
  35. /*
  36.  * Device colors are 'objects'.  Currently they only have two procedures,
  37.  * but they might have more in the future.
  38.  */
  39.  
  40. #ifndef gx_device_color_DEFINED
  41. #  define gx_device_color_DEFINED
  42. typedef struct gx_device_color_s gx_device_color;
  43. #endif
  44.  
  45. #ifndef gx_device_DEFINED
  46. #  define gx_device_DEFINED
  47. typedef struct gx_device_s gx_device;
  48. #endif
  49.  
  50. typedef struct gx_device_color_procs_s {
  51.  
  52.     /* If necessary and possible, load the halftone cache */
  53.     /* with the rendering of this color. */
  54.  
  55. #define dev_color_proc_load(proc)\
  56.   int proc(P2(gx_device_color *pdevc, const gs_state *pgs))
  57.     dev_color_proc_load((*load));
  58.  
  59.     /* Fill a rectangle with the color.  We only pass the gs_state */
  60.     /* because it supplies the halftone phase; eventually */
  61.     /* we should incorporate the state in the cached bits. */
  62.     /* We pass the device so that pattern fills can substitute */
  63.     /* a tiled mask clipping device. */
  64.  
  65. #define dev_color_proc_fill_rectangle(proc)\
  66.   int proc(P7(const gx_device_color *pdevc, int x, int y, int w, int h,\
  67.     gx_device *dev, const gs_state *pgs))
  68.     dev_color_proc_fill_rectangle((*fill_rectangle));
  69.  
  70. } gx_device_color_procs;
  71.  
  72. /*
  73.  * A device color consists of a base color and an optional (tiled) mask.
  74.  * The base color may be a pure color, a binary halftone, or a colored
  75.  * bitmap (color halftone or colored Pattern).  The mask is used for
  76.  * both colored and uncolored Patterns.
  77.  *
  78.  * The device color in the graphics state is computed from client color
  79.  * specifications, and kept current through changes in transfer function
  80.  * or device.  (gx_set_dev_color sets the device color if needed.)
  81.  * For binary halftones (and eventually colored halftones as well),
  82.  * the bitmaps are only cached, so internal clients (the painting operators)
  83.  * must call gx_color_load to ensure that the bitmap is available.
  84.  * Device color elements set by gx_color_load are marked with @ below.
  85.  *
  86.  * Base colors are represented as follows:
  87.  *
  88.  *    Pure color (gx_dc_pure):
  89.  *        colors.pure = the color;
  90.  *    Binary halftone (gx_dc_ht_binary):
  91.  *        colors.binary.color[0] = the color for 0s (darker);
  92.  *        colors.binary.color[1] = the color for 1s (lighter);
  93.  *        colors.binary.b_level = the number of pixels to lighten,
  94.  *          0 < halftone_level < P, the number of pixels in the tile;
  95.  *    @    colors.binary.b_tile points to an entry in the binary
  96.  *          tile cache.
  97.  *    Colored halftone (gx_dc_ht_colored):
  98.  *        colors.colored.c_level[0..N-1] = the halftone levels,
  99.  *          like b_level;
  100.  *        colors.colored.c_base[0..N-1] = the base colors;
  101.  *          N=3 for RGB devices, 4 for CMYK devices;
  102.  *          0 <= c_level[i] < P;
  103.  *          0 <= c_base[i] <= dither_rgb;
  104.  *        colors.colored.alpha = the opacity.
  105.  *    Colored pattern (gx_dc_ht_pattern):
  106.  *        (id is also set, see below)
  107.  *    @    colors.pattern.p_tile points to a gx_color_tile in
  108.  *          the pattern cache.
  109.  * The id and mask elements of a device color are only used for patterns:
  110.  *    Non-pattern:
  111.  *        id and mask are unused.
  112.  *    Pattern:
  113.  *        id gives the ID of the pattern (and its mask);
  114.  *    @    mask points to the mask member of a gx_color_tile in
  115.  *          the pattern cache.
  116.  * For masked colors, gx_set_dev_color replaces the type with a different
  117.  * type that applies the mask when painting.  These types are not defined
  118.  * here, because they are only used in Level 2.
  119.  */
  120. typedef struct gx_color_tile_s gx_color_tile;
  121.  
  122. /* A device color type is just a pointer to the procedures. */
  123. typedef const gx_device_color_procs _ds *gx_device_color_type;
  124.  
  125. struct gx_device_color_s {
  126.     /* See the comment above for descriptions of the members. */
  127.     /* We use b_, c_, and p_ member names because */
  128.     /* some old compilers don't allow the same name to be used for */
  129.     /* two different structure members even when it's unambiguous. */
  130.     union _c {
  131.         gx_color_index pure;
  132.         struct _bin {
  133.             gx_color_index color[2];
  134.             uint b_level;
  135.             gx_tile_bitmap *b_tile;
  136.         } binary;
  137.         struct _col {
  138.             byte c_base[4];
  139.             uint c_level[4];
  140.             ushort /*gx_color_value*/ alpha;
  141.         } colored;
  142.         struct _pat {
  143.             gx_color_tile *p_tile;
  144.         } /*(colored)*/ pattern;
  145.     } colors;
  146.     gx_bitmap_id id;
  147.     gx_tile_bitmap *mask;
  148.     /* We put the type last to preserve word alignment */
  149.     /* on platforms with short ints. */
  150.     gx_device_color_type type;
  151. };
  152. extern_st(st_device_color);
  153. #define public_st_device_color() /* in gxcmap.c */\
  154.   gs_public_st_composite(st_device_color, gx_device_color, "gx_device_color",\
  155.     device_color_enum_ptrs, device_color_reloc_ptrs)
  156. #define st_device_color_max_ptrs 2
  157.  
  158. /* Define the standard device color types. */
  159. extern const gx_device_color_procs
  160.     gx_dc_none, gx_dc_pure, gx_dc_ht_binary,
  161.     gx_dc_ht_colored;
  162. /* We don't declare gx_dc_pattern here, so as not to create */
  163. /* a spurious external reference in Level 1 systems. */
  164. #define color_is_set(pdevc)\
  165.   ((pdevc)->type != &gx_dc_none)
  166. #define color_unset(pdevc)\
  167.   ((pdevc)->type = &gx_dc_none)
  168. #define color_is_pure(pdevc)\
  169.   ((pdevc)->type == &gx_dc_pure)
  170. #define color_set_pure(pdevc, color)\
  171.   ((pdevc)->colors.pure = (color),\
  172.    (pdevc)->type = &gx_dc_pure)
  173. #define color_set_binary_halftone(pdevc, color1, color2, level)\
  174.   ((pdevc)->colors.binary.color[0] = (color1),\
  175.    (pdevc)->colors.binary.color[1] = (color2),\
  176.    (pdevc)->colors.binary.b_level = (level),\
  177.    (pdevc)->type = &gx_dc_ht_binary)
  178. #define _color_set_c(pdevc, i, b, l)\
  179.   ((pdevc)->colors.colored.c_base[i] = (b),\
  180.    (pdevc)->colors.colored.c_level[i] = (l))
  181. #define color_set_rgb_halftone(pdevc, br, lr, bg, lg, bb, lb, a)\
  182.   (_color_set_c(pdevc, 0, br, lr),\
  183.    _color_set_c(pdevc, 1, bg, lg),\
  184.    _color_set_c(pdevc, 2, bb, lb),\
  185.    (pdevc)->colors.colored.alpha = (a),\
  186.    (pdevc)->type = &gx_dc_ht_colored)
  187. #define color_set_cmyk_halftone(pdevc, bc, lc, bm, lm, by, ly, bk, lk)\
  188.   (_color_set_c(pdevc, 0, bc, lc),\
  189.    _color_set_c(pdevc, 1, bm, lm),\
  190.    _color_set_c(pdevc, 2, by, ly),\
  191.    _color_set_c(pdevc, 3, bk, lk),\
  192.    (pdevc)->colors.colored.alpha = max_ushort,\
  193.    (pdevc)->type = &gx_dc_ht_colored)
  194. #define color_set_pattern(pdevc, pt)\
  195.  ((pdevc)->colors.pattern.p_tile = (pt),\
  196.   (pdevc)->type = &gx_dc_pattern)
  197.  
  198. /* Define the implementation of standard device color types. */
  199. /* These are exported for the implementation of Pattern colors. */
  200. dev_color_proc_load(gx_dc_no_load);
  201. dev_color_proc_fill_rectangle(gx_dc_no_fill_rectangle);
  202. dev_color_proc_load(gx_dc_pure_load);
  203. dev_color_proc_fill_rectangle(gx_dc_pure_fill_rectangle);
  204. dev_color_proc_load(gx_dc_ht_binary_load);
  205. dev_color_proc_fill_rectangle(gx_dc_ht_binary_fill_rectangle);
  206. dev_color_proc_load(gx_dc_ht_colored_load);
  207. dev_color_proc_fill_rectangle(gx_dc_ht_colored_fill_rectangle);
  208.  
  209. /* Set up black for writing into a mask cache (e.g., the character cache). */
  210. void gx_set_black(P1(gs_state *pgs));
  211.  
  212. /* Remap the color if necessary. */
  213. int gx_remap_color(P1(gs_state *));
  214. #define gx_set_dev_color(pgs)\
  215.   if ( !color_is_set((pgs)->dev_color) )\
  216.    { int code_dc = gx_remap_color(pgs);\
  217.      if ( code_dc != 0 ) return code_dc;\
  218.    }
  219.  
  220. /* Indicate that the device color needs remapping. */
  221. #define gx_unset_dev_color(pgs)\
  222.   color_unset((pgs)->dev_color)
  223.  
  224. /* Load the halftone cache in preparation for drawing. */
  225. #define gx_color_load(pdevc, pgs)\
  226.   (*(pdevc)->type->load)(pdevc, pgs)
  227.  
  228. /* Fill a rectangle with a color. */
  229. #define gx_fill_rectangle(x, y, w, h, pdevc, pgs)\
  230.   (*(pdevc)->type->fill_rectangle)(pdevc, x, y, w, h, pgs->device, pgs)
  231.  
  232. #endif                    /* gxdcolor_INCLUDED */
  233.