Clip.c File Reference

#include <stdlib.h>
#include <X11/IntrinsicP.h>
#include <X11/Xmu/Xmu.h>

Include dependency graph for Clip.c:

Go to the source code of this file.

Defines
#define	XmuMax(a, b)   ((a) > (b) ? (a) : (b))
#define	XmuMin(a, b)   ((a) < (b) ? (a) : (b))
Functions
XmuArea *	XmuNewArea (int x1, int y1, int x2, int y2)
XmuArea *	XmuAreaDup (XmuArea *area)
XmuArea *	XmuAreaCopy (XmuArea *dst, XmuArea *src)
XmuArea *	XmuAreaNot (XmuArea *area, int x1, int y1, int x2, int y2)
XmuArea *	XmuAreaOrXor (XmuArea *dst, XmuArea *src, Bool or)
XmuArea *	XmuAreaAnd (XmuArea *dst, XmuArea *src)
Bool	XmuValidArea (XmuArea *area)
Bool	XmuValidScanline (XmuScanline *scanline)
Bool	XmuScanlineEqu (XmuScanline *s1, XmuScanline *s2)
XmuSegment *	XmuNewSegment (int x1, int x2)
void	XmuDestroySegmentList (XmuSegment *segment)
XmuScanline *	XmuScanlineCopy (XmuScanline *dst, XmuScanline *src)
Bool	XmuAppendSegment (XmuSegment *segment, XmuSegment *append)
XmuScanline *	XmuOptimizeScanline (XmuScanline *scanline)
XmuScanline *	XmuScanlineNot (XmuScanline *scanline, int minx, int maxx)
XmuScanline *	XmuScanlineOrSegment (XmuScanline *dst, XmuSegment *src)
XmuScanline *	XmuScanlineAndSegment (XmuScanline *dst, XmuSegment *src)
XmuScanline *	XmuScanlineXorSegment (XmuScanline *dst, XmuSegment *src)
XmuScanline *	XmuScanlineOr (XmuScanline *dst, XmuScanline *src)
XmuScanline *	XmuScanlineAnd (XmuScanline *dst, XmuScanline *src)
XmuScanline *	XmuScanlineXor (XmuScanline *dst, XmuScanline *src)
XmuScanline *	XmuNewScanline (int y, int x1, int x2)
void	XmuDestroyScanlineList (XmuScanline *scanline)
XmuArea *	XmuOptimizeArea (XmuArea *area)

---

Define Documentation

#define XmuMax	(	a,
		b		)	((a) > (b) ? (a) : (b))

Definition at line 34 of file Clip.c.

Referenced by XmuAreaAnd(), XmuScanlineAnd(), XmuScanlineAndSegment(), XmuScanlineXor(), and XmuScanlineXorSegment().

#define XmuMin	(	a,
		b		)	((a) < (b) ? (a) : (b))

Definition at line 35 of file Clip.c.

Referenced by XmuScanlineAndSegment(), XmuScanlineOr(), XmuScanlineOrSegment(), XmuScanlineXor(), and XmuScanlineXorSegment().

---

Function Documentation

Bool XmuAppendSegment	(	XmuSegment *	segment,
		XmuSegment *	append
	)

Definition at line 721 of file Clip.c.

References _XmuSegment::next, NULL, XmuDestroySegmentList(), XmuNewSegment(), and XmuValidSegment.

Referenced by XmuScanlineOr(), and XmuScanlineXor().

{
  if (!segment || !append)
    return (False);

  if (segment->next)
    /* Should not happen! */
    XmuDestroySegmentList(segment->next);

  while (append)
    {
      if (XmuValidSegment(append))
        {
          if ((segment->next = XmuNewSegment(append->x1, append->x2)) == NULL)
            return (False);
          segment = segment->next;
        }
      append = append->next;
    }

  return (True);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuArea* XmuAreaAnd	(	XmuArea *	dst,
		XmuArea *	src
	)

Definition at line 420 of file Clip.c.

References _XmuScanline::next, NULL, p, P, _XmuArea::scanline, top, XmuDestroyScanline, XmuDestroyScanlineList(), XmuMax, XmuNewScanline(), XmuOptimizeArea(), XmuScanlineAnd(), XmuScanlineCopy(), XmuValidArea(), z, and Z.

Referenced by XmuAreaNot().

{
  XmuScanline *z, *p, *Z, *P, *top;

  if (!dst || !src || dst == src)
    return (dst);
  if (!XmuValidArea(dst) || !XmuValidArea(src))
    {
      XmuDestroyScanlineList(dst->scanline);
      dst->scanline = (XmuScanline *)NULL;
      return (dst);
    }
  z = p = dst->scanline;
  Z = P = src->scanline;
  top = XmuNewScanline(dst->scanline->y, 0, 0);
  XmuScanlineCopy(top, dst->scanline);

  while (z)
    {
      while (Z->next && Z->next->y < z->y)
        {
          P = Z;
          Z = Z->next;
          if (Z->y >= p->y)
            {
              XmuScanline *q = XmuNewScanline(Z->y, 0, 0); 
              XmuScanlineCopy(q, Z);

              XmuScanlineAnd(q, top);
              if (p->y != P->y)
                {
                  XmuScanlineAnd(p, P);
                  p->y = XmuMax(p->y, P->y);
                }
              p->next = q;
              q->next = z;
              p = q;
            }
        }
      if (!z->next)
        {
          z->y = XmuMax(z->y, Z->y);
          break;
        }
      while (Z->y >= z->next->y)
        {
          if (z == dst->scanline)
            {
              p = dst->scanline = dst->scanline->next;
              XmuDestroyScanline(z);
              z = dst->scanline;
            }
          else
            {
              p->next = z->next;
              XmuDestroyScanline(z);
              z = p;
            }
          if (!z || !z->next)
            {
              XmuOptimizeArea(dst);
              XmuDestroyScanline(top);

              return (dst);
            }
        }
      if (Z->y > p->y)
        z->y = XmuMax(z->y, Z->y);
      if (top->y != z->y)
        {
          XmuScanlineCopy(top, z);
          top->y = z->y;
        }
      XmuScanlineAnd(z, Z);
      p = z;
      z = z->next;
    }
  XmuOptimizeArea(dst);
  XmuDestroyScanline(top);

  return (dst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuArea* XmuAreaCopy	(	XmuArea *	dst,
		XmuArea *	src
	)

Definition at line 103 of file Clip.c.

References NULL, p, _XmuArea::scanline, XmuDestroyScanlineList(), XmuNewScanline(), XmuScanlineCopy(), z, and Z.

Referenced by XmuAreaDup(), and XmuAreaOrXor().

{
  XmuScanline *z, *p, *Z;

  if (!dst || !src || dst == src)
    return (dst);

  z = p = dst->scanline;
  Z = src->scanline;

  /*CONSTCOND*/
  while (1)
    {
      if (!Z)
        {
          if (z == dst->scanline)
            {
              XmuDestroyScanlineList(dst->scanline);
              dst->scanline = (XmuScanline *)NULL;
            }
          else
            {
              XmuDestroyScanlineList(p->next);
              p->next = (XmuScanline *)NULL;
            }
          return (dst);
        }
      if (z)
        {
          XmuScanlineCopy(z, Z);
          z->y = Z->y;
        }
      else
        {
          z = XmuNewScanline(Z->y, 0, 0);
          XmuScanlineCopy(z, Z);
          if (p == dst->scanline && !dst->scanline)
            p = dst->scanline = z;
          else
            p->next = z;
        }
      p = z;
      z = z->next;
      Z = Z->next;
    }

  return (dst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuArea* XmuAreaDup

(

XmuArea *

area

)

Definition at line 78 of file Clip.c.

References NULL, XmuAreaCopy(), and XmuCreateArea.

{
  XmuArea *dst;

  if (!area)
    return ((XmuArea *)NULL);

  dst = XmuCreateArea();
  XmuAreaCopy(dst, area);
  return (dst);
}

Here is the call graph for this function:

XmuArea* XmuAreaNot	(	XmuArea *	area,
		int	x1,
		int	y1,
		int	x2,
		int	y2
	)

Definition at line 181 of file Clip.c.

References _XmuScanline::next, NULL, XmuAreaAnd(), XmuDestroyArea, XmuDestroyScanline, XmuDestroyScanlineList(), XmuNewArea(), XmuNewScanline(), XmuOptimizeArea(), XmuScanlineNot(), and z.

{
  XmuScanline *z;
  XmuArea *and;

  if (!area)
    return (area);

  if (x1 > x2)
    {
      x1 ^= x2; x2 ^= x1; x1 ^= x2;
    }
    if (y1 > y2)
      {
        y1 ^= y2; y2 ^= y1; y1 ^= y2;
      }
    if (!area->scanline)
      {
        if ((area->scanline = XmuNewScanline(y1, x1, x2)) != NULL)
          area->scanline->next = XmuNewScanline(y2, 0, 0);
        return (area);
      }
    and = XmuNewArea(x1, y1, x2, y2);
    XmuAreaAnd(area, and);
    XmuDestroyArea(and);
    z = area->scanline;
    if (z->y != y1)
      {
        XmuScanline *q = XmuNewScanline(y1, x1, x2);
        q->next = z;
        area->scanline = q;
      }
    else
      {
        area->scanline = area->scanline->next;
        XmuDestroyScanline(z);
        XmuOptimizeArea(area);
        if((z = area->scanline) == (XmuScanline *)NULL)
          return (area);
      }

    /* CONSTCOND */
    while (1)
      {
        XmuScanlineNot(z, x1, x2);
        if (!z->next)
          {
            z->next = XmuNewScanline(y2, 0, 0);
            break;
          }
        if (z->next->y == y2)
          {
            XmuDestroyScanlineList(z->next);
            z->next = XmuNewScanline(y2, 0, 0);
            break;
          }
        z = z->next;
      }

    return (area);
}

Here is the call graph for this function:

XmuArea* XmuAreaOrXor	(	XmuArea *	dst,
		XmuArea *	src,
		Bool	or
	)

Definition at line 256 of file Clip.c.

References _XmuScanline::next, NULL, p, P, _XmuArea::scanline, top, XmuAreaCopy(), XmuDestroyScanline, XmuDestroyScanlineList(), XmuNewScanline(), XmuOptimizeArea(), XmuScanlineCopy(), XmuScanlineEqu(), XmuScanlineOr(), XmuScanlineXor(), XmuValidArea(), XmuValidScanline(), _XmuScanline::y, z, and Z.

{
  XmuScanline *z, *p, *Z, *P, *ins, *top;

  if (!dst || !src)
    return (dst);

  if (dst == src)
    {
      if (or)
        return (dst);
      XmuDestroyScanlineList(dst->scanline);
      dst->scanline = (XmuScanline *)NULL;
      return (dst);
    }
  if (!XmuValidArea(src))
    return (dst);
  if (!XmuValidArea(dst))
    {
      XmuAreaCopy(dst, src);
      return (dst);
    }

  p = z = dst->scanline;
  P = Z = src->scanline;
  ins = XmuNewScanline(dst->scanline->y, 0, 0);
  top = XmuNewScanline(dst->scanline->y, 0, 0);
  XmuScanlineCopy(ins, dst->scanline);
  XmuScanlineCopy(top, dst->scanline);

  /*CONSTCOND*/
  while (1)
    {
      if (!Z)
        break;
      else if (Z->y < z->y)
        {
          XmuScanline  *q = XmuNewScanline(Z->y, 0, 0);
          XmuScanlineCopy(q, Z);

          if (z == dst->scanline)
            {
              dst->scanline = p = q;
              q->next = z;
            }
          else
            {
              p->next = q;
              q->next = z;
              if (Z->y >= p->y)
                {
                  if (ins->y >= top->y
                      && (p->y != P->y || !XmuScanlineEqu(p, P)
                          || (ins->y <= P->y && !XmuScanlineEqu(ins, P))))
                    {
                      if (or)
                        XmuScanlineOr(q, ins);
                      else
                        XmuScanlineXor(q, ins);
                    }
                  else if (Z->y >= top->y
                           && (top->y == p->y || top->y > ins->y
                               || !XmuValidScanline(Z)
                               || (p->y == P->y && XmuValidScanline(p)
                                   && XmuValidScanline(P))
                               || XmuScanlineEqu(ins, top)))
                    {
                      if (or)
                        XmuScanlineOr(q, top);
                      else
                        XmuScanlineXor(q, top);
                    }
                  if (ins->y != p->y && p->y != P->y)
                    {
                      XmuScanlineCopy(ins, p);
                      ins->y = p->y;
                    }
                }
              if (!XmuValidScanline(p) || Z->y <= p->y)
                {
                  XmuScanlineCopy(top, p);
                  top->y = p->y;
                }
              p = q;
            }
          P = Z;
          Z = Z->next;
          continue;
        }
      else if (Z->y == z->y)
        {
          if (top->y != z->y)
            {
              XmuScanlineCopy(top, z);
              top->y = z->y;
            }
          if (or)
            XmuScanlineOr(z, Z);
          else
            XmuScanlineXor(z, Z);
          P = Z;
          Z = Z->next;
        }
      else if (P != Z)          /* && Z->y > z->y */
        {
          if (top->y == ins->y && top->y != z->y)
            {
              XmuScanlineCopy(top, z);
              top->y = z->y;
            }
          if (ins->y != z->y)
            {
              XmuScanlineCopy(ins, z);
              ins->y = z->y;
            }
          if (or)
            XmuScanlineOr(z, P);
          else
            XmuScanlineXor(z, P);
        }
      else if (ins->y != z->y)
        {
          XmuScanlineCopy(ins, z);
          ins->y = z->y;
        }
      p = z;
      z = z->next;
      if (!z)
        {
          while (Z)
            {
              p->next = XmuNewScanline(Z->y, 0, 0);
              XmuScanlineCopy(p->next, Z);
              p = p->next;
              Z = Z->next;
            }
          break;
        }
      else if (ins->y > top->y && !XmuValidScanline(z)
               && XmuValidScanline(ins))
        {
          XmuScanlineCopy(top, ins);
          top->y = ins->y;
        }
    }
  XmuOptimizeArea(dst);
  XmuDestroyScanline(ins);
  XmuDestroyScanline(top);

  return (dst);
}

Here is the call graph for this function:

void XmuDestroyScanlineList

(

XmuScanline *

scanline

)

Definition at line 1535 of file Clip.c.

References _XmuScanline::next, XmuDestroyScanline, and z.

Referenced by XmuAreaAnd(), XmuAreaCopy(), XmuAreaNot(), XmuAreaOrXor(), and XmuOptimizeArea().

{
  XmuScanline *z;

  if (!scanline)
    return;

  while (scanline)
    {
      z = scanline;
      scanline = scanline->next;
      XmuDestroyScanline(z);
    }
}

Here is the caller graph for this function:

void XmuDestroySegmentList

(

XmuSegment *

segment

)

Definition at line 640 of file Clip.c.

References _XmuSegment::next, XmuDestroySegment, and z.

Referenced by XmuAppendSegment(), XmuScanlineAnd(), XmuScanlineAndSegment(), XmuScanlineCopy(), and XmuScanlineXor().

{
  XmuSegment *z;

  if (!segment)
    return;

  while (segment)
    {
      z = segment;
      segment = segment->next;
      XmuDestroySegment(z);
    }
}

Here is the caller graph for this function:

XmuArea* XmuNewArea	(	int	x1,
		int	y1,
		int	x2,
		int	y2
	)

Definition at line 51 of file Clip.c.

References _XmuScanline::next, NULL, _XmuArea::scanline, and XmuNewScanline().

Referenced by XmuAreaNot().

{
  XmuArea *area;

  area = (XmuArea *)XtMalloc(sizeof(XmuArea));
  if (x2 > x1 && y2 > y1)
    {
      area->scanline = XmuNewScanline(y1, x1, x2);
      area->scanline->next = XmuNewScanline(y2, 0, 0);
    }
  else
    area->scanline = (XmuScanline *)NULL;

  return (area);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuScanline* XmuNewScanline	(	int	y,
		int	x1,
		int	x2
	)

Definition at line 1503 of file Clip.c.

References _XmuScanline::next, NULL, _XmuScanline::segment, XmuNewSegment(), and _XmuScanline::y.

Referenced by XmuAreaAnd(), XmuAreaCopy(), XmuAreaNot(), XmuAreaOrXor(), and XmuNewArea().

{
  XmuScanline *scanline;

  scanline = (XmuScanline *)XtMalloc(sizeof(XmuScanline));
  scanline->y = y;
  if (x1 < x2)
    scanline->segment = XmuNewSegment(x1, x2);
  else
    scanline->segment = (XmuSegment *)NULL;

  scanline->next = (XmuScanline *)NULL;

  return (scanline);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuSegment* XmuNewSegment	(	int	x1,
		int	x2
	)

Definition at line 615 of file Clip.c.

References NULL, and _XmuSegment::x1.

Referenced by XmuAppendSegment(), XmuNewScanline(), XmuScanlineAnd(), XmuScanlineCopy(), XmuScanlineNot(), XmuScanlineOr(), XmuScanlineOrSegment(), XmuScanlineXor(), and XmuScanlineXorSegment().

{
  XmuSegment *segment;

  if ((segment = (XmuSegment *)XtMalloc(sizeof(XmuSegment))) == NULL)
    return (segment);

  segment->x1 = x1;
  segment->x2 = x2;
  segment->next = (XmuSegment *)NULL;

  return (segment);
}

Here is the caller graph for this function:

XmuArea* XmuOptimizeArea

(

XmuArea *

area

)

Definition at line 1564 of file Clip.c.

References _XmuScanline::next, pr, _XmuArea::scanline, XmuDestroyScanline, XmuDestroyScanlineList(), XmuScanlineEqu(), XmuValidScanline(), and _XmuScanline::y.

Referenced by XmuAreaAnd(), XmuAreaNot(), and XmuAreaOrXor().

{
  XmuScanline *pr, *at;

  if (!area || !area->scanline)
    return (area);

  if (!area->scanline->next)
    {
      XmuDestroyScanlineList(area->scanline);
      area->scanline = (XmuScanline *)0;
      return (area);
    }

  pr = area->scanline;
  at = area->scanline->next;
  while (area->scanline && (!XmuValidScanline(area->scanline)
                            || (area->scanline->next && area->scanline->y
                                >= area->scanline->next->y)))
    {
      area->scanline = area->scanline->next;
      XmuDestroyScanline(pr);
      pr = area->scanline;
      if (pr)
        at = pr->next;
    }

  for (; at; pr = at, at = at->next)
    {
      if (XmuScanlineEqu(at, pr)
          || (!XmuValidScanline(at) && !XmuValidScanline(pr))
          || (at->next && at->y >= at->next->y))
        {
          pr->next = at->next;
          XmuDestroyScanline(at);
          at = pr;
        }
    }
  if (pr && XmuValidScanline(pr))
    {
      XmuDestroySegmentList(pr->segment);
      pr->segment = (XmuSegment *)NULL;
    }
  if (area->scanline && !area->scanline->next)
    {
      XmuDestroyScanlineList(area->scanline);
      area->scanline = (XmuScanline *)NULL;
    }

  return (area);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuScanline* XmuOptimizeScanline

(

XmuScanline *

scanline

)

Definition at line 757 of file Clip.c.

References _XmuSegment::next, p, s, _XmuScanline::segment, XmuDestroySegment, XmuValidSegment, and z.

Referenced by XmuScanlineNot().

{
  XmuSegment *z, *p;

  while (scanline->segment && !XmuValidSegment(scanline->segment))
    {
      XmuSegment *s = scanline->segment;

      scanline->segment = scanline->segment->next;
      XmuDestroySegment(s);
    }
  for (z = p = scanline->segment; z; p = z, z = z->next)
    {
      if (!XmuValidSegment(z))
        {
          p->next = z->next;
          XmuDestroySegment(z);
          z = p;
        }
    }
  return (scanline);
}

Here is the caller graph for this function:

XmuScanline* XmuScanlineAnd	(	XmuScanline *	dst,
		XmuScanline *	src
	)

Definition at line 1263 of file Clip.c.

References _XmuSegment::next, NULL, p, _XmuScanline::segment, XmuDestroySegment, XmuDestroySegmentList(), XmuMax, XmuNewSegment(), XmuValidSegment, z, and Z.

Referenced by XmuAreaAnd(), and XmuScanlineNot().

{
  XmuSegment  *z, *p, *Z;

  if (!dst || !src || dst == src || !dst->segment) {
        return (dst);
  }
  if (!src->segment)
    {
      XmuDestroySegmentList(dst->segment);
      dst->segment = (XmuSegment *)NULL;
      return (dst);
    }
  z = p = dst->segment;
  Z = src->segment;

  while (z)
    {
      while (!XmuValidSegment(Z) || Z->x2 <= z->x1)
        {
          Z = Z->next;
          if (!Z)
            {
              if (z == dst->segment)
                dst->segment = (XmuSegment *)NULL;
              else
                p->next = (XmuSegment *)0;
              XmuDestroySegmentList(z);
              return (dst);
            }
        }
      if (Z->x1 >= z->x2)
        {
          if (z == dst->segment)
            {
              p = dst->segment = dst->segment->next;
              XmuDestroySegment(z);
              z = dst->segment;
            }
          else
            {
              p->next = z->next;
              XmuDestroySegment(z);
              z = p->next;
            }
          if (!z)
            return (dst);
          else
            continue;
        }
        z->x1 = XmuMax(z->x1, Z->x1);
        if (z->x2 > Z->x2)
          {
            if (Z->next)
              {
                XmuSegment *q = XmuNewSegment(Z->x2, z->x2);

                q->next = z->next;
                z->next = q;
              }
            z->x2 = Z->x2;
          }
        p = z;
        z = z->next;
    }

  return (dst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuScanline* XmuScanlineAndSegment	(	XmuScanline *	dst,
		XmuSegment *	src
	)

Definition at line 963 of file Clip.c.

References NULL, p, _XmuSegment::x1, _XmuSegment::x2, XmuDestroySegment, XmuDestroySegmentList(), XmuMax, XmuMin, XmuValidSegment, and z.

{
  XmuSegment *z, *p;

  if (!dst || !src)
    return (dst);

  if (!XmuValidSegment(src))
    {
      XmuDestroySegmentList(dst->segment);
      dst->segment = (XmuSegment *)NULL;
      return (dst);
    }
  if (!dst->segment)
    return (dst);

  z = p = dst->segment;
  while (z)
    {
      if (src->x2 <= z->x1 || src->x1 >= z->x2)
        {
          if (z == dst->segment)
            {
              p = dst->segment = dst->segment->next;
              XmuDestroySegment(z);
              z = dst->segment;
              continue;
            }
          else
            {
              p->next = z->next;
              XmuDestroySegment(z);
              z = p;
            }
        }
      else
        {
          z->x1 = XmuMax(z->x1, src->x1);
          z->x2 = XmuMin(z->x2, src->x2);
        }
      p = z;
      z = z->next;
    }

  return (dst);
}

Here is the call graph for this function:

XmuScanline* XmuScanlineCopy	(	XmuScanline *	dst,
		XmuScanline *	src
	)

Definition at line 667 of file Clip.c.

References NULL, p, _XmuScanline::segment, XmuDestroySegmentList(), XmuNewSegment(), z, and Z.

Referenced by XmuAreaAnd(), XmuAreaCopy(), XmuAreaOrXor(), XmuScanlineOr(), and XmuScanlineXor().

{
  XmuSegment *z, *p, *Z;

  if (!dst || !src || dst == src)
    return (dst);

  z = p = dst->segment;
  Z = src->segment;

  /*CONSTCOND*/
  while (1)
    {
      if (!Z)
        {
          if (z == dst->segment)
            dst->segment = (XmuSegment *)NULL;
          else
            p->next = (XmuSegment *)NULL;
          XmuDestroySegmentList(z);
          return (dst);
        }
      if (z)
        {
          z->x1 = Z->x1;
          z->x2 = Z->x2;
        }
      else
        {
          z = XmuNewSegment(Z->x1, Z->x2);
          if (p == dst->segment && !dst->segment)
            p = dst->segment = z;
          else
            p->next = z;
        }
      p = z;
      z = z->next;
      Z = Z->next;
    }
  /*NOTREACHED*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool XmuScanlineEqu	(	XmuScanline *	s1,
		XmuScanline *	s2
	)

Definition at line 573 of file Clip.c.

References s1, s2, XmuSegmentEqu, z, and Z.

Referenced by XmuAreaOrXor(), and XmuOptimizeArea().

{
  XmuSegment *z, *Z;

  if ((!s1 && !s2) || s1 == s2)
    return (True);
  if (!s1 || !s2)
    return (False);

  z = s1->segment;
  Z = s2->segment;

  /*CONSTCOND*/
  while (1)
    {
      if (!z && !Z)
        return (True);
      if (!z || !Z)
        return (False);
      if (!XmuSegmentEqu(z, Z))
        return (False);
      z = z->next;
      Z = Z->next;
    }
  /*NOTREACHED*/
}

Here is the caller graph for this function:

XmuScanline* XmuScanlineNot	(	XmuScanline *	scanline,
		int	minx,
		int	maxx
	)

Definition at line 796 of file Clip.c.

References _XmuSegment::next, NULL, _XmuScanline::segment, x, _XmuSegment::x1, _XmuSegment::x2, XmuDestroySegment, XmuNewSegment(), XmuOptimizeScanline(), XmuScanlineAnd(), and z.

Referenced by XmuAreaNot().

{
  XmuSegment *z;
  static XmuSegment x = { 0, 0, 0 };
  static XmuScanline and = { 0, &x, 0 };

  if (!scanline)
    return (scanline);

  XmuOptimizeScanline(scanline);
  if (minx > maxx)
    {
      minx ^= maxx; maxx ^= minx; minx ^= maxx;
    }
  and.segment->x1 = minx;
  and.segment->x2 = maxx;
  XmuScanlineAnd(scanline, &and);
  if (!scanline->segment)
    {
      scanline->segment = XmuNewSegment(minx, maxx);
      return (scanline);
    }
  z = scanline->segment;
  if (z->x1 != minx)
    {
      XmuSegment *q = XmuNewSegment(minx, z->x1);

      q->next = z;
      scanline->segment = q;
    }

  /*CONSTCOND*/
  while (1)
    {
      z->x1 = z->x2;
      if (!z->next)
        {
          z->x2 = maxx;
          break;
        }
      z->x2 = z->next->x1;
      if (z->next->x2 == maxx)
        {
          XmuDestroySegment(z->next);
          z->next = (XmuSegment *)NULL;
          break;
        }
      z = z->next;
    }

  return (scanline);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuScanline* XmuScanlineOr	(	XmuScanline *	dst,
		XmuScanline *	src
	)

Definition at line 1133 of file Clip.c.

References _XmuSegment::next, NULL, p, _XmuScanline::segment, _XmuSegment::x1, _XmuSegment::x2, XmuAppendSegment(), XmuDestroySegment, XmuMin, XmuNewSegment(), XmuScanlineCopy(), XmuValidSegment, z, and Z.

Referenced by XmuAreaOrXor().

{
  XmuSegment *z, *p, *Z, ins;

  if (!src || !src->segment || !dst || dst == src)
    return (dst);
  if (!dst->segment)
    {
      XmuScanlineCopy(dst, src);
      return (dst);
    }

  z = p = dst->segment;
  Z = src->segment;
  ins.x1 = Z->x1;
  ins.x2 = Z->x2;

  /*CONSTCOND*/
  while (1)
    {
      while (!XmuValidSegment((&ins)))
        {
          if ((Z = Z->next) == (XmuSegment *)NULL)
            return (dst);
          ins.x1 = Z->x1;
          ins.x2 = Z->x2;
        }
        if (!z)
          {
            XmuSegment *q = XmuNewSegment(ins.x1, ins.x2);

            if (p == dst->segment && z == p)
              dst->segment = p = q;
            else
              {
                p->next = q;
                p = q;
              }
            Z = Z->next;
            XmuAppendSegment(p, Z);
            break;
          }
        else if (ins.x2 < z->x1)
          {
            XmuSegment *r = XmuNewSegment(ins.x1, ins.x2);

            if (p == dst->segment && z == p)
              {
                r->next = dst->segment;
                dst->segment = p = r;
              }
            else
              {
                p->next = r;
                r->next = z;
                p = r;
              }
            Z = Z->next;
            if (!Z)
              break;
            else
              {
                ins.x1 = Z->x1;
                ins.x2 = Z->x2;
                continue;
              }
          }
        else if (ins.x2 <= z->x2)
          {
            z->x1 = XmuMin(z->x1, ins.x1);
            Z = Z->next;
            if (!Z)
              break;
            else
              {
                ins.x1 = Z->x1;
                ins.x2 = Z->x2;
                continue;
              }
          }
        else if (ins.x1 <= z->x2)
          {
            ins.x1 = XmuMin(z->x1, ins.x1);
            if (!z->next)
              {
                z->x1 = ins.x1;
                z->x2 = ins.x2;
                p = z;
                Z = Z->next;
                XmuAppendSegment(p, Z);
                break;
              }
            else
              {
                if (z == dst->segment)
                  {
                    p = dst->segment = dst->segment->next;
                    XmuDestroySegment(z);
                    z = p;
                    continue;
                  }
                else
                  {
                    p->next = z->next;
                    XmuDestroySegment(z);
                    z = p;
                  }
              }
          }
        p = z;
        z = z->next;
    }

  return (dst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuScanline* XmuScanlineOrSegment	(	XmuScanline *	dst,
		XmuSegment *	src
	)

Definition at line 865 of file Clip.c.

References _XmuSegment::next, p, _XmuSegment::x1, _XmuSegment::x2, XmuDestroySegment, XmuMin, XmuNewSegment(), XmuValidSegment, and z.

{
  XmuSegment *z, *p, ins;

  if (!src || !dst || !XmuValidSegment(src))
    return (dst);

  if (!dst->segment)
    {
      dst->segment = XmuNewSegment(src->x1, src->x2);
      return (dst);
    }

  z = p = dst->segment;
  ins.x1 = src->x1;
  ins.x2 = src->x2;

  /*CONSTCOND*/
  while (1)
    {
      if (!z)
        {
            XmuSegment *q = XmuNewSegment(ins.x1, ins.x2);

            if (p == dst->segment && z == p)
              dst->segment = q;
            else
              p->next = q;
            break;
        }
      else if (ins.x2 < z->x1)
        {
          XmuSegment *q = XmuNewSegment(ins.x1, ins.x2);

          if (p == dst->segment && z == p)
            {
              q->next = dst->segment;
              dst->segment = q;
            }
          else
            {
              p->next = q;
              q->next = z;
            }
          break;
        }
      else if (ins.x2 <= z->x2)
        {
          z->x1 = XmuMin(z->x1, ins.x1);
          break;
        }
      else if (ins.x1 <= z->x2)
        {
          ins.x1 = XmuMin(z->x1, ins.x1);
          if (!z->next)
            {
              z->x1 = ins.x1;
              z->x2 = ins.x2;
              break;
            }
          else
            {
              if (z == dst->segment)
                {
                  p = dst->segment = dst->segment->next;
                  XmuDestroySegment(z);
                  z = dst->segment;
                  continue;
                }
              else
                {
                  p->next = z->next;
                  XmuDestroySegment(z);
                  z = p;
                }
            }
        }
      p = z;
      z = z->next;
    }

  return (dst);
}

Here is the call graph for this function:

XmuScanline* XmuScanlineXor	(	XmuScanline *	dst,
		XmuScanline *	src
	)

Definition at line 1346 of file Clip.c.

References _XmuSegment::next, NULL, p, _XmuScanline::segment, _XmuSegment::x1, _XmuSegment::x2, XmuAppendSegment(), XmuDestroySegment, XmuDestroySegmentList(), XmuMax, XmuMin, XmuNewSegment(), XmuScanlineCopy(), XmuValidSegment, z, and Z.

Referenced by XmuAreaOrXor().

{
  XmuSegment *z, *p, *Z, ins;
  int tmp1, tmp2;

  if (!src || !dst || !src->segment)
    return (dst);
  if (src == dst)
    {
      XmuDestroySegmentList(dst->segment);
      dst->segment = (XmuSegment *)NULL;
      return (dst);
    }
  if (!dst->segment)
    {
      XmuScanlineCopy(dst, src);
      return (dst);
    }

  z = p = dst->segment;
  Z = src->segment;
  ins.x1 = Z->x1;
  ins.x2 = Z->x2;

  /*CONSTCOND*/
  while (1)
    {
      while (!XmuValidSegment((&ins)))
        {
          if ((Z = Z->next) == (XmuSegment *)NULL)
            return (dst);
          ins.x1 = Z->x1;
          ins.x2 = Z->x2;
        }
      if (!z)
        {
          XmuSegment *q = XmuNewSegment(ins.x1, ins.x2);

            if (!dst->segment)
              dst->segment = q;
            else
              p->next = q;
            p = q;
            Z = Z->next;
            XmuAppendSegment(p, Z);
            break;
        }
      else if (ins.x2 < z->x1)
        {
          XmuSegment *q = XmuNewSegment(ins.x1, ins.x2);

          q->next = z;
          if (z == dst->segment)
            dst->segment = q;
          else
            p->next = q;
          if ((Z = Z->next) == (XmuSegment *)NULL)
            return (dst);

          p = q;
          ins.x1 = Z->x1;
          ins.x2 = Z->x2;
          continue;
        }
      else if (ins.x2 == z->x1)
        {
          z->x1 = ins.x1;
          if ((Z = Z->next) == (XmuSegment *)NULL)
            break;
          ins.x1 = Z->x1;
          ins.x2 = Z->x2;
          continue;
        }
      else if (ins.x1 < z->x2)
        {
          if (ins.x1 == z->x1)
            {
              if (ins.x2 < z->x2)
                {
                  z->x1 = ins.x2;
                  if ((Z = Z->next) == (XmuSegment *)NULL)
                    break;
                  ins.x1 = Z->x1;
                  ins.x2 = Z->x2;
                  continue;
                }
              else
                {
                  ins.x1 = z->x2;
                  if (z == dst->segment)
                    p = dst->segment = dst->segment->next;
                  else
                    p->next = z->next;
                  XmuDestroySegment(z);
                  z = p;
                  continue;
                }
            }
          else
            {
              if (Z->x2 < z->x2)
                {
                  XmuSegment  *q = XmuNewSegment(XmuMin(ins.x1, z->x1),
                                                 XmuMax(z->x1, ins.x1));

                  q->next = z;
                  if (z == dst->segment)
                    dst->segment = q;
                  else
                    p->next = q;
                  ins.x1 = z->x2;
                  z->x1 = ins.x2;
                  p = q;
                  continue;
                }
              else
                {
                  tmp1 = ins.x2;
                  tmp2 = z->x2;
                  ins.x2 = XmuMax(ins.x2, z->x2);
                  z->x2 = XmuMax(z->x1, ins.x1);
                  z->x1 = XmuMin(ins.x1, z->x1);
                  ins.x1 = XmuMin(tmp1, tmp2);
                }
            }
        }
      else if (ins.x1 == z->x2)
        {
          ins.x1 = z->x1;
          if (z == dst->segment)
            p = dst->segment = dst->segment->next;
          else
            p->next = z->next;
          XmuDestroySegment(z);
          z = p;
          continue;
        }
      p = z;
      z = z->next;
    }

  return (dst);
}

Here is the call graph for this function:

Here is the caller graph for this function:

XmuScanline* XmuScanlineXorSegment	(	XmuScanline *	dst,
		XmuSegment *	src
	)

Definition at line 1024 of file Clip.c.

References _XmuSegment::next, p, _XmuSegment::x1, _XmuSegment::x2, XmuDestroySegment, XmuMax, XmuMin, XmuNewSegment(), XmuValidSegment, and z.

{
  XmuSegment *p, *z, ins;
  int tmp1, tmp2;

  if (!dst || !src || !XmuValidSegment(src))
    return (dst);
  if (!dst->segment)
    {
      dst->segment = XmuNewSegment(src->x1, src->x2);
      return (dst);
    }

  p = z = dst->segment;
  ins.x1 = src->x1;
  ins.x2 = src->x2;

  /*CONSTCOND*/
  while (1)
    {
      if (!XmuValidSegment((&ins)))
        break;
      if (!z || ins.x2 < z->x1)
        {
          XmuSegment *q = XmuNewSegment(ins.x1, ins.x2);

          q->next = z;
          if (z == dst->segment)
            dst->segment = q;
          else
            p->next = q;
          break;
        }
      else if (ins.x2 == z->x1)
        {
          z->x1 = ins.x1;
          break;
        }
      else if (ins.x1 < z->x2)
        {
          if (ins.x1 < z->x1)
            {
              tmp1 = ins.x2;
              tmp2 = z->x2;
              ins.x2 = XmuMax(ins.x2, z->x2);
              z->x2 = z->x1;
              z->x1 = ins.x1;
              ins.x1 = XmuMin(tmp1, tmp2);
            }
          else if (ins.x1 > z->x1)
            {
              tmp1 = ins.x1;
              ins.x1 = XmuMin(ins.x2, z->x2);
              ins.x2 = XmuMax(z->x2, ins.x2);
              z->x2 = tmp1;
            }
          else  /* ins.x1 == z->x1 */
            {
              if (ins.x2 < z->x2)
                {
                  z->x1 = ins.x2;
                  break;
                }
              else
                {
                  ins.x1 = z->x2;
                  if (z == dst->segment)
                    p = dst->segment = dst->segment->next;
                  else
                    p->next = z->next;
                  XmuDestroySegment(z);
                  z = p;
                  continue;
                }
            }
        }
      else if (ins.x1 == z->x2)
        {
          ins.x1 = z->x1;
          if (z == dst->segment)
            p = dst->segment = dst->segment->next;
          else
            p->next = z->next;
          XmuDestroySegment(z);
          z = p;
          continue;
        }
      p = z;
      z = z->next;
    }

  return (dst);
}

Here is the call graph for this function:

Bool XmuValidArea

(

XmuArea *

area

)

Definition at line 514 of file Clip.c.

References _XmuScanline::next, _XmuArea::scanline, and XmuValidScanline().

Referenced by XmuAreaAnd(), and XmuAreaOrXor().

{
  XmuScanline *at;

  if (!area || !area->scanline)
    return (False);

  at = area->scanline;
  while (at)
    {
      if (XmuValidScanline(at))
        return (True);
      at = at->next;
    }

  return (False);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Bool XmuValidScanline

(

XmuScanline *

scanline

)

Definition at line 543 of file Clip.c.

References _XmuSegment::next, _XmuScanline::segment, XmuValidSegment, and z.

Referenced by XmuAreaOrXor(), XmuOptimizeArea(), and XmuValidArea().

{
  XmuSegment *z;

  if (!scanline)
    return (False);

  z = scanline->segment;
  while (z)
    {
      if (XmuValidSegment(z))
        return (True);
      z = z->next;
    }

  return (False);
}

Here is the caller graph for this function:

---