7.11 Raster functions

void v_get_pixel (int16_t handle, int16_t x, int16_t y,
                  int16_t *pel, int16_t *index)
{
   ptsin[0]  = x;
   ptsin[1]  = y;
   contrl[0] = 105;
   contrl[1] = 1;
   contrl[3] = 0;
   contrl[6] = handle;

   vdi ();

   *pel   = intout[0];
   *index = intout[1];
}

int32_t vq_hilite_color( int16_t handle,
                         COLOR_ENTRY *hilite_color )
{
   contrl[0] = 209;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[5] = 0;
   contrl[6] = handle;

   vdi ();

   hilite_color = intout[2..5];

   return ( intout[0..1] );
}

int32_t vq_max_color( int16_t handle, COLOR_ENTRY *max_color )
{
   contrl[0] = 209;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[5] = 2;
   contrl[6] = handle;

   vdi ();

   max_color = intout[2..5];
   return ( intout[0..1] );
}

int32_t vq_min_color( int16_t handle, COLOR_ENTRY *min_color )
{
   contrl[0] = 209;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[5] = 1;
   contrl[6] = handle;

   vdi ();

   min_color = intout[2..5];
   return ( intout[0..1] );
}

int32_t vq_weight_color( int16_t handle,
                         COLOR_ENTRY *weight_color )
{
   contrl[0] = 209;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[5] = 3;
   contrl[6] = handle;

   vdi ();

   weight_color = intout[2..5];
   return ( intout[0..1] );
}

int16_t vr_clip_rects32_by_dst ( int16_t handle,
                                 RECT32 *dst_clip_rect,
                                 RECT32 *src_rect,
                                 RECT16 *dst_rect,
                                 RECT32 *clipped_src_rect,
                                 RECT32 *clipped_dst_rect )
{
   ptsin[0..7] = dst_clip_rect;
   ptsin[8..15] = src_rect;
   ptsin[16..23] = dst_rect;

   contrl[0] = 171;
   contrl[1] = 12;
   contrl[3] = 0;
   contrl[5] = 2;
   contrl[6] = handle;

   vdi ();

   clipped_src_rect = ptsout[0..7];
   clipped_dst_rect = ptsout[8..15];

   return ( intout[0] );
}

int16_t vr_clip_rects32_by_src ( int16_t handle,
                                 RECT32 *src_clip_rect,
                                 RECT32 *src_rect,
                                 RECT16 *dst_rect,
                                 RECT32 *clipped_src_rect,
                                 RECT32 *clipped_dst_rect )
{
   ptsin[0..7] = src_clip_rect;
   ptsin[8..15] = src_rect;
   ptsin[16..23] = dst_rect;

   contrl[0] = 171;
   contrl[1] = 12;
   contrl[3] = 0;
   contrl[5] = 3;
   contrl[6] = handle;

   vdi ();

   clipped_src_rect = ptsout[0..7];
   clipped_dst_rect = ptsout[8..15];

   return ( intout[0] );
}

int16_t vr_clip_rects_by_dst ( int16_t handle,
                               RECT16 *dst_clip_rect,
                               RECT16 *src_rect,
                               RECT16 *dst_rect,
                               RECT16 *clipped_src_rect,
                               RECT16 *clipped_dst_rect )
{
   ptsin[0..3] = dst_clip_rect;
   ptsin[4..7] = src_rect;
   ptsin[8..11] = dst_rect;

   contrl[0] = 171;
   contrl[1] = 6;
   contrl[3] = 0;
   contrl[5] = 0;
   contrl[6] = handle;

   vdi ();

   clipped_src_rect = ptsout[0..3];
   clipped_dst_rect = ptsout[4..7];

   return ( intout[0] );
}

int16_t vr_clip_rects_by_src ( int16_t handle,
                               RECT16 *src_clip_rect,
                               RECT16 *src_rect,
                               RECT16 *dst_rect,
                               RECT16 *clipped_src_rect,
                               RECT16 *clipped_dst_rect )
{
   ptsin[0..3] = src_clip_rect;
   ptsin[4..7] = src_rect;
   ptsin[8..11] = dst_rect;

   contrl[0] = 171;
   contrl[1] = 6;
   contrl[3] = 0;
   contrl[5] = 1;
   contrl[6] = handle;

   vdi ();

   clipped_src_rect = ptsout[0..3];
   clipped_dst_rect = ptsout[4..7];

   return ( intout[0] );
}

/* Logical transfer modes */
/* dst = src; */
#define T_LOGIC_COPY         0

/* dst = src OR dst; */
#define T_LOGIC_OR           1

/* dst = src XOR dst; */
#define T_LOGIC_XOR          2

/* dst = src AND dst; */
#define T_LOGIC_AND          3

/* dst = ( NOT src ); */
#define T_LOGIC_NOT_COPY     4

/* dst = ( NOT src ) OR dst; */
#define T_LOGIC_NOT_OR       5

/* dst = ( NOT src ) XOR dst; */
#define T_LOGIC_NOT_XOR      6

/* dst = ( NOT src ) AND dst; */
#define T_LOGIC_NOT_AND      7

/* Drawing modes */
/* dst = src; */
#define T_REPLACE            32

/* if ( src != bg_col ) dst = src; */
#define T_TRANSPARENT        33

/* if ( src != bg_col )            */
/* {                               */
/*    if ( dst == bg_col )         */
/*       dst = hilite_col;         */
/*    else if ( dst == hilite_col )*/
/*       dst = bg_col;             */
/* }                               */
#define T_HILITE             34

/* if ( src == bg_col ) dst = src; */
#define T_REVERS_TRANSPARENT 35

/* Arithmetic transfer modes */
/* Mix source and destination color  */
/* rgb = RGB( src ) * weighting );   */
/* rgb += RGB( dst ) * (1-weighting));*/
/* dst = PIXELWERT( rgb );           */
#define T_BLEND     64

/* Add source and destination color  */
/* rgb = RGB( src ) + RGB( dst )     */
/* if ( rgb > max_rgb )              */
/*    rgb = max_rgb;                 */
/* dst = PIXELWERT( rgb );           */
#define T_ADD       65

/* Add source and destination color, */
/* do not catch overflows            */
/* rgb = RGB( src ) + RGB( dst )     */
/* dst = PIXELWERT( rgb );           */
#define T_ADD_OVER  66

/* Subtract source from destination  */
/* color                             */
/* rgb = RGB( dst ) - RGB( src )     */
/* if ( rgb < min_rgb )              */
/*    rgb = min_rgb;                 */
/* dst = PIXELWERT( rgb );           */
#define T_SUB       67

/* Maximum RGB components            */
/* rgb = MAX(RGB( dst ), RGB( src )) */
/* dst = PIXELWERT( rgb );           */
#define T_MAX       69

/* Subtract source from destination  */
/* color, do not catch overflows     */
/* rgb = RGB( dst ) - RGB( src )     */
/* dst = PIXELWERT( rgb );           */
#define T_SUB_OVER  70

/* Minimum RGB components            */
/* rgb = MIN(RGB( dst ), RGB( src )) */
/* dst = PIXELWERT( rgb );           */
#define T_MIN       71

#define T_COLORIZE     16    /* Colourize source   */
#define T_DITHER_MODE  128   /* Dither source data */

• If a logical mode is called with 'T_COLORIZE', the type of colourizing applied depends on the mode:
   

  T_LOGIC_COPY
  
  For all set bits in the colour value depict the
  background colour and for all cleared bits the
  foreground colour:
  rgb = (( NOT RGB( src )) & RGB( fg_col )) OR
        ( RGB( src ) AND RGB( bg_col ));
  dst = PIXELWERT( rgb );
  
  T_LOGIC_NOT_COPY
  
  For all set bits in the colour value depict the
  foreground colour and for all cleared bits the
  background colour:
  rgb = ( RGB( src ) & RGB( fg_col )) OR
        ((( NOT RGB( src )) AND RGB( bg_col ));
  dst = PIXELWERT( rgb );
  
  T_LOGIC_OR
  
  Everywhere that source bits are set, ( src AND
  fg_col ) will be depicted in the destination:
  dst = ( src AND fg_col ) OR (( NOT src ) AND dst );
  
  T_LOGIC_NOT_OR
  
  Everywhere that source bits are cleared,
  ((NOT src ) AND fg_col ) will be depicted in
  the destination:
  dst = (( NOT src ) AND fg_col ) OR ( src AND dst );
  
  T_LOGIC_XOR
  T_LOGIC_NOT_XOR
  
  The XOR combination ignores the colourizing.
  
  T_LOGIC_AND
  
  Everywhere that source bits are cleared,
  (( NOT src ) AND bg_col ) will be depicted in the
  destination:
  dst = ((NOT src ) AND bg_col ) OR ( src AND dst );
  
  T_LOGIC_NOT_AND
  
  Everywhere that source bits are set, ( src AND
  bg_col ) will be depicted in the destination:
  dst = ( src AND bg_col ) OR ((NOT src ) AND dst );
  

• For the modes T_REPLACE, T_TRANSPARENT, T_HILITE and T_REVERS_TRANSPARENT the colourizing does not act in a binary manner on the colour or pixel values, but the colour values are scaled instead. The following sample shows how a colour value is colourized; 'bg_col', 'fg_col', 'src' and 'dst' are RGB colour values (between 0 and 65535):
   

  red_range = bg_col.red - fg_col.red;
  green_range = bg_col.green - fg_col.green;
  blue_range = bg_col.blue - fg_col.blue;
  
  dst.red = fg_col.red + ( src_color.red * red_range / 65535 );
  dst.green = fg_col.green + ( src_color.green * green_range / 65535 );
  dst.blue = fg_col.blue + ( src_color.blue * blue_range / 65535 );
  

  
  Note: At present, colourizing in the modes T_REPLACE, T_TRANSPARENT, T_HILITE and T_REVERS_TRANSPARENT is suppored only for source bitmaps with up to 256 colours. For source bitmaps with 16- or 32-bit depths there is at present no support for colourizing in these modes.
   

• The arithmetic transfer modes do not support any colourizing.
   

• If the source does not have a colour table (0L), the colour table of the device will be used if this has the same bit-depth. If this is not the case, the system colour table for the bit-depth of the source will be used.
   

• If the destination does not have an (inverse) colour table, the (inverse) colour table of the device will be used if this has the same bit-depth. If this is not the case, the system color table for the bit depth of the destination will be used, and an additional inverse colour table will be built up internally for the call. This means that is is imperative that destination bitmaps that have no inverse colour table have the same bit-depth as the device belonging to the VDI handle.
   

/* Constants for pixel formats */
/* Pixel consists of one used component:
   Color index */
#define  PX_1COMP    0x01000000L
/* Pixel consists of three used components,
   e.g. RGB */
#define  PX_3COMP    0x03000000L
/* Pixel consists of four used components, e.g.
   CMYK */
#define  PX_4COMP    0x04000000L
/* Pixel will be output in reverse byte order */
#define  PX_REVERSED 0x00800000L
/* Unused bits lie before the used ones
   (viewed in Motorola format) */
#define  PX_xFIRST   0x00400000L
/* K lies before CMY (viewed in Motorola format) */
#define  PX_kFIRST   0x00200000L
/* Alpha channel lies before the color bits
   (viewed in Motorola format) */
#define  PX_aFIRST   0x00100000L
/* Bits are stored sequentially */
#define  PX_PACKED   0x00020000L
/* Bits are distributed over several planes
   (order: 0, 1, ..., n) */
#define  PX_PLANES   0x00010000L
/* Bits are distributed over several words
   (order: 0, 1, ..., n) */
#define  PX_IPLANES  0x00000000L
/* 1 bit of the pixel is used */
#define  PX_USES1    0x00000100L
/* 2 bits of the pixel are used */
#define  PX_USES2    0x00000200L
/* 3 bits of the pixel are used */
#define  PX_USES3    0x00000300L
/* 4 bits of the pixel are used */
#define  PX_USES4    0x00000400L
/* 8 bits of the pixel are used */
#define  PX_USES8    0x00000800L
/* 15 bits of the pixel are used */
#define  PX_USES15   0x00000f00L
/* 16 bits of the pixel are used */
#define  PX_USES16   0x00001000L
/* 24 bits of the pixel are used */
#define  PX_USES24   0x00001800L
/* 32 bits of the pixel are used */
#define  PX_USES32   0x00002000L
/* 48 bits of the pixel are used */
#define  PX_USES48   0x00003000L
/* Pixel consists of 1 bit */
#define  PX_1BIT     0x00000001L
/* Pixel consists of 2 bits */
#define  PX_2BIT     0x00000002L
/* Pixel consists of 3 bits */
#define  PX_3BIT     0x00000003L
/* Pixel consists of 4 bits */
#define  PX_4BIT     0x00000004L
/* Pixel consists of 8 bits */
#define  PX_8BIT     0x00000008L
/* Pixel consists of 16 bits */
#define  PX_16BIT    0x00000010L
/* Pixel consists of 24 bits */
#define  PX_24BIT    0x00000018L
/* Pixel consists of 32 bits */
#define  PX_32BIT    0x00000020L
/* Pixel consists of 48 bits */
#define  PX_48BIT    0x00000030L
/* Mask for number of pixel components */
#define  PX_CMPNTS   0x0f000000L
/* Mask for various flags */
#define  PX_FLAGS    0x00f00000L
/* Mask for pixel format */
#define  PX_PACKING  0x00030000L
/* Mask for number of used bits */
#define  PX_USED     0x00003f00L
/* Mask for number of bits per pixel */
#define  PX_BITS     0x0000003fL

/* Pixel formats for ATARI graphics */
#define  PX_ATARI1  ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_ATARI2  ( PX_IPLANES + PX_1COMP + PX_USES2 + PX_2BIT )
#define  PX_ATARI4  ( PX_IPLANES + PX_1COMP + PX_USES4 + PX_4BIT )
#define  PX_ATARI8  ( PX_IPLANES + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_FALCON15( PX_PACKED + PX_3COMP + PX_USES16 + PX_16BIT )

/* Pixel formats for Mac */
#define  PX_MAC1    ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_MAC4    ( PX_PACKED + PX_1COMP + PX_USES4 + PX_4BIT )
#define  PX_MAC8    ( PX_PACKED + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_MAC15   ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES15 + PX_16BIT )
#define  PX_MAC32   ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )

/* Pixel formats for graphics cards */
#define  PX_VGA1    ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_VGA4    ( PX_PLANES + PX_1COMP + PX_USES4 + PX_4BIT )
#define  PX_VGA8    ( PX_PACKED + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_VGA15   ( PX_REVERSED + PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES15 + PX_16BIT )
#define  PX_VGA16   ( PX_REVERSED + PX_PACKED + PX_3COMP + PX_USES16 + PX_16BIT )
#define  PX_VGA24   ( PX_REVERSED + PX_PACKED + PX_3COMP + PX_USES24 + PX_24BIT )
#define  PX_VGA32   ( PX_REVERSED + PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )
#define  PX_MATRIX16( PX_PACKED + PX_3COMP + PX_USES16 + PX_16BIT )
#define  PX_NOVA32  ( PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )

/* Pixel formats for printers */
#define  PX_PRN1    ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_PRN8    ( PX_PACKED + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_PRN32   ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )

/* Preferred (fast) pixel formats for bitmaps */
#define  PX_PREF1   ( PX_PACKED + PX_1COMP + PX_USES1 + PX_1BIT )
#define  PX_PREF2   ( PX_PACKED + PX_1COMP + PX_USES2 + PX_2BIT )
#define  PX_PREF4   ( PX_PACKED + PX_1COMP + PX_USES4 + PX_4BIT )
#define  PX_PREF8   ( PX_PACKED + PX_1COMP + PX_USES8 + PX_8BIT )
#define  PX_PREF15  ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES15 + PX_16BIT )
#define  PX_PREF32  ( PX_xFIRST + PX_PACKED + PX_3COMP + PX_USES24 + PX_32BIT )

void vr_transfer_bits( int16_t handle, GCBITMAP *src_bm,
                       GCBITMAP *dst_bm, RECT16 *src_rect,
                       RECT16 *dst_rect, int16_t mode )
{
   intin[o] = mode;
   intin[1] = 0;
   intin[2] = 0;
   intin[3] = 0;

   ptsin[0..3] = src_rect;
   ptsin[4..7] = dst_rect;

   contrl[0] = 170;
   contrl[1] = 4;
   contrl[3] = 4;
   contrl[5] = 0;
   contrl[6] = handle;
   contrl[7..8] = src_bm;
   contrl[9..10] = dst_bm;
   contrl[11..12] = 0;

   vdi ();
}

void vr_trnfm (int16_t handle, MFDB *psrcMFDB, MFDB *pdesMFDB)
{
   iptr (psrcMFDB);
   iptr_2 (pdesMFDB);

   contrl[0] = 110;
   contrl[1] = 0;
   contrl[3] = 0;
   contrl[6] = handle;

   vdi ();
}

void vro_cpyfm (int16_t handle, int16_t vr_mode,
                int16_t *pxyarray, MFDB *psrcMFDB,
                MFDB *pdesMFDB)
{
   intin[0]    = vr_mode;
   ptsin[0..7] = pxyarray[0..7];
   iptr (psrcMFDB);
   iptr2 (pdesMFDB);

   contrl[0] = 109;
   contrl[1] = 4;
   contrl[3] = 1;
   contrl[6] = handle;

   vdi ();
}

void vrt_cpyfm (int16_t handle, int16_t vr_mode,
                int16_t *pxyarray,MFDB *psrcMFDB,
                MFDB *pdesMFDB, int16_t *color_index)
{
   intin[0]    = vr_mode;
   intin[1]    = *color_index++;
   intin[2]    = *color_index;
   ptsin[0..7] = pxyarray[0..7];

   iptr (psrcMFDB);
   iptr_2 (pdesMFDB);

   contrl[0] = 121;
   contrl[1] = 4;
   contrl[3] = 3;
   contrl[6] = handle;

   vdi ();
}

int16_t vs_hilite_color( int16_t handle, int32_t color_space,
                         COLOR_ENTRY *hilite_color )
{
   intin[0..1]    = color_space;
   intin[2..5]    = hilite_color;

   contrl[0] = 207;
   contrl[1] = 0;
   contrl[3] = 6;
   contrl[5] = 0;
   contrl[6] = handle;

   vdi ();

   return ( intout[0] );
}

int16_t vs_max_color( int16_t handle, int32_t color_space,
                      COLOR_ENTRY *max_color )
{
   intin[0..1]    = color_space;
   intin[2..5]    = max_color;

   contrl[0] = 207;
   contrl[1] = 0;
   contrl[3] = 6;
   contrl[5] = 2;
   contrl[6] = handle;

   vdi ();

   return ( intout[0] );
}

int16_t vs_min_color( int16_t handle, int32_t color_space,
                      COLOR_ENTRY *min_color )
{
   intin[0..1]    = color_space;
   intin[2..5]    = min_color;

   contrl[0] = 207;
   contrl[1] = 0;
   contrl[3] = 6;
   contrl[5] = 1;
   contrl[6] = handle;

   vdi ();

   return ( intout[0] );
}

int16_t vs_weight_color( int16_t handle, int32_t color_space,
                         COLOR_ENTRY *weight_color )
{
   intin[0..1]    = color_space;
   intin[2..5]    = weight_color;

   contrl[0] = 207;
   contrl[1] = 0;
   contrl[3] = 6;
   contrl[5] = 3;
   contrl[6] = handle;

   vdi ();

   return ( intout[0] );
}