8.13 Grafikfunktionen

int16_t graf_dragbox (int16_t gr_dwidth, int16_t gr_dheight,
                      int16_t gr_dstartx, int16_t gr_dstarty,
                      int16_t gr_dboundx, int16_t gr_dboundy,
                      int16_t gr_dboundw, int16_t gr_dboundh,
                      int16_t *gr_dfinishx,
                      int16_t *gr_dfinishy)
{
   int_in[0] = gr_dwidth;
   int_in[1] = gr_dheight;
   int_in[2] = gr_dstartx;
   int_in[3] = gr_dstarty;
   int_in[4] = gr_dboundx;
   int_in[5] = gr_dboundy;
   int_in[6] = gr_dboundw;
   int_in[7] = gr_dboundh;

   crys_if (71);

   *gr_dfinishx = int_out[1];
   *gr_dfinishy = int_out[2];

   return ( int_out[0] );
}

int16_t graf_growbox (int16_t gr_gstx, int16_t gr_gsty,
                      int16_t gr_gstwidth,
                      int16_t gr_gstheight, int16_t gr_gfinx,
                      int16_t gr_gfiny, int16_t gr_gfinwidth,
                      int16_t gr_gfinheight)
{
   int_in[0] = gr_gstx;
   int_in[1] = gr_gsty;
   int_in[2] = gr_gstwidth;
   int_in[3] = gr_gstheight;
   int_in[4] = gr_gfinx;
   int_in[5] = gr_gfiny;
   int_in[6] = gr_gfinwidth;
   int_in[7] = gr_gfinheight;

   return ( crys_if(73) );
}

int16_t graf_handle (int16_t *gr_hwchar, int16_t *gr_hhchar,
                     int16_t *gr_hwbox, int16_t *gr_hhbox)
{
   crys_if (77);

   *gr_hwchar = int_out[1];
   *gr_hhchar = int_out[2];
   *gr_hwbox  = int_out[3];
   *gr_hhbox  = int_out[4];

   return ( int_out[0] );
}

int16_t graf_mbox (int16_t gr_mwidth, int16_t gr_mheight,
                   int16_t gr_msourcex, int16_t gr_msourcey,
                   int16_t gr_mdestx, int16_t gr_mdesty)
{
   int_in[0] = gr_mwidth;
   int_in[1] = gr_mheight;
   int_in[2] = gr_msourcex;
   int_in[3] = gr_msourcey;
   int_in[4] = gr_mdestx;
   int_in[5] = gr_medsty;

   return ( crys_if(72) );
}

int16_t graf_mkstate (int16_t *gr_mkmx, int16_t *gr_mkmy,
                      int16_t *gr_mkmstate,
                      int16_t *gr_mkkstate)
{
   crys_if (79);

   *gr_mkmx     = int_out[1];
   *gr_mkmy     = int_out[2];
   *gr_mkmstate = int_out[3];
   *gr_mkkstate = int_out[4];

   return ( int_out[0] );
}

X_MRESET (1000)

 
graf_mouse( X_MRESET, 0L );
 
Resets the mouse so that it is "on" just once, and also updates graf_mouse's idea of the hide count.
 

X_MGET (1001)

 
hidecount = graf_mouse( X_MGET, MFORM *mouse );
 
In this mode, if "mouse" is non-zero, then the MFORM it points to is filled-in with the shape of the last mouse set with graf_mouse(). "hidecount" gets the number of times the mouse was hidden using graf_mouse(M_OFF...). If this number is greater than zero, the mouse is hidden that number of times. If it is zero, the mouse is shown once. If it is less than zero, the mouse is "shown" more than once.
 

X_SET_SHAPE (1100)

 
graf_mouse( X_SET_SHAPE+index, ANI_MOUSE *mouse_form );
 
Change the shape of the mouse form whose number is "index". The ANI_MOUSE structure contains up to 32 mouse shapes to be animated in a continuous loop while that particular mouse shape is being displayed.
If the "frames" portion of the ANI_MOUSE structure is one, then no animation is performed. Otherwise, it should be the number of frames contained in the mouse animation sequence. The "delay" value is the number of 50 Hz timer tics to pause between each frame in the animation. The "form" portion of the structure only needs to be initialized for the number of frames, so if there are only two frames, this means that only form[0] and form[1] are used. If a NULL pointer is passed, instead of a pointer to an ANI_MOUSE structure, then the mouse shape is restored to its default.
It does not matter if the application which sets a new shape terminates without resetting the mouse shape, as this call allocates memory internally to hold the new shape data.
 

int16_t graf_mouse (int16_t gr_monumber, MFORM *gr_mofaddr)
{
   int_in[0]  = gr_monumber;
   addr_in[0] = gr_mofaddr;

   return ( crys_if(78) );
}

int16_t graf_multirubber (int16_t x, int16_t y, int16_t minw,
                          int16_t minh, GRECT *rec,
                          int16_t *outw, int16_t *outh)
{
   int_in[0] = x;
   int_in[1] = y;
   int_in[2] = minw;
   int_in[3] = minh;

   addr_in[0] = rec;

   crys_if (69);

   *outw = int_out[1];
   *outh = int_out[2];

   return ( int_out[0] );
}

int16_t graf_rubbox (int16_t gr_rx, int16_t gr_ry,
                     int16_t gr_minwidth,
                     int16_t gr_minheight,
                     int16_t *gr_rlastwidth,
                     int16_t *gr_rlastheight)
{
   int_in[0] = gr_rx;
   int_in[1] = gr_ry;
   int_in[2] = gr_minwidth;
   int_in[3] = gr_minheight;

   crys_if (70);

   *gr_rlastwidth = int_out[1];
   *gr_lastheight = int_out[2];

   return ( int_out[0] );
}

int16_t graf_shrinkbox (int16_t gr_sfinx, int16_t gr_sfiny,
                        int16_t gr_sfinwidth,
                        int16_t gr_sfinheight,
                        int16_t gr_sstx, int16_t gr_ssty,
                        int16_t gr_sstwidth,
                        int16_t gr_sstheight)
{
   int_in[0] = gr_sfinx;
   int_in[1] = gr_sfiny;
   int_in[2] = gr_sfinwidth;
   int_in[3] = gr_sfinheight;
   int_in[4] = gr_sstx;
   int_in[5] = gr_ssty;
   int_in[6] = gr_sstwidth;
   int_in[7] = gr_sstheight;

   return ( crys_if(74) );
}

int16_t graf_slidebox (OBJECT *gr_slptree,
                       int16_t gr_slparent,
                       int16_t gr_slobject, int16_t gr_slvh)
{
   int_in[0]  = gr_slparent;
   int_in[1]  = gr_slobject;
   int_in[2]  = gr_slvh;
   addr_in[0] = gr_slptree;

   return ( crys_if(76) );
}

int16_t graf_watchbox (OBJECT *gr_wptree, int16_t gr_wobject,
                       int16_t gr_winstate,
                       int16_t gr_woutstate)
{
   int_in[0]  = 0;
   int_in[1]  = gr_wobject;
   int_in[2]  = gr_winstate;
   int_in[3]  = gr_woutstate;

   addr_in[0] = gr_wptree;

   return ( crys_if(75) );
}

int16_t graf_wwatchbox (OBJECT *gr_wptree, int16_t gr_wobject,
                        int16_t gr_winstate,
                        int16_t gr_woutstate,
                        int16_t whandle)
{
   int_in[0]  = gr_wobject;
   int_in[1]  = gr_winstate;
   int_in[2]  = gr_woutstate;
   int_in[3]  = whandle;

   addr_in[0] = gr_wptree;

   return ( crys_if(62) );
}

int16_t graf_xhandle (int16_t *gr_hwchar, int16_t *gr_hhchar,
                      int16_t *gr_hwbox, int16_t *gr_hhbox,
                      int16_t *device )
{
   crys_if (77);

   *gr_hwchar = int_out[1];
   *gr_hhchar = int_out[2];
   *gr_hwbox  = int_out[3];
   *gr_hhbox  = int_out[4];
   *device    = int_out[5];

   return ( int_out[0] );
}

OBJECT *tree;
GRECT r;

rsrc_gaddr( 0, 0, &tree );                    /* get dialog        */
form_center( tree, &r.x, &r.y, &r.w, &r.h );  /* center it         */
wind_update( BEG_UPDATE );                    /* lock menu bar     */
x_graf_blit( &r, 0L );                        /* save what's there */
objc_draw( tree, 0, 8, r.x, r.y, r.w, r.h );  /* draw dialog       */
form_do( tree, 0 );                           /* get user response */
x_graf_blit( 0L, &r );                        /* now restore       */
wind_update( END_UPDATE );                    /* re-enable menus   */

int16_t x_graf_blit( GRECT *source, GRECT *dest )
{
   addr_in[0] = source;
   addr_in[1] = dest;

   crys_if(28976);

   return ( int_out[0] );
}

MFDB source,                           /* assume this is already filled-in */
     dest,
     screen;
     int32_t dest_size;

     dest = source;                    /* most values are the same to start */
     dest.fd_nplanes = current_video_planes;
     dest_size = (long)dest.fd_nplanes * dest.fd_wdwidth*2 * dest.fd_h;
     dest.fd_addr = Malloc(dest_size);
     x_graf_rast2rez( source.fd_addr, (long)source.fd_wdwidth*2 * source.fd_h,
                      source.fd_nplanes, &dest, 1 );
     screen.fd_addr = 0L;
     vro_cpyfm( vdi_handle, MD_REPLACE, array, &dest, &screen );

void x_graf_rast2rez( uint16_t *src_data, int32_t plane_len, int16_t old_planes,
                      MFDB *mfdb, int16_t devspef )
{
   int_in[0-1] = plane_len;
   int_in[2]   = old_planes;
   int_in[3]   = devspef;

   addr_in[0] = src_data;
   addr_in[1] = mfdb;

   crys_if(28978);

   return;
}

• The area parameter points to a GRECT structure which describes the dimensions of the initial rubberband box. If the lag parameter is zero, then the g_w and g_h elements of area are ignored.
• outer describes the size of the outside bounding rectangle. The rubberband box will never go outside this box. If this is a NULL pointer, the outside boundaries will be the whole desktop.
• minwidth and minheight describe the minimum height of the rubberband box; maxwidth and maxheight are the maximums. If either of the minimums are greater than zero, then extended resizing is possible. In this mode, the mouse can be dragged to the left or top edge of the minimum area, and resizing happens in a manner similar to Geneva's extended window resizing.
• snap is the number of pixels to jump by. If this value is greater than 1, the rubberband box will only move when its width or height is an even increment of this value.
• The lag parameter says whether the rubberband box should exactly follow the mouse, or if it should stay a constant distance from the mouse pointer. When resizing a window, Geneva uses the lag mode so that if the resize gadget is released before the mouse is moved, the window will not be resized.

int16_t x_graf_rubberbox(GRECT *area, GRECT *outer, int16_t
minwidth, int16_t minheight, int16_t maxwidth, int16_t
maxheight, int16_tsnap, int16_t lag )
{
   int_in[0] = minwidth;
   int_in[1] = minheight;
   int_in[2] = maxwidth;
   int_in[3] = maxheight;
   int_in[4] = snap;
   int_in[5] = lag;

   addr_in[0] = area;
   addr_in[1] = outer;

   crys_if(28977);

   return ( int_out[0] );
}