625 lines
20 KiB
C
625 lines
20 KiB
C
#ifndef lint
|
|
static char sccsid[] = "@(#)cgiwindow.c 1.1 94/10/31 Copyr 1985-9 Sun Micro";
|
|
#endif lint
|
|
|
|
/*
|
|
* Copyright (c) 1985, 1986, 1987, 1988, 1989 by Sun Microsystems, Inc.
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose and without fee is hereby granted, provided that the above
|
|
* copyright notice appear in all copies and that both that copyright
|
|
* notice and this permission notice are retained, and that the name
|
|
* of Sun Microsystems, Inc., not be used in advertising or publicity
|
|
* pertaining to this software without specific, written prior permission.
|
|
* Sun Microsystems, Inc., makes no representations about the suitability
|
|
* of this software or the interface defined in this software for any
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
|
*/
|
|
/*
|
|
* CGI window functions
|
|
*/
|
|
|
|
|
|
/*
|
|
vdc_extent
|
|
cgipw_set_vdc_extent
|
|
cgipw_set_offset
|
|
_cgi_update_gp1_xform
|
|
device_viewport
|
|
clip_indicator
|
|
clip_rectangle
|
|
_cgi_windowset
|
|
_cgi_reset_clipping
|
|
_cgi_reset_intatt
|
|
_cgi_get_r_screen
|
|
*/
|
|
|
|
/*
|
|
bugs:
|
|
reverse screen device viewport
|
|
vdc extent work for all viewports.
|
|
implement clip rectangle in all functions.
|
|
x and y scaling factors should be computed separately
|
|
*/
|
|
|
|
#include "cgipriv.h"
|
|
#include <suntool/sunview.h>
|
|
#include <suntool/canvas.h>
|
|
#include <sun/fbio.h>
|
|
#include <sun/gpio.h>
|
|
|
|
Gstate _cgi_state; /* CGI global state */
|
|
View_surface *_cgi_vws; /* current view surface */
|
|
Outatt *_cgi_att; /* structure containing current attributes */
|
|
int _cgi_pix_mode; /* pixrect equivalent of drawing mode */
|
|
int _cgi_criticalcnt; /* critical region protection */
|
|
Ccoor _cgi_00; /* coordinate (0,0) */
|
|
caddr_t (*_cgi_win_get)(); /* -> "window_get" if canvas call */
|
|
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: vdc_extent */
|
|
/* */
|
|
/* Defines the limits of VDC space */
|
|
/****************************************************************************/
|
|
|
|
Cerror vdc_extent(c1, c2)
|
|
Ccoor *c1, *c2; /* bottom left-hand and top right-hand corner
|
|
* of VDC space */
|
|
{
|
|
register Outatt *common_att = _cgi_state.common_att;
|
|
int ivw;
|
|
Cerror err, terr;
|
|
|
|
if (_cgi_state.cgipw_mode) /* opened via open_pw_cgi? */
|
|
err = ENOTCCPW;
|
|
else
|
|
err = _cgi_check_state_5();
|
|
if (!err)
|
|
{
|
|
/* (void) printf("corners %d %d %d %d\n",c1->x,c2->x,c1->y,c2->y); */
|
|
if ((c1->x < c2->x) && (c1->y < c2->y))
|
|
{
|
|
if (!((c1->x <= -32768) || (c1->y <= -32768)
|
|
|| (c2->x >= 32768) || (c2->y >= 32768)))
|
|
{
|
|
common_att->vdc.rect.r_left = c1->x;
|
|
common_att->vdc.rect.r_width = c2->x - c1->x + 1;
|
|
common_att->vdc.rect.r_bottom = c1->y;
|
|
common_att->vdc.rect.r_height = c2->y - c1->y + 1;
|
|
common_att->vdc.clip.rect = common_att->vdc.rect;
|
|
/* rescale all open windows */
|
|
ivw = 0;
|
|
while (_cgi_bump_vws(&ivw))
|
|
{
|
|
terr = _cgi_windowset(_cgi_vws);
|
|
if (terr && !err) /* capture first error */
|
|
err = terr;
|
|
if (_cgi_vws->sunview.gp_att != (Gp1_attr *) 0)
|
|
_cgi_update_gp1_xform(_cgi_vws);
|
|
}
|
|
}
|
|
else
|
|
err = EVDCSDIL;
|
|
}
|
|
else
|
|
err = EBADRCTD;
|
|
}
|
|
return (_cgi_errhand(err));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: cgipw_set_vdc_extent */
|
|
/* */
|
|
/* Set global xscale and yscale, and update GP's values. */
|
|
/****************************************************************************/
|
|
Cerror cgipw_set_vdc_extent(desc, c1, c2)
|
|
Ccgiwin *desc;
|
|
Ccoor *c1, *c2; /* bottom left-hand and top right-hand corner
|
|
* of VDC space */
|
|
{
|
|
register View_surface *vwsP;
|
|
register Outatt *attP;
|
|
Cerror err;
|
|
|
|
SETUP_CGIWIN(desc);
|
|
vwsP = desc->vws;
|
|
attP = vwsP->att;
|
|
if ((c1->x < c2->x) && (c1->y < c2->y))
|
|
{
|
|
if (!((c1->x <= -32768) || (c1->y <= -32768)
|
|
|| (c2->x >= 32768) || (c2->y >= 32768)))
|
|
{
|
|
attP->vdc.use_pw_size = 0;
|
|
attP->vdc.rect.r_left = c1->x;
|
|
attP->vdc.rect.r_width = c2->x - c1->x + 1;
|
|
attP->vdc.rect.r_bottom = c1->y;
|
|
attP->vdc.rect.r_height = c2->y - c1->y + 1;
|
|
err = _cgi_windowset(vwsP);
|
|
if (vwsP->sunview.gp_att != (Gp1_attr *) NULL)
|
|
_cgi_update_gp1_xform(vwsP);
|
|
}
|
|
else
|
|
err = EVDCSDIL;
|
|
}
|
|
else
|
|
err = EBADRCTD;
|
|
return (err);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: cgipw_set_offset */
|
|
/* */
|
|
/* Set global xoff and yoff, and update GP's offset. */
|
|
/****************************************************************************/
|
|
Cerror cgipw_set_offset(desc, xoff, yoff)
|
|
Ccgiwin *desc;
|
|
Cint xoff, yoff;
|
|
{
|
|
register View_surface *vwsP = desc->vws;
|
|
Cerror err = NO_ERROR;
|
|
|
|
SETUP_CGIWIN(desc);
|
|
vwsP->xform.win_off.x = xoff;
|
|
vwsP->xform.win_off.y = yoff;
|
|
err = _cgi_windowset(vwsP);
|
|
if (vwsP->sunview.gp_att != (Gp1_attr *) NULL)
|
|
_cgi_update_gp1_xform(vwsP);
|
|
return (err);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: _cgi_update_gp1_xform */
|
|
/* */
|
|
/* Gives CGI's VDC-to-DC transform to GP1. */
|
|
/* Uses vwsP argument to get transform. */
|
|
/* Updates GP's clip list for good luck. */
|
|
/****************************************************************************/
|
|
|
|
_cgi_update_gp1_xform(vws)
|
|
register View_surface *vws; /* ptr to view surface to update from */
|
|
{
|
|
register Gp1_attr *gp_att = vws->sunview.gp_att;
|
|
float xs, ys, xo, yo;
|
|
|
|
(void) _cgi_gp1_pw_updclplst(vws->sunview.pw, gp_att);
|
|
xs = (float) (vws->xform.scale.x.num >> 1)
|
|
/ (float) vws->xform.scale.x.den;
|
|
xo = (float) (vws->xform.off.x + gp_att->org_x);
|
|
ys = (float) (vws->xform.scale.y.num >> 1)
|
|
/ (float) vws->xform.scale.y.den;
|
|
yo = (float) (vws->xform.off.y + gp_att->org_y);
|
|
_cgi_gp1_set_scale(&xs, &ys, gp_att);
|
|
_cgi_gp1_set_offset(&xo, &yo, gp_att);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: device_viewport */
|
|
/* */
|
|
/* Defines where in device coordinates the screen will be mapped */
|
|
/****************************************************************************/
|
|
|
|
Cerror device_viewport(name, c1, c2)
|
|
Cint name; /* name of view surface */
|
|
Ccoor *c1, *c2; /* bottom left-hand and top right-hand corner
|
|
* of viewsurface to map VDC onto (expressed in
|
|
* pixels) */
|
|
{
|
|
register View_surface *cur_vws;
|
|
int err;
|
|
Ccoor size;
|
|
|
|
if (_cgi_state.cgipw_mode) /* opened via open_pw_cgi? */
|
|
err = ENOTCCPW;
|
|
else
|
|
err = _cgi_check_state_5();
|
|
if (!err)
|
|
err = _cgi_context(name);
|
|
if (!err)
|
|
{
|
|
cur_vws = _cgi_vws;
|
|
size.x = c2->x - c1->x + 1;
|
|
size.y = c2->y - c1->y + 1;
|
|
if ((c1->x <= c2->x) && (c1->y <= c2->y))
|
|
{
|
|
if ((c1->x >= cur_vws->real_screen.r_left) &&
|
|
(size.x <= cur_vws->real_screen.r_width) &&
|
|
(c1->y >= cur_vws->real_screen.r_top) &&
|
|
(size.y <= cur_vws->real_screen.r_height))
|
|
{
|
|
cur_vws->vport.r_left = c1->x;
|
|
cur_vws->vport.r_width = size.x;
|
|
cur_vws->vport.r_top = c1->y;
|
|
cur_vws->vport.r_height = size.y;
|
|
cur_vws->sunview.lock_rect = cur_vws->vport;
|
|
|
|
/* set device scaling and clipping */
|
|
err = _cgi_windowset(cur_vws);
|
|
if (cur_vws->sunview.gp_att != (Gp1_attr *) NULL)
|
|
_cgi_update_gp1_xform(cur_vws);
|
|
}
|
|
else
|
|
err = EBDVIEWP;
|
|
}
|
|
else
|
|
err = EBADRCTD;
|
|
}
|
|
return (_cgi_errhand(err));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: clip_indicator */
|
|
/* */
|
|
/* Defines clipping rules. */
|
|
/****************************************************************************/
|
|
|
|
Cerror clip_indicator(cflag)
|
|
Cclip cflag; /* on or off */
|
|
{
|
|
int ivw;
|
|
Cerror err, terr;
|
|
|
|
err = _cgi_check_state_5();
|
|
if (!err)
|
|
{
|
|
switch (cflag)
|
|
{
|
|
case NOCLIP:
|
|
_cgi_pix_mode |= PIX_DONTCLIP;
|
|
break;
|
|
case CLIP:
|
|
/* since PIX_CLIP is 0, _cgi_pix_mode |= PIX_CLIP is a no-op */
|
|
_cgi_pix_mode &= ~PIX_DONTCLIP;
|
|
break;
|
|
case CLIP_RECTANGLE:
|
|
/* since PIX_CLIP is 0, _cgi_pix_mode |= PIX_CLIP is a no-op */
|
|
_cgi_pix_mode &= ~PIX_DONTCLIP;
|
|
if (_cgi_state.cgipw_mode) /* opened via open_pw_cgi? */
|
|
err = ENOTCCPW;
|
|
break;
|
|
}
|
|
}
|
|
_cgi_state.common_att->vdc.clip.indicator = cflag;
|
|
ivw = 0;
|
|
if (!err)
|
|
{
|
|
while (_cgi_bump_all_vws(&ivw))
|
|
{
|
|
_cgi_att->vdc.clip.indicator = cflag;
|
|
terr = _cgi_reset_clipping(_cgi_vws);
|
|
if (terr && !err) /* capture first error */
|
|
err = terr;
|
|
if (_cgi_vws->sunview.gp_att != (Gp1_attr *) 0)
|
|
_cgi_update_gp1_xform(_cgi_vws);
|
|
}
|
|
}
|
|
return (_cgi_errhand(err));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: clip_rectangle */
|
|
/* */
|
|
/* Defines clipping rectangle in VDC space */
|
|
/****************************************************************************/
|
|
|
|
Cerror clip_rectangle(xmin, xmax, ymin, ymax)
|
|
Cint xmin, xmax, ymin, ymax;
|
|
/* bottom left-hand and top right-hand corner of clipping rectangle */
|
|
{
|
|
register Outatt *common_att = _cgi_state.common_att;
|
|
VdcRect new_clip;
|
|
int ivw;
|
|
Cerror err, terr;
|
|
|
|
err = _cgi_check_state_5();
|
|
if (!err && _cgi_state.cgipw_mode) /* opened via open_pw_cgi? */
|
|
err = ENOTCCPW;
|
|
if (!err)
|
|
{
|
|
/*
|
|
* The clipping region includes values == xmax,ymax. In other words, a
|
|
* pixel is unclipped (ie. drawn) if its coordinates are (min <= coord
|
|
* && coord <= max)
|
|
*/
|
|
new_clip.r_left = xmin;
|
|
new_clip.r_bottom = ymin;
|
|
new_clip.r_width = xmax - xmin + 1;
|
|
new_clip.r_height = ymax - ymin + 1;
|
|
if ((xmin <= xmax) && (ymin <= ymax)) /* = added */
|
|
{
|
|
if ((xmin < xmax) && (ymin < ymax)) /* previously != */
|
|
{
|
|
if ((new_clip.r_left >= common_att->vdc.rect.r_left)
|
|
&& (new_clip.r_bottom >= common_att->vdc.rect.r_bottom)
|
|
&& (new_clip.r_width <= common_att->vdc.rect.r_width)
|
|
&& (new_clip.r_height <= common_att->vdc.rect.r_height))
|
|
{
|
|
common_att->vdc.clip.rect = new_clip;
|
|
|
|
/* reset clipping on all open windows */
|
|
ivw = 0;
|
|
while (_cgi_bump_vws(&ivw))
|
|
{
|
|
terr = _cgi_windowset(_cgi_vws);
|
|
if (terr && !err)
|
|
err = terr; /* capture first error */
|
|
if (_cgi_vws->sunview.gp_att != (Gp1_attr *) 0)
|
|
_cgi_update_gp1_xform(_cgi_vws);
|
|
}
|
|
}
|
|
else
|
|
err = ECLIPTOL;
|
|
}
|
|
else
|
|
err = ECLIPTOS;
|
|
}
|
|
else
|
|
err = EBADRCTD;
|
|
}
|
|
return (_cgi_errhand(err));
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: _cgi_windowset */
|
|
/* */
|
|
/* Sets VDC space to screen space conversion factors */
|
|
/* */
|
|
/* This routine maps min_vdc to the center of the left-most */
|
|
/* (resp. bottom-most) pixel, and max vdc to the center of */
|
|
/* the right-most (resp. top-most) pixel. Since CGI relies */
|
|
/* on pixwin clipping, and does not clip vectors in VDC */
|
|
/* space prior to coordinate conversion, this will result in */
|
|
/* some coordinates outside the specified VDC range being */
|
|
/* drawn, rather than being clipped. This matches the GP */
|
|
/* behavior, however, and a mismatch with the GP would be */
|
|
/* more noticeable than a slight deviation from the */
|
|
/* standard in clipping. */
|
|
/****************************************************************************/
|
|
|
|
Cerror _cgi_windowset(vwsP)
|
|
register View_surface *vwsP;
|
|
{
|
|
register Outatt *attP = vwsP->att;
|
|
int vport_xsize, vport_ysize;
|
|
int pix_vdc_xsize, pix_vdc_ysize;
|
|
int vdc_xsize, vdc_ysize;
|
|
int win_size, vdc_size;
|
|
int xleft, ybottom;
|
|
float winratio, vdcratio;
|
|
Cerror err = NO_ERROR;
|
|
|
|
START_CRITICAL();
|
|
|
|
attP = vwsP->att;
|
|
vwsP->xform.off = _cgi_00;
|
|
if (attP->vdc.use_pw_size) /* wds added 850614 for null-transform pixwin
|
|
* vws */
|
|
{
|
|
IDENTITY_SCALE(vwsP->xform.scale.x);
|
|
IDENTITY_SCALE(vwsP->xform.scale.y);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* The meaning of min and max for vport, vdc, r_screen, etc. is: an
|
|
* in-range number X may take on values: min <= X < max
|
|
*/
|
|
vport_xsize = vwsP->vport.r_width;
|
|
vport_ysize = vwsP->vport.r_height;
|
|
vdc_xsize = abs(attP->vdc.rect.r_width);
|
|
vdc_ysize = abs(attP->vdc.rect.r_height);
|
|
winratio = (float) vport_xsize / (float) vport_ysize;
|
|
vdcratio = (float) vdc_xsize / (float) vdc_ysize;
|
|
|
|
if (winratio < vdcratio)
|
|
{
|
|
win_size = vport_xsize - 1;
|
|
vdc_size = vdc_xsize - 1;
|
|
}
|
|
else
|
|
{
|
|
win_size = vport_ysize - 1;
|
|
vdc_size = vdc_ysize - 1;
|
|
}
|
|
vwsP->xform.scale.x.num = win_size << 1;
|
|
vwsP->xform.scale.x.den = vdc_size;
|
|
vwsP->xform.scale.y.num = (-win_size) << 1;
|
|
vwsP->xform.scale.y.den = vdc_size;
|
|
_cgi_devscalen(vdc_xsize - 1, pix_vdc_xsize);
|
|
_cgi_devscalen(vdc_ysize - 1, pix_vdc_ysize);
|
|
pix_vdc_xsize++;
|
|
pix_vdc_ysize++;
|
|
|
|
/*
|
|
* Center VDC rectangle within viewport.
|
|
* Pix_vdc_xsize and pix_vdc_ysize are always <= vport_xsize
|
|
* and vport_ysize, respectively
|
|
*/
|
|
vwsP->xform.off.x += ((vport_xsize - pix_vdc_xsize) / 2);
|
|
vwsP->xform.off.y += ((vport_ysize - pix_vdc_ysize) / 2);
|
|
|
|
/*
|
|
* Account for offset of viewport within window (ie. relative
|
|
* to real_screen).
|
|
*/
|
|
vwsP->xform.off.x += vwsP->vport.r_left;
|
|
vwsP->xform.off.y += vwsP->vport.r_top;
|
|
|
|
/*
|
|
* Scaling vdc_xmin and vdc_ymin may yield non-zero values,
|
|
* so offset for that.
|
|
*/
|
|
_cgi_dev_scale_only(attP->vdc.rect.r_left,
|
|
attP->vdc.rect.r_bottom,
|
|
xleft, ybottom);
|
|
vwsP->xform.off.x -= xleft;
|
|
vwsP->xform.off.y -= ybottom;
|
|
|
|
/**
|
|
** The transform handles the problem of Y positive == up in VDC
|
|
** but Y positive == down in DC by doing
|
|
** DC = (window_height - 1) - (VDC * scaling)
|
|
** This is acheived by making the scaling negative, and offsetting
|
|
** by (window_height - 1).
|
|
**/
|
|
vwsP->xform.off.y += pix_vdc_ysize - 1;
|
|
}
|
|
_cgi_reset_intatt(vwsP); /* reset relevant internal attributes */
|
|
err = _cgi_reset_clipping(vwsP); /* reset internal clipping parameters */
|
|
|
|
/*
|
|
* Delay version stamping the changed attributes until everything is done.
|
|
*/
|
|
_cgi_state.vdc_change_cnt++;
|
|
|
|
END_CRITICAL();
|
|
return (err);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: _cgi_reset_clipping */
|
|
/* */
|
|
/* Resets clip region after a change in vdc extent, */
|
|
/* window size, clip rectangle, clip indicator, or */
|
|
/* viewport size. */
|
|
/* */
|
|
/* This assumes that _cgi_windowset has already been done, */
|
|
/* so that the edges of VDC space fit within the viewport. */
|
|
/****************************************************************************/
|
|
|
|
Cerror _cgi_reset_clipping(vwsP)
|
|
register View_surface *vwsP;
|
|
{
|
|
register Outatt *attP = vwsP->att;
|
|
Cint xmin, xmax, ymin, ymax;
|
|
Cint vxmin, vxmax, vymin, vymax;
|
|
Cerror err = NO_ERROR;
|
|
|
|
START_CRITICAL();
|
|
|
|
/*
|
|
* Don't change the pw_region in CGIPW mode. This test should be the same
|
|
* as the one in _cgi_windowset, so _cgi_att.vdc.use_pw_size is the correct
|
|
* thing to test, not _cgi_state.cgipw_mode.
|
|
*/
|
|
if (!attP->vdc.use_pw_size)
|
|
{
|
|
if (vwsP->sunview.pw != vwsP->sunview.orig_pw
|
|
&& vwsP->sunview.pw != (Pixwin *) NULL)
|
|
{
|
|
pw_close(vwsP->sunview.pw);
|
|
vwsP->sunview.pw = (Pixwin *) NULL;
|
|
}
|
|
if (attP->vdc.clip.indicator == CLIP_RECTANGLE)
|
|
{
|
|
vxmin = attP->vdc.clip.rect.r_left;
|
|
vxmax = attP->vdc.clip.rect.r_left + attP->vdc.clip.rect.r_width -1;
|
|
vymin = attP->vdc.clip.rect.r_bottom;
|
|
vymax = attP->vdc.clip.rect.r_bottom+attP->vdc.clip.rect.r_height-1;
|
|
}
|
|
else
|
|
{
|
|
vxmin = attP->vdc.rect.r_left;
|
|
vxmax = attP->vdc.rect.r_left + attP->vdc.rect.r_width - 1;
|
|
vymin = attP->vdc.rect.r_bottom;
|
|
vymax = attP->vdc.rect.r_bottom + attP->vdc.rect.r_height - 1;
|
|
}
|
|
|
|
/*
|
|
* Transform the bottom-left and top-right corners of the clip region,
|
|
* and set a pw_region corresponding to this area. It is better not to
|
|
* use _cgi_devscalen for this, since the result obtained for the
|
|
* top-right corner could be different if the scaled width is added to
|
|
* the scaled origin, since each is rounded separately before adding.
|
|
*/
|
|
_cgi_devscale_clip(vxmin, vymin, xmin, ymax);
|
|
_cgi_devscale_clip(vxmax, vymax, xmax, ymin);
|
|
vwsP->conv.clip.r_left = xmin;
|
|
vwsP->conv.clip.r_width = xmax - xmin + 1;
|
|
vwsP->conv.clip.r_top = ymin;
|
|
vwsP->conv.clip.r_height = ymax - ymin + 1;
|
|
|
|
if (attP->vdc.clip.indicator != NOCLIP)
|
|
{
|
|
vwsP->sunview.pw = pw_region(vwsP->sunview.orig_pw,
|
|
vwsP->conv.clip.r_left,
|
|
vwsP->conv.clip.r_top,
|
|
vwsP->conv.clip.r_width,
|
|
vwsP->conv.clip.r_height);
|
|
if (vwsP->sunview.pw == (Pixwin *) NULL)
|
|
err = EMEMSPAC;
|
|
}
|
|
else
|
|
{
|
|
vwsP->sunview.pw = vwsP->sunview.orig_pw;
|
|
}
|
|
}
|
|
|
|
END_CRITICAL();
|
|
return (err);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: _cgi_reset_intatt */
|
|
/* */
|
|
/* resets attributes that depend on screen size */
|
|
/****************************************************************************/
|
|
|
|
_cgi_reset_intatt(vws)
|
|
View_surface *vws;
|
|
{
|
|
_cgi_set_conv_line_width(vws);
|
|
_cgi_set_conv_marker_size(vws);
|
|
_cgi_set_conv_perimeter_width(vws);
|
|
_cgi_reset_internal_text(vws);
|
|
}
|
|
|
|
/****************************************************************************/
|
|
/* */
|
|
/* FUNCTION: _cgi_get_r_screen */
|
|
/* */
|
|
/* Determine what screen extent we're mapping to. */
|
|
/* Returns L_FALSE if CGI should not do damage repair. */
|
|
/****************************************************************************/
|
|
|
|
Clogical _cgi_get_r_screen(vws, rect)
|
|
View_surface *vws;
|
|
Rect *rect;
|
|
{
|
|
register Canvas canvas;
|
|
|
|
/*
|
|
* If the output surface is a canvas, use the canvas width and height.
|
|
* Otherwise, use the pixwin region.
|
|
*/
|
|
if ( (_cgi_win_get) && /* we have a "window_get" func pointer */
|
|
((canvas = vws->sunview.canvas) != (Canvas) 0) )
|
|
{
|
|
rect->r_left = 0;
|
|
rect->r_top = 0;
|
|
rect->r_width = (int) (*_cgi_win_get)(canvas, CANVAS_WIDTH);
|
|
rect->r_height = (int) (*_cgi_win_get)(canvas, CANVAS_HEIGHT);
|
|
return (L_FALSE);
|
|
}
|
|
else if (vws->sunview.orig_pw->pw_clipdata != NULL
|
|
&& vws->sunview.orig_pw->pw_clipdata->pwcd_regionrect != 0)
|
|
{
|
|
pw_get_region_rect(vws->sunview.orig_pw, rect);
|
|
return (L_TRUE);
|
|
}
|
|
else
|
|
{
|
|
win_getsize(vws->sunview.windowfd, rect);
|
|
return (L_TRUE);
|
|
}
|
|
}
|