lineto.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

		}
	    }
	  else
	    {
	      x--;
	      error = error + deltay;
	      if (deltax <= error)
		{
	  	  y--;
		  error = error - deltax;
		}
	    }
	  i++;
	}
    }
}

/*
 * @implemented
 */
BOOL STDCALL
EngLineTo(SURFOBJ *DestObj,
	  CLIPOBJ *Clip,
	  BRUSHOBJ *Brush,
	  LONG x1,
	  LONG y1,
	  LONG x2,
	  LONG y2,
	  RECTL *RectBounds,
	  MIX mix)
{
  LONG x, y, deltax, deltay, xchange, ychange, hx, vy;
  ULONG i;
  ULONG Pixel = Brush->iSolidColor;
  SURFOBJ *OutputObj;
  RECTL DestRect;
  POINTL Translate;
  INTENG_ENTER_LEAVE EnterLeave;
  RECT_ENUM RectEnum;
  BOOL EnumMore;

  if (x1 < x2)
    {
      DestRect.left = x1;
      DestRect.right = x2;
    }
  else
    {
      DestRect.left = x2;
      DestRect.right = x1 + 1;
    }
  if (y1 < y2)
    {
      DestRect.top = y1;
      DestRect.bottom = y2;
    }
  else
    {
      DestRect.top = y2;
      DestRect.bottom = y1 + 1;
    }

  if (! IntEngEnter(&EnterLeave, DestObj, &DestRect, FALSE, &Translate, &OutputObj))
    {
      return FALSE;
    }

  x1 += Translate.x;
  x2 += Translate.x;
  y1 += Translate.y;
  y2 += Translate.y;

  x = x1;
  y = y1;
  deltax = x2 - x1;
  deltay = y2 - y1;

  if (0 == deltax && 0 == deltay)
    {
      return TRUE;
    }

  if (deltax < 0)
    {
      xchange = -1;
      deltax = - deltax;
      hx = x2 + 1;
    }
  else
    {
      xchange = 1;
      hx = x1;
    }

  if (deltay < 0)
    {
      ychange = -1;
      deltay = - deltay;
      vy = y2 + 1;
    }
  else
    {
      ychange = 1;
      vy = y1;
    }

  if (y1 == y2)
    {
      CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0);
      do
	{
	  EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
	  for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top + Translate.y <= y1; i++)
	    {
              if (y1 < RectEnum.arcl[i].bottom + Translate.y &&
                  RectEnum.arcl[i].left + Translate.x <= hx + deltax &&
                  hx < RectEnum.arcl[i].right + Translate.x &&
                  max(hx, RectEnum.arcl[i].left + Translate.x) <
                  min(hx + deltax, RectEnum.arcl[i].right + Translate.x))
                {
                  DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_HLine(
                                       OutputObj,
                                       max(hx, RectEnum.arcl[i].left + Translate.x),
                                       min(hx + deltax, RectEnum.arcl[i].right + Translate.x),
                                       y1, Pixel);
               	}
	    }
	}
      while (EnumMore);
    }
  else if (x1 == x2)
    {
      CLIPOBJ_cEnumStart(Clip, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0);
      do
	{
	  EnumMore = CLIPOBJ_bEnum(Clip, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
	  for (i = 0; i < RectEnum.c; i++)
	    {
	      if (RectEnum.arcl[i].left + Translate.x <= x1 &&
                  x1 < RectEnum.arcl[i].right + Translate.x &&
	          RectEnum.arcl[i].top + Translate.y <= vy + deltay &&
	          vy < RectEnum.arcl[i].bottom + Translate.y)
		{
		  DibFunctionsForBitmapFormat[OutputObj->iBitmapFormat].DIB_VLine(
		                       OutputObj, x1,
		                       max(vy, RectEnum.arcl[i].top + Translate.y),
		                       min(vy + deltay, RectEnum.arcl[i].bottom + Translate.y),
		                       Pixel);
		}
	    }
	}
      while (EnumMore);
    }
  else
    {
      if (0 < xchange)
	{
	  if (0 < ychange)
	    {
	      NWtoSE(OutputObj, Clip, Brush, x, y, deltax, deltay, &Translate);
	    }
	  else
	    {
	      SWtoNE(OutputObj, Clip, Brush, x, y, deltax, deltay, &Translate);
	    }
	}
      else
	{
	  if (0 < ychange)
	    {
	      NEtoSW(OutputObj, Clip, Brush, x, y, deltax, deltay, &Translate);
	    }
	  else
	    {
	      SEtoNW(OutputObj, Clip, Brush, x, y, deltax, deltay, &Translate);
	    }
	}
    }

  return IntEngLeave(&EnterLeave);
}

BOOL STDCALL
IntEngLineTo(SURFOBJ *DestSurf,
	     CLIPOBJ *ClipObj,
	     BRUSHOBJ *Brush,
	     LONG x1,
	     LONG y1,
	     LONG x2,
	     LONG y2,
	     RECTL *RectBounds,
	     MIX Mix)
{
  BOOLEAN ret;
  BITMAPOBJ *DestObj;
  PGDIBRUSHINST GdiBrush;
  RECTL b;

  ASSERT(DestSurf);
  DestObj = CONTAINING_RECORD(DestSurf, BITMAPOBJ, SurfObj);
  ASSERT(DestObj);

  GdiBrush = CONTAINING_RECORD(
     Brush,
     GDIBRUSHINST,
     BrushObject);
  ASSERT(GdiBrush);
  ASSERT(GdiBrush->GdiBrushObject);

  if (GdiBrush->GdiBrushObject->flAttrs & GDIBRUSH_IS_NULL)
    return TRUE;

  /* No success yet */
  ret = FALSE;

  /* Clip lines totally outside the clip region. This is not done as an
   * optimization (there are very few lines drawn outside the region) but
   * as a workaround for what seems to be a problem in the CL54XX driver */
  if (NULL == ClipObj || DC_TRIVIAL == ClipObj->iDComplexity)
    {
      b.left = 0;
      b.right = DestSurf->sizlBitmap.cx;
      b.top = 0;
      b.bottom = DestSurf->sizlBitmap.cy;
    }
  else
    {
      b = ClipObj->rclBounds;
    }
  if ((x1 < b.left && x2 < b.left) || (b.right <= x1 && b.right <= x2) ||
      (y1 < b.top && y2 < b.top) || (b.bottom <= y1 && b.bottom <= y2))
    {
      return TRUE;
    }

  b.left = min(x1, x2);
  b.right = max(x1, x2);
  b.top = min(y1, y2);
  b.bottom = max(y1, y2);
  if (b.left == b.right) b.right++;
  if (b.top == b.bottom) b.bottom++;

  BITMAPOBJ_LockBitmapBits(DestObj);
  MouseSafetyOnDrawStart(DestSurf, x1, y1, x2, y2);

  if (DestObj->flHooks & HOOK_LINETO)
    {
    /* Call the driver's DrvLineTo */
    ret = GDIDEVFUNCS(DestSurf).LineTo(
      DestSurf, ClipObj, Brush, x1, y1, x2, y2, &b, Mix);
    }

#if 0
  if (! ret && (DestObj->flHooks & HOOK_STROKEPATH))
    {
      /* FIXME: Emulate LineTo using drivers DrvStrokePath and set ret on success */
    }
#endif

  if (! ret)
    {
      ret = EngLineTo(DestSurf, ClipObj, Brush, x1, y1, x2, y2, RectBounds, Mix);
    }

  MouseSafetyOnDrawEnd(DestSurf);
  BITMAPOBJ_UnlockBitmapBits(DestObj);

  return ret;
}

BOOL STDCALL
IntEngPolyline(SURFOBJ *DestSurf,
	       CLIPOBJ *Clip,
	       BRUSHOBJ *Brush,
	       CONST LPPOINT  pt,
               LONG dCount,
	       MIX Mix)
{
  LONG i;
  RECTL rect;
  BOOL ret = FALSE;

  //Draw the Polyline with a call to IntEngLineTo for each segment.
  for (i = 1; i < dCount; i++)
    {
      rect.left = min(pt[i-1].x, pt[i].x);
      rect.top = min(pt[i-1].y, pt[i].y);
      rect.right = max(pt[i-1].x, pt[i].x);
      rect.bottom = max(pt[i-1].y, pt[i].y);
      ret = IntEngLineTo(DestSurf,
	                 Clip,
	                 Brush,
                         pt[i-1].x,
	                 pt[i-1].y,
	                 pt[i].x,
	                 pt[i].y,
	                 &rect,
	                 Mix);
      if (!ret)
	{
	  break;
	}
    }

  return ret;
}

/* EOF */