Subversion Repositories openrisc_me

/*

 * Copyright (c) 1999 Greg Haerr <greg@censoft.com>

 * Copyright (c) 1991 David I. Bell

 * Permission is granted to use, distribute, or modify this source,

 * provided that this copyright notice remains intact.

 *

 * Device-independent routines to determine clipping regions.

 */

#include "device.h"

/* Clip cache rectangle information.

 * After calling GdClipPoint, this rectangle is guaranteed to contain the

 * specified point (among others), and all points in the rectangle are

 * plottable or not according to the value of clipresult.

 */

MWCOORD clipminx;               /* minimum x value of cache rectangle */

MWCOORD clipminy;               /* minimum y value of cache rectangle */

MWCOORD clipmaxx;               /* maximum x value of cache rectangle */

MWCOORD clipmaxy;               /* maximum y value of cache rectangle */

static MWBOOL   clipresult;     /* whether clip rectangle is plottable */

int     clipcount;              /* number of clip rectangles */

MWCLIPRECT cliprects[MAX_CLIPRECTS];    /* clip rectangles */

/*

 * Set an array of clip rectangles for future drawing actions.

 * Each pixel will be drawn only if lies in one or more of the specified

 * clip rectangles.  As a special case, specifying no rectangles implies

 * clipping is for the complete screen.  All clip rectangles are modified

 * if necessary to lie within the device area.  Call only after device

 * has been initialized.

 */

void

GdSetClipRects(PSD psd,int count, MWCLIPRECT *table)

{

  register MWCLIPRECT *rp;              /* current rectangle */

  /* If there are no clip rectangles, then default to the full device area. */

  if (count <= 0) {

        clipminx = 0;

        clipminy = 0;

        clipmaxx = psd->xvirtres - 1;

        clipmaxy = psd->yvirtres - 1;

        clipcount = 0;

        clipresult = TRUE;

        return;

  }

  /* Copy the clip table to our own static array, modifying each

   * rectangle as necesary to fit within the device area.  If the clip

   * rectangle lies entirely outside of the device area, then skip it.

   */

  rp = cliprects;

  clipcount = 0;

  if (count > MAX_CLIPRECTS) count = MAX_CLIPRECTS;

  while (count-- > 0) {

        *rp = *table++;

        if (rp->x < 0) {

                rp->width += rp->x;

                rp->x = 0;

        }

        if (rp->y < 0) {

                rp->height += rp->y;

                rp->y = 0;

        }

        if ((rp->x >= psd->xvirtres) || (rp->width <= 0) ||

            (rp->y >= psd->yvirtres) || (rp->height <= 0))

                continue;

        if (rp->x + rp->width > psd->xvirtres)

                rp->width = psd->xvirtres - rp->x;

        if (rp->y + rp->height > psd->yvirtres)

                rp->height = psd->yvirtres - rp->y;

        rp++;

        clipcount++;

  }

  /* If there were no surviving clip rectangles, then set the clip

   * cache to prevent all drawing.

   */

  if (clipcount == 0) {

        clipminx = MIN_MWCOORD;

        clipminy = MIN_MWCOORD;

        clipmaxx = MAX_MWCOORD;

        clipmaxy = MAX_MWCOORD;

        clipresult = FALSE;

        return;

  }

  /* There was at least one valid clip rectangle. Default the clip

   * cache to be the first clip rectangle.

   */

  clipminx = cliprects[0].x;

  clipminy = cliprects[0].y;

  clipmaxx = clipminx + cliprects[0].width - 1;

  clipmaxy = clipminy + cliprects[0].height - 1;

  clipresult = TRUE;

}

/* Check a point against the list of clip rectangles.

 * Returns TRUE if the point is within one or more rectangles and thus

 * can be plotted, or FALSE if the point is not within any rectangle and

 * thus cannot be plotted.  Also remembers the coordinates of a clip cache

 * rectangle containing the specified point such that every point in the

 * rectangle would give the same result.  By examining this clip cache

 * rectangle after a call to this routine, the caller can efficiently

 * check many nearby points without needing any further calls.  If the

 * point lies within the cursor, then the cursor is removed.

 */

MWBOOL

GdClipPoint(PSD psd,MWCOORD x,MWCOORD y)

{

  int count;

  MWCLIPRECT *rp;

  MWCOORD temp;

  /* First see whether the point lies within the current clip cache

   * rectangle.  If so, then we already know the result.

   */

  if ((x >= clipminx) && (x <= clipmaxx) &&

      (y >= clipminy) && (y <= clipmaxy)) {

        if (clipresult) GdCheckCursor(psd, x, y, x, y);

        return clipresult;

  }

  /* If the point is outside of the screen area, then it is not

   * plottable, and the clip cache rectangle is the whole half-plane

   * outside of the screen area.

   */

  if (x < 0) {

        clipminx = MIN_MWCOORD;

        clipmaxx = -1;

        clipminy = MIN_MWCOORD;

        clipmaxy = MAX_MWCOORD;

        clipresult = FALSE;

        return FALSE;

  }

  if (y < 0) {

        clipminx = MIN_MWCOORD;

        clipmaxx = MAX_MWCOORD;

        clipminy = MIN_MWCOORD;

        clipmaxy = -1;

        clipresult = FALSE;

        return FALSE;

  }

  if (x >= psd->xvirtres) {

        clipminx = psd->xvirtres;

        clipmaxx = MAX_MWCOORD;

        clipminy = MIN_MWCOORD;

        clipmaxy = MAX_MWCOORD;

        clipresult = FALSE;

        return FALSE;

  }

  if (y >= psd->yvirtres) {

        clipminx = MIN_MWCOORD;

        clipmaxx = MAX_MWCOORD;

        clipminy = psd->yvirtres;

        clipmaxy = MAX_MWCOORD;

        clipresult = FALSE;

        return FALSE;

  }

  /* The point is within the screen area. If there are no clip

   * rectangles, then the point is plottable and the rectangle is the

   * whole screen.

   */

  count = clipcount;

  if (count <= 0) {

        clipminx = 0;

        clipmaxx = psd->xvirtres - 1;

        clipminy = 0;

        clipmaxy = psd->yvirtres - 1;

        clipresult = TRUE;

        GdCheckCursor(psd, x, y, x, y);

        return TRUE;

  }

  /* We need to scan the list of clip rectangles to calculate a new

   * clip cache rectangle containing this point, and the result. First

   * see if the point lies within any of the clip rectangles. If so,

   * then it is plottable and use that clip rectangle as the cache

   * rectangle.  This is not necessarily the best result, but works ok

   * and is fast.

   */

  for (rp = cliprects; count-- > 0; rp++) {

        if ((x >= rp->x) && (y >= rp->y) && (x < rp->x + rp->width)

            && (y < rp->y + rp->height)) {

                clipminx = rp->x;

                clipminy = rp->y;

                clipmaxx = rp->x + rp->width - 1;

                clipmaxy = rp->y + rp->height - 1;

                clipresult = TRUE;

                GdCheckCursor(psd, x, y, x, y);

                return TRUE;

        }

  }

  /* The point is not plottable. Scan the clip rectangles again to

   * determine a rectangle containing more non-plottable points.

   * Simply pick the largest rectangle whose area doesn't contain any

   * of the same coordinates as appropriate sides of the clip

   * rectangles.  This is not necessarily the best result, but works ok

   * and is fast.

   */

  clipminx = MIN_MWCOORD;

  clipminy = MIN_MWCOORD;

  clipmaxx = MAX_MWCOORD;

  clipmaxy = MAX_MWCOORD;

  count = clipcount;

  for (rp = cliprects; count-- > 0; rp++) {

        if ((x < rp->x) && (rp->x <= clipmaxx)) clipmaxx = rp->x - 1;

        temp = rp->x + rp->width - 1;

        if ((x > temp) && (temp >= clipminx)) clipminx = temp + 1;

        if ((y < rp->y) && (rp->y <= clipmaxy)) clipmaxy = rp->y - 1;

        temp = rp->y + rp->height - 1;

        if ((y > temp) && (temp >= clipminy)) clipminy = temp + 1;

  }

  clipresult = FALSE;

  return FALSE;

}

/* Check the area determined by the specified pair of points against the

 * list of clip rectangles.  The area will either be totally visible,

 * totally visible, or possibly partially visible.  This routine updates

 * the clip cache rectangle, and returns one of the following values:

 *      CLIP_VISIBLE            The whole rectangle is visible

 *      CLIP_INVISIBLE          The whole rectangle is invisible

 *      CLIP_PARTIAL            The rectangle may be partially visible

 * In the case that the area is totally visible, the cursor is removed

 * if it overlaps the clip area.

 */

int

GdClipArea(PSD psd,MWCOORD x1, MWCOORD y1, MWCOORD x2, MWCOORD y2)

{

  if ((x1 < clipminx) || (x1 > clipmaxx) ||

      (y1 < clipminy) || (y1 > clipmaxy))

        GdClipPoint(psd, x1, y1);

  if ((x2 >= clipminx) && (x2 <= clipmaxx) &&

      (y2 >= clipminy) && (y2 <= clipmaxy)) {

        if (!clipresult) return CLIP_INVISIBLE;

        GdCheckCursor(psd, x1, y1, x2, y2);

        return CLIP_VISIBLE;

  }

  return CLIP_PARTIAL;

}