cfb8line.c

远程桌面连接工具

#else
	    y1_or_e1 = y2;
	    x1_or_len = x2;
#endif /* SAVE_X2Y2 */
	    c2 = *ppt++;

	    if (isClipped (c2, upperleft, lowerright))
		break;
#ifdef SAVE_X2Y2
	    intToCoord(c2,x2,y2);
#endif
	    CalcLineDeltas(X1, Y1, X2, Y2, x1_or_len, y1_or_e1,
			   stepmajor, stepminor, 1, NWIDTH(nwidth), octant);
	}
#endif /* !PREVIOUS */
#endif /* POLYSEGMENT */

#ifdef POLYSEGMENT
	CalcLineDeltas(X1, Y1, X2, Y2, x1_or_len, y1_or_e1,
		       stepmajor, stepminor, 1, NWIDTH(nwidth), octant);
	/*
	 * although the horizontal code works for polyline, it
	 * slows down 10 pixel lines by 15%.  Thus, this
	 * code is optimized for horizontal segments and
	 * random orientation lines, which seems like a reasonable
	 * assumption
	 */
	if (y1_or_e1 != 0)
	{
#endif /* POLYSEGMENT */
	if (x1_or_len < y1_or_e1)
	{
#ifdef REARRANGE
	    register int	e3;
#endif

	    e3 = x1_or_len;
	    x1_or_len = y1_or_e1;
	    y1_or_e1 = e3;

	    e3 = stepminor;
	    stepminor = stepmajor;
	    stepmajor = e3;
	    SetYMajorOctant(octant);
	}

	e = -x1_or_len;
#ifdef POLYSEGMENT
	if (!capStyle)
	    x1_or_len--;
#endif

	{
#ifdef REARRANGE
	register int e3;
	RROP_DECLARE
	RROP_FETCH_GCPRIV(devPriv);
#endif

	y1_or_e1 = y1_or_e1 << 1;
	e3 = e << 1;

	FIXUP_ERROR(e, octant, bias);

#if PSZ == 24
 	if (stepmajor == 1  ||  stepmajor == -1){
 	    stepmajor3 = stepmajor * 3;
 	    stepminor3 = stepminor * sizeof (long);
 	    majordx = stepmajor; minordx = 0;
         } else {
 	    stepmajor3 = stepmajor * sizeof (long);
 	    stepminor3 = stepminor * 3;
 	    majordx = 0; minordx = stepminor;
         }
#endif
 
#if PSZ == 24
#define body {\
 	    body_rop \
 	    addrb += stepmajor3; \
             xOffset += majordx; \
 	    e += y1_or_e1; \
 	    if (e >= 0){ \
 	        addrb += stepminor3; \
                 xOffset += minordx; \
 		e += e3; \
 	    } \
 	}
#else /* PSZ == 24 */

#define body {\
	    RROP_SOLID(addrp); \
	    addrp += stepmajor; \
	    e += y1_or_e1; \
	    if (e >= 0) \
	    { \
		addrp += stepminor; \
		e += e3; \
	     } \
	}
#endif /* PSZ == 24 */

#ifdef LARGE_INSTRUCTION_CACHE

# ifdef SERIOUS_UNROLLING
#  define UNROLL	16
# else
#  define UNROLL	4
# endif
#define CASE(n)	case -n: body

	while ((x1_or_len -= UNROLL) >= 0)
	{
	    body body body body
# if UNROLL >= 8
	    body body body body
# endif
# if UNROLL >= 12
	    body body body body
# endif
# if UNROLL >= 16
	    body body body body
# endif
	}
	switch (x1_or_len)
	{
	CASE(1) CASE(2) CASE(3)
# if UNROLL >= 8
	CASE(4) CASE(5) CASE(6) CASE(7)
# endif
# if UNROLL >= 12
	CASE(8) CASE(9) CASE(10) CASE(11)
# endif
# if UNROLL >= 16
	CASE(12) CASE(13) CASE(14) CASE(15)
# endif
	}
#else /* !LARGE_INSTRUCTION_CACHE */

	IMPORTANT_START
	IMPORTANT_START

	if (x1_or_len & 1)
	    body
	x1_or_len >>= 1;
	while (x1_or_len--) {
	    body body
	}

	IMPORTANT_END
	IMPORTANT_END
#endif /* LARGE_INSTRUCTION_CACHE */

#ifdef POLYSEGMENT
#if PSZ == 24
	body_rop
#else
	RROP_SOLID(addrp);
#endif
#endif
#if PSZ == 24
	addrp = (PixelType *)((unsigned long)addrb & ~0x03);
#endif
	}
#undef body
#ifdef POLYSEGMENT
	}
	else
	{
# ifdef REARRANGE
	    register int    e3;
	    RROP_DECLARE
	    RROP_FETCH_GCPRIV(devPriv);
# endif /* REARRANGE */
	    if (stepmajor < 0)
	    {
#if PSZ == 24
		xOffset -= x1_or_len;
		addrp = addrLineEnd + PXL2ADR(xOffset);
#else
		addrp -= x1_or_len;
#endif
		if (capStyle)
		    x1_or_len++;
		else
#if PSZ == 24
		  xOffset++;
		addrp = addrLineEnd + PXL2ADR(xOffset);
#else
		    addrp++;
#endif
	    }
	    else
	    {
#if PSZ == 24
		addrp = addrLineEnd + PXL2ADR(xOffset);
#endif
		if (capStyle)
		    x1_or_len++;
	    }
# if PSZ == 24
	    y1_or_e1 = xOffset & 3;
# else
	    /* Round addrp down to the next PixelGroup boundary, and
	     * set y1_or_e1 to the excess (in pixels)
	     * (assumes PGSZB is a power of 2). */
	    y1_or_e1 = (((unsigned long) addrp) & (PGSZB - 1)) / (PSZ / 8);
	    addrp -= y1_or_e1;
# endif /* PSZ == 24 */
#if PSZ == 24
	    {
#if RROP == GXcopy
	      register int nlmiddle;
	      int leftIndex = xOffset & 3;
	      int rightIndex = (xOffset + x1_or_len) & 3;
#else
	      register int pidx;
#endif

#if RROP == GXcopy
	      nlmiddle = x1_or_len;
	      if(leftIndex){
		nlmiddle -= (4 - leftIndex);
	      }
	      if(rightIndex){
		nlmiddle -= rightIndex;
	      }
	      
	      nlmiddle >>= 2;
	      switch(leftIndex+x1_or_len){
	      case 4:
		switch(leftIndex){
		case 0:
		  *addrp++ = piQxelXor[0];
		  *addrp++ = piQxelXor[1];
		  *addrp   = piQxelXor[2];
		  break;
		case 1:
		  *addrp++ = ((*addrp) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
		  *addrp++ = piQxelXor[1];
		  *addrp   = piQxelXor[2];
		  break;
		case 2:
		  *addrp++ =((*addrp) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
		  *addrp = piQxelXor[2];
		  break;
		case 3:
		  *addrp =((*addrp) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
		  break;
		}
		break;
	      case 3:
		switch(leftIndex){
		case 0:
		  *addrp++ = piQxelXor[0];
		  *addrp++ = piQxelXor[1];
		  *addrp = ((*addrp) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
		  break;
		case 1:
		  *addrp++ = ((*addrp) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
		  *addrp++ = piQxelXor[1];
		  *addrp = ((*addrp) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
		  break;
		case 2:
		  *addrp++ =((*addrp) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
		  *addrp = ((*addrp) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
		  break;
		}
		break;
	      case 2:
		switch(leftIndex){
/*
		case 2:
		  *addrp++ = ((*addrp) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
		  *addrp = ((*addrp) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
		  break;
*/
		case 1:
		  *addrp++ = ((*addrp) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
		  *addrp = ((*addrp) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
		  break;
		case 0:
		  *addrp++ =  piQxelXor[0];
		  *addrp = ((*addrp) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
		  break;
		}
		break;
	      case 1: /*only if leftIndex = 0 and w = 1*/
		if(x1_or_len){
		*addrp =  ((*addrp) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
		}
/*
		else{
		*addrp++ =  ((*addrp) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
		*addrp =  ((*addrp) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
		}
*/
		break;
	      case 0: /*never*/
		break;
	      default:
		{
/*
		  maskbits(y1_or_e1, x1_or_len, e, e3, x1_or_len)
*/
		  switch(leftIndex){
		  case 0:
		    break;
		  case 1:
		    *addrp++ = ((*addrp) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
		    *addrp++ = piQxelXor[1];
		    *addrp++ = piQxelXor[2];
		    break;
		  case 2:
		    *addrp++ = ((*addrp) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
		    *addrp++ = piQxelXor[2];
		    break;
		  case 3:
		    *addrp++ = ((*addrp) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
		    break;
		  }
		  while(nlmiddle--){
		    *addrp++ = piQxelXor[0];
		    *addrp++ = piQxelXor[1];
		    *addrp++ = piQxelXor[2];
		  }
		  switch(rightIndex++){
		  case 0:
		    break;
		  case 1:
		    *addrp = ((*addrp) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
		    break;
		  case 2:
		    *addrp++ = piQxelXor[0];
		    *addrp = ((*addrp) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
		    break;
		  case 3:
		    *addrp++ = piQxelXor[0];
		    *addrp++ = piQxelXor[1];
		    *addrp = ((*addrp) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
		    break;
		  }
/*
		  if (e3){
		    e3 &= 0xFFFFFF;
		    switch(rightIndex&3){
		    case 0:
		      *addrp = ((*addrp) & (0xFF000000 | ~e3))
			| (piQxelXor[0] & 0xFFFFFF & e3);
		      break;
		    case 1:
		      *addrp++ = ((*addrp) & (0xFFFFFF | ~(e3<<24)))
				  | (piQxelXor[0] & 0xFF000000 & (e3<<24));
		      *addrp = ((*addrp) & (0xFFFF0000|~(e3 >> 8)))
				  | (piQxelXor[1] & 0xFFFF & (e3 >> 8));
		      break;
		    case 2:
		      *addrp++ = ((*addrp) & (0xFFFF|~(e3 << 16)))
				  | (piQxelXor[1] & 0xFFFF0000 & (e3 << 16));
		      *addrp = ((*addrp) & (0xFFFFFF00|~(e3>>16)))
				  | (piQxelXor[2] & 0xFF & (e3 >> 16));
		      break;
		    case 3:
		      *addrp++ = ((*addrp) & (0xFF|~(e3<<8)))
				  | (piQxelXor[2] & 0xFFFFFF00 & (e3<<8));
		      break;
		    }
		  }
*/
		}
	      }
#else /* GXcopy */
	      addrp = (PixelType *)((char *)addrLineEnd + ((xOffset * 3) & ~0x03));
	      if (x1_or_len <= 1){
		if (x1_or_len)
		  RROP_SOLID24(addrp, xOffset);
	      } else {
		maskbits(xOffset, x1_or_len, e, e3, x1_or_len);
		pidx = xOffset & 3;
		if (e){
		  RROP_SOLID_MASK(addrp, e, pidx-1);
		  addrp++;
		  if (pidx == 3)
		    pidx = 0;
		}
		while (--x1_or_len >= 0){
		  RROP_SOLID(addrp, pidx);
		  addrp++;
		  if (++pidx == 3)
		    pidx = 0;
		}
		if (e3)
		  RROP_SOLID_MASK(addrp, e3, pidx);
	      }
#endif /* GXcopy */
	    }
#else /* PSZ == 24 */
	    if (y1_or_e1 + x1_or_len <= PPW)
	      {
		if (x1_or_len)
		  {
		    maskpartialbits(y1_or_e1, x1_or_len, e)
		      RROP_SOLID_MASK((unsigned long *) addrp, e);
		  }
	      }
	    else
	    {
	    	maskbits(y1_or_e1, x1_or_len, e, e3, x1_or_len)
	    	if (e)
	    	{
		    RROP_SOLID_MASK((unsigned long *) addrp, e);
		    addrp += PPW;
	    	}
#if 0
		RROP_SPAN_lu(addrp, x1_or_len)
#else
		RROP_SPAN(addrp, x1_or_len)
#endif
	    	if (e3)
#if 0
		    RROP_SOLID_MASK_lu((unsigned long *) addrp, e3);
#else
		    RROP_SOLID_MASK((unsigned long *) addrp, e3);
#endif
	    }
#endif /* PSZ == 24 */
	}
#endif /* POLYSEGMENT */
    }
#ifdef POLYSEGMENT
    if (nseg >= 0)
	return (xSegment *) ppt - pSegInit;
#else
    if (npt)
    {
#ifdef EITHER_MODE
	if (!mode)
#endif /* EITHER_MODE */
#ifndef ORIGIN
	{
	    *x1p = _x1;
	    *y1p = _y1;		
	    *x2p = _x2;
	    *y2p = _y2;
	}
#endif /* !ORIGIN */	    
	return ((DDXPointPtr) ppt - pptInit) - 1;
    }
#endif /* POLYSEGMENT */

#ifndef POLYSEGMENT
# ifndef ORIGIN
#  define C2  c2
# else
#  define C2  ppt[-1]
# endif
#ifdef EITHER_MODE
    if (pGC->capStyle != CapNotLast &&
	((mode ? (C2 != *((int *) pptInitOrig))
	       : ((_x2 != pptInitOrig->x) ||
		  (_y2 != pptInitOrig->y)))
	 || (ppt == ((int *)pptInitOrig) + 2)))
#endif /* EITHER_MODE */
#ifdef PREVIOUS
    if (pGC->capStyle != CapNotLast &&
	((_x2 != pptInitOrig->x) ||
	 (_y2 != pptInitOrig->y) ||
	 (ppt == ((int *)pptInitOrig) + 2)))
#endif /* PREVIOUS */
#ifdef ORIGIN
    if (pGC->capStyle != CapNotLast &&
	((C2 != *((int *) pptInitOrig)) ||
	 (ppt == ((int *)pptInitOrig) + 2)))
#endif /* !PREVIOUS */
    {
# ifdef REARRANGE
	RROP_DECLARE

	RROP_FETCH_GCPRIV(devPriv);
# endif
#if PSZ == 24
#if RROP == GXcopy
	    switch(xOffset & 3){
	    case 0:
	      *addrp = ((*addrp)&0xFF000000)|(piQxelXor[0] & 0xFFFFFF);
	      break;
	    case 3: