www.pudn.com > WinGOS.rar > Rop2.cpp

#include "gos.h" 
#include "rop2.h" 
 
const WORD CROP4::m_aColor16[16]= 
{ 
	0x0000,0x8000,0x0400,0x8400,0x0010,0x8010,0x0410,0xc618, 
	0x8410,0xf800,0x07e0,0xffe0,0x001f,0xf81f,0x07ff,0xffff, 
}; 
const DWORD CROP4::m_aColor32[16]= 
{ 
	0x00000000,0x80800000,0x10008000,0x90808000, 
	0x02000080,0x82800080,0x12008080,0xdbc0c0c0, 
	0x92808080,0xe0ff0000,0x1c00ff00,0xfcffff00, 
	0x030000ff,0xe3ff00ff,0x1f00ffff,0xffffffff, 
}; 
 
void CROP::SelectObject(CBitmap* pBitmap) 
{ 
	const BITMAP &bmp=pBitmap->GetBitmap(); 
	int y,x=bmp.bmBitsPixel; 
	PBYTE pBits=PBYTE(bmp.bmBits); 
	switch(x) 
	{ 
	case 1:GetProc=CROP1::GetProc;break; 
	case 4:GetProc=CROP4::GetProc;break; 
	case 8:GetProc=CROP8::GetProc;break; 
	case 16:GetProc=CROP16::GetProc;break; 
	default:GetProc=CROP24::GetProc; 
	} 
 
	GETBMPWIDTHBYTES(y,bmp.bmWidth,x); 
 
	if(bmp.bmWidth<0) 
	{ 
		x=-x; 
		pBits+=(x*(bmp.bmWidth+1))/8; 
	} 
	if(bmp.bmHeight<0) 
	{ 
		y=-y; 
		pBits+=y*(bmp.bmHeight+1); 
	} 
 
	if(bmp.bmBitsPixel<8)y*=8; 
	else x/=8; 
	m_nStepX=x; 
	m_nStepY=y; 
 
	m_pBits=pBits; 
} 
void CROP::SetRopGetColor(CDC* pDestDC,CBitmap* pSrcBmp) 
{ 
	DWORD nROP; 
	c=DWORD(&pDestDC->GetRopObj().c); 
 
	if(pSrcBmp->GetBitmap().bmBitsPixel<=8 && pDestDC->GetCurrentPalette()) 
	{ 
		i=DWORD(pDestDC->GetCurrentPalette()->GetTable()); 
		if(i>0) 
		{ 
			SetROP(R2_GETCOLORINDEX); 
			return; 
		} 
	} 
 
	switch(pDestDC->GetCurrentBitmap()->GetBitmap().bmBitsPixel) 
	{ 
	case 16: 
		if(pSrcBmp->GetBitmap().bmType&BMP_TYPEMASK) 
		{ 
			ROP=Color555To565; 
			return; 
		} 
		nROP=R2_GETCOLOR16; 
		break; 
	case 8: 
		nROP=R2_GETCOLOR8; 
		break; 
	case 4: 
		nROP=R2_GETCOLOR4; 
		break; 
	case 1: 
		nROP=R2_GETCOLOR1; 
		break; 
	default: 
		nROP=R2_GETCOLOR24; 
		break; 
	} 
	SetROP(nROP); 
} 
void CROP::RpNone(CROP &rp) 
{ 
	/* 无操作 */ 
} 
void CROP::RpIfPen(CROP &rp) 
{ 
	if(rp.c==rp.i)rp.ROP(rp); 
} 
void CROP::RpIfNotPen(CROP &rp) 
{ 
	if(rp.c!=rp.i)rp.ROP(rp); 
} 
void CROP::Color555To565(CROP &rp) 
{ 
	DWORD clr,c=*PWORD(rp.p); 
	clr=(c&0x07FE0)<<1; 
	clr|=(c>>4)&0x20; 
	*PDWORD(rp.c)=clr|(c&0x001F); 
} 
void CROP::Color32To24(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD c=p[0]; 
	c|=DWORD(p[1])<<16; 
	c|=DWORD(p[2])<<24; 
	*PDWORD(rp.c)=c; 
} 
 
//24位ROP渲染 
void CROP24::CopyPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]=BYTE(c);p[1]=BYTE(c>>8);p[2]=BYTE(c>>16); 
} 
void CROP24::XorPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]^=BYTE(c);p[1]^=BYTE(c>>8);p[2]^=BYTE(c>>16); 
} 
void CROP24::AndPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]&=BYTE(c);p[1]&=BYTE(c>>8);p[2]&=BYTE(c>>16); 
} 
void CROP24::AndNotPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=~rp.c; 
	p[0]&=BYTE(c);p[1]&=BYTE(c>>8);p[2]&=BYTE(c>>16); 
} 
void CROP24::AndPenNot(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]=~p[0]&BYTE(c);p[1]=~p[1]&BYTE(c>>8);p[2]=~p[2]&BYTE(c>>16); 
} 
void CROP24::OrPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]|=BYTE(c);p[1]|=BYTE(c>>8);p[2]|=BYTE(c>>16); 
} 
void CROP24::OrNotPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=~rp.c; 
	p[0]|=BYTE(c);p[1]|=BYTE(c>>8);p[2]|=BYTE(c>>16); 
} 
void CROP24::OrPenNot(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]=~p[0]|BYTE(c);p[1]=~p[1]|BYTE(c>>8);p[2]=~p[2]|BYTE(c>>16); 
} 
void CROP24::NotCopyPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=~rp.c; 
	p[0]=BYTE(c);p[1]=BYTE(c>>8);p[2]=BYTE(c>>16); 
} 
void CROP24::NotAndPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]&=BYTE(c);p[0]=~p[0]; 
	c>>=8;p[1]&=BYTE(c);p[1]=~p[1]; 
	c>>=8;p[2]&=BYTE(c);p[2]=~p[2]; 
} 
void CROP24::NotOrPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]|=BYTE(c);p[0]=~p[0]; 
	c>>=8;p[1]|=BYTE(c);p[1]=~p[1]; 
	c>>=8;p[2]|=BYTE(c);p[2]=~p[2]; 
} 
void CROP24::NotXorPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p);DWORD c=rp.c; 
	p[0]^=BYTE(c);p[0]=~p[0]; 
	c>>=8;p[1]^=BYTE(c);p[1]=~p[1]; 
	c>>=8;p[2]^=BYTE(c);p[2]=~p[2]; 
} 
void CROP24::AlphaBlend(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD r,g,b,c=rp.c,clr=rp.a; 
	r=(c>>16)&0xff;g=(c>>8)&0xff;b=c&0xff; 
	c=256-clr; 
	r*=c;r+=127; 
	g*=c;g+=127; 
	b*=c;b+=127; 
	c=p[2]*clr+r;p[2]=BYTE(c>>8); 
	c=p[1]*clr+g;p[1]=BYTE(c>>8); 
	c=p[0]*clr+b;p[0]=BYTE(c>>8); 
} 
void CROP24::AlphaPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD c,clr=rp.a; 
	c=p[2]*clr+rp.r;p[2]=BYTE(c>>8); 
	c=p[1]*clr+rp.g;p[1]=BYTE(c>>8); 
	c=p[0]*clr+rp.b;p[0]=BYTE(c>>8); 
} 
void CROP24::AlphaBlendPen(CROP &rp) 
{ 
	CopyPen(rp); 
	AlphaPen(rp); 
} 
 
//24位设备的像素操作 
void CROP24::GetColorIndex(CROP &rp) 
{ 
	PDWORD aColor=PDWORD(rp.i); 
	PBYTE p=PBYTE(rp.p); 
	DWORD c=p[0]; 
	c|=DWORD(p[1])<<16; 
	c|=DWORD(p[2])<<24; 
	*PDWORD(rp.c)=aColor[c]; 
} 
void CROP24::GetColor1(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD c; 
	c=p[2];c|=p[1];c|=p[0]; 
	*PDWORD(rp.c)=c?1:0; 
} 
void CROP24::GetColor4(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD r=p[2],g=p[1],b=p[0],h; 
	h=r|g|b;h>>=4;h&=8; 
	r>>=6;r|=r>>1;r&=1; 
	g>>=5;g|=g>>1;g&=2; 
	b>>=4;b|=b>>1;b&=4; 
	*PDWORD(rp.c)=r|g|b|h; 
} 
void CROP24::GetColor8(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD r,g,b; 
	r=p[2];r&=0xe0; 
	g=p[1];g>>=5;g<<=2; 
	b=p[0];b>>=6; 
	*PDWORD(rp.c)=r|g|b; 
} 
void CROP24::GetColor16(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD r,g,b; 
	r=p[2];r>>=3;r<<=11; 
	g=p[1];g>>=2;g<<=5; 
	b=p[0];b>>=3; 
	*PDWORD(rp.c)=r|g|b; 
} 
void CROP24::GetColor24(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD c=p[0]; 
	c|=DWORD(p[1])<<16; 
	c|=DWORD(p[2])<<24; 
	*PDWORD(rp.c)=c; 
} 
void CROP24::RpIfScr(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD r,g,b=p[0]; 
	r=p[2];r<<=16; 
	g=p[1];g<<=8; 
	if((r|g|b)==rp.i)rp.ROP(rp); 
} 
void CROP24::RpIfNotScr(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	DWORD r,g,b=p[0]; 
	r=p[2];r<<=16; 
	g=p[1];g<<=8; 
	if((r|g|b)!=rp.i)rp.ROP(rp); 
} 
PFNROP CROP24::GetProc(int nRop) 
{ 
	PFNROP pProc; 
	switch(nRop) 
	{ 
	case R2_COPYPEN:pProc=CopyPen;break; 
	case R2_PRVRPIFSCR:pProc=RpIfScr;break; 
	case R2_PRVRPIFNOTSCR:pProc=RpIfNotScr;break; 
	case R2_PRVRPIFPEN:pProc=RpIfPen;break; 
	case R2_PRVRPIFNOTPEN:pProc=RpIfNotPen;break; 
	case R2_XORPEN:pProc=XorPen;break; 
	case R2_MASKPEN:pProc=AndPen;break; 
	case R2_MASKNOTPEN:pProc=AndNotPen;break; 
	case R2_MASKPENNOT:pProc=AndPenNot;break; 
	case R2_MERGEPEN:pProc=OrPen;break; 
	case R2_MERGENOTPEN:pProc=OrNotPen;break; 
	case R2_MERGEPENNOT:pProc=OrPenNot;break; 
	case R2_NOTCOPYPEN:pProc=NotCopyPen;break; 
	case R2_NOTMASKPEN:pProc=NotAndPen;break; 
	case R2_NOTMERGEPEN:pProc=NotOrPen;break; 
	case R2_NOTXORPEN:pProc=NotXorPen;break; 
	case R2_ALPHAPEN:pProc=AlphaPen;break; 
	case R2_ALPHABLEND:pProc=AlphaBlend;break; 
	case R2_ALPHABLENDPEN:pProc=AlphaBlendPen;break; 
	case R2_GETCOLORINDEX:pProc=GetColorIndex;break; 
	case R2_GETCOLOR1:pProc=GetColor1;break; 
	case R2_GETCOLOR4:pProc=GetColor4;break; 
	case R2_GETCOLOR8:pProc=GetColor8;break; 
	case R2_GETCOLOR16:pProc=GetColor16;break; 
	case R2_GETCOLOR24:pProc=GetColor24;break; 
	case R2_SETPENCOLOR:pProc=SetPenColor;break; 
	case R2_COPYPALETTE:pProc=CopyPalette;break; 
	default: 
		pProc=RpNone;break; 
	} 
	return pProc; 
} 
void CROP24::SetPenColor(CROP &rp) 
{ 
	DWORD c=rp.c; 
	rp.r=(c&0xff); 
	rp.g=(c>>8)&0xff; 
	rp.b=(c>>16)&0xff; 
	rp.c=(rp.r<<16)|(rp.g<<8)|(rp.b); 
	if(c & 0xff000000) 
	{ 
		c>>=24;rp.a=c;c=256-c; 
		rp.r*=c;rp.r+=127; 
		rp.g*=c;rp.g+=127; 
		rp.b*=c;rp.b+=127; 
	} 
	else rp.a=0; 
} 
void CROP24::CopyPalette(CROP &rp) 
{ 
	int nCount=rp.c; 
	PBYTE pSrc=PBYTE(rp.a); 
	PBYTE pDest=PBYTE(rp.i); 
	if(nCount<0) 
	{ 
		while(nCount++) 
		{ 
			pDest[0]=pSrc[2]; 
			pDest[1]=pSrc[1]; 
			pDest[2]=pSrc[0]; 
			pDest+=4;pSrc+=4; 
		} 
	} 
	else 
	{ 
		nCount*=sizeof(DWORD); 
		CopyMemory(pDest,pSrc,nCount); 
	} 
} 
 
//16位ROP渲染 
void CROP16::CopyPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p=WORD(rp.c); 
} 
void CROP16::XorPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p^=WORD(rp.c); 
} 
void CROP16::AndPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p&=WORD(rp.c); 
} 
void CROP16::AndNotPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p&=WORD(~rp.c); 
} 
void CROP16::AndPenNot(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p=~(*p)&WORD(rp.c); 
} 
void CROP16::OrPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p|=WORD(rp.c); 
} 
void CROP16::OrNotPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p|=WORD(~rp.c); 
} 
void CROP16::OrPenNot(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p=~*p|WORD(rp.c); 
} 
void CROP16::NotCopyPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p=WORD(~rp.c); 
} 
void CROP16::NotAndPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p&=WORD(rp.c);*p=~*p; 
} 
void CROP16::NotOrPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p|=WORD(rp.c);*p=~*p; 
} 
void CROP16::NotXorPen(CROP &rp) 
{ 
	PWORD p=PWORD(rp.p); 
	*p^=WORD(rp.c);*p=~*p; 
} 
void CROP16::AlphaPen(CROP &rp) 
{ 
	DWORD r,g,b,c=*PWORD(rp.p),a=rp.a; 
	r=c>>11;r=(r<<3)|(r>>2); 
	r*=a;r+=rp.r;r>>=11;r<<=11; 
	g=c<<21;g>>=26;g=(g<<2)|(g>>4); 
	g*=a;g+=rp.g;g>>=10;g<<=5; 
	b=c&0x1f;b=(b<<3)|(b>>2); 
	b*=a;b+=rp.b;b>>=11; 
	*PWORD(rp.p)=WORD(r|g|b); 
} 
void CROP16::AlphaBlend(CROP &rp) 
{ 
	DWORD r,g,b,c=*PWORD(rp.p),a=rp.a; 
	DWORD ar,ag,ab,ac=rp.c,aa=256-a; 
	ar=ac>>11;ar=(ar<<3)|(ar>>2); 
	ar*=aa;ar+=127; 
	ag=ac<<21;ag>>=26;ag=(ag<<2)|(ag>>4); 
	ag*=aa;ag+=127; 
	ab=ac&0x1f;ab=(ab<<3)|(ab>>2); 
	ab*=aa;ab+=127; 
	r=c>>11;r=(r<<3)|(r>>2); 
	r*=a;r+=ar;r>>=11;r<<=11; 
	g=c<<21;g>>=26;g=(g<<2)|(g>>4); 
	g*=a;g+=ag;g>>=10;g<<=5; 
	b=c&0x1f;b=(b<<3)|(b>>2); 
	b*=a;b+=ab;b>>=11; 
	*PWORD(rp.p)=WORD(r|g|b); 
} 
 
void CROP16::AlphaBlendPen(CROP &rp) 
{ 
	CopyPen(rp); 
	AlphaPen(rp); 
} 
 
//16位ROP操作 
void CROP16::GetColorIndex(CROP &rp) 
{ 
	PDWORD aColor=PDWORD(rp.i); 
	*PDWORD(rp.c)=aColor[*PWORD(rp.p)]; 
} 
void CROP16::GetColor1(CROP &rp) 
{ 
	*PDWORD(rp.c)=*PWORD(rp.p)?1:0; 
} 
void CROP16::GetColor4(CROP &rp) 
{ 
	DWORD c=*PWORD(rp.p); 
	DWORD r=c<<16,g=c<<21,b=c<<27,h; 
	h=r|g|b;h>>=28;h&=8; 
	r>>=30;r|=r>>1;r&=1; 
	g>>=29;g|=g>>1;g&=2; 
	b>>=28;b|=b>>1;b&=4; 
	*PDWORD(rp.c)=r|g|b|h; 
} 
void CROP16::GetColor8(CROP &rp) 
{ 
	DWORD r,g,b,c=*PWORD(rp.p); 
	r=(c>>8)&0xe0; 
	g=(c>>6)&0x1c; 
	b=(c>>3)&3; 
	*PDWORD(rp.c)=r|g|b; 
} 
void CROP16::GetColor16(CROP &rp) 
{ 
	*PDWORD(rp.c)=*PWORD(rp.p); 
} 
void CROP16::GetColor24(CROP &rp) 
{ 
	DWORD r,g,b,c=*PWORD(rp.p); 
	r=c>>11;r=(r<<3)|(r>>2);r<<=16; 
	g=c<<21;g>>=26;g=(g<<2)|(g>>4);g<<=8; 
	b=c<<27;b>>=27;b=(b<<3)|(b>>2); 
	*PDWORD(rp.c)=r|g|b; 
} 
void CROP16::RpIfScr(CROP &rp) 
{ 
	DWORD c=*PWORD(rp.p); 
	if(c==rp.i)rp.ROP(rp); 
} 
void CROP16::RpIfNotScr(CROP &rp) 
{ 
	DWORD c=*PWORD(rp.p); 
	if(c!=rp.i)rp.ROP(rp); 
} 
void CROP16::SetPenColor(CROP &rp) 
{ 
	DWORD c=rp.c; 
	if(c & 0xff000000) 
	{ 
		rp.r=(c&0xff); 
		rp.g=(c>>8)&0xff; 
		rp.b=(c>>16)&0xff; 
		rp.c=(rp.r<<16)|(rp.g<<8)|(rp.b); 
		c>>=24;rp.a=c;c=256-c; 
		rp.r*=c;rp.r+=127; 
		rp.g*=c;rp.g+=127; 
		rp.b*=c;rp.b+=127; 
	} 
	else 
	{ 
		rp.r=(c>>3)&31; 
		rp.g=(c>>10)&63; 
		rp.b=(c>>19)&31; 
		rp.c=(rp.r<<11)|(rp.g<<5)|rp.b; 
		rp.a=0; 
	} 
} 
void CROP16::CopyPalette(CROP &rp) 
{ 
	DWORD r,g,b,c; 
	int nCount=rp.c; 
	PDWORD pSrc=PDWORD(rp.a); 
	PDWORD pDest=PDWORD(rp.i); 
	if(nCount<0) 
	{ 
		while(nCount++) 
		{ 
			c=*pSrc++; 
			r=(c<<8)&0xf800;g=(c<<3)&0x07e0;b=(c>>3)&0x001f; 
			*pDest++=r|g|b; 
		} 
 
	} 
	else 
	{ 
		while(nCount--) 
		{ 
			c=*pSrc++; 
			r=(c>>8)&0xf800;g=(c>>5)&0x07e0;b=(c>>3)&0x001f; 
			*pDest++=r|g|b; 
		} 
	} 
} 
PFNROP CROP16::GetProc(int nRop) 
{ 
	PFNROP pProc; 
	switch(nRop) 
	{ 
	case R2_COPYPEN:pProc=CopyPen;break; 
	case R2_PRVRPIFSCR:pProc=RpIfScr;break; 
	case R2_PRVRPIFNOTSCR:pProc=RpIfNotScr;break; 
	case R2_PRVRPIFPEN:pProc=RpIfPen;break; 
	case R2_PRVRPIFNOTPEN:pProc=RpIfNotPen;break; 
	case R2_XORPEN:pProc=XorPen;break; 
	case R2_MASKPEN:pProc=AndPen;break; 
	case R2_MASKNOTPEN:pProc=AndNotPen;break; 
	case R2_MASKPENNOT:pProc=AndPenNot;break; 
	case R2_MERGEPEN:pProc=OrPen;break; 
	case R2_MERGENOTPEN:pProc=OrNotPen;break; 
	case R2_MERGEPENNOT:pProc=OrPenNot;break; 
	case R2_NOTCOPYPEN:pProc=NotCopyPen;break; 
	case R2_NOTMASKPEN:pProc=NotAndPen;break; 
	case R2_NOTMERGEPEN:pProc=NotOrPen;break; 
	case R2_NOTXORPEN:pProc=NotXorPen;break; 
	case R2_ALPHAPEN:pProc=AlphaPen;break; 
	case R2_ALPHABLEND:pProc=AlphaBlend;break; 
	case R2_ALPHABLENDPEN:pProc=AlphaBlendPen;break; 
	case R2_GETCOLORINDEX:pProc=GetColorIndex;break; 
	case R2_GETCOLOR1:pProc=GetColor1;break; 
	case R2_GETCOLOR4:pProc=GetColor4;break; 
	case R2_GETCOLOR8:pProc=GetColor8;break; 
	case R2_GETCOLOR16:pProc=GetColor16;break; 
	case R2_GETCOLOR24:pProc=GetColor24;break; 
	case R2_SETPENCOLOR:pProc=SetPenColor;break; 
	case R2_COPYPALETTE:pProc=CopyPalette;break; 
	default: 
		pProc=RpNone;break; 
	} 
	return pProc; 
} 
 
 
//8位ROP渲染 
void CROP8::CopyPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p=BYTE(rp.c); 
} 
void CROP8::XorPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p^=BYTE(rp.c); 
} 
void CROP8::AndPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p&=BYTE(rp.c); 
} 
void CROP8::AndNotPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p&=BYTE(~rp.c); 
} 
void CROP8::AndPenNot(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p=~(*p)&BYTE(rp.c); 
} 
void CROP8::OrPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p|=BYTE(rp.c); 
} 
void CROP8::OrNotPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p|=BYTE(~rp.c); 
} 
void CROP8::OrPenNot(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p=~*p|BYTE(rp.c); 
} 
void CROP8::NotCopyPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p=BYTE(~rp.c); 
} 
void CROP8::NotAndPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p&=BYTE(rp.c);*p=~*p; 
} 
void CROP8::NotOrPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p|=BYTE(rp.c);*p=~*p; 
} 
void CROP8::NotXorPen(CROP &rp) 
{ 
	PBYTE p=PBYTE(rp.p); 
	*p^=BYTE(rp.c);*p=~*p; 
} 
void CROP8::AlphaPen(CROP &rp) 
{ 
	DWORD r,g,b,c=*PBYTE(rp.p),a=rp.a; 
	r=c>>5;r=(r<<5)|(r<<2)|(r>>1); 
	r*=a;r+=rp.r;r>>=13;r<<=5; 
	g=c<<27;g>>=29;g=(g<<5)|(g<<2)|(g>>1); 
	g*=a;g+=rp.g;g>>=13;g<<=2; 
	b=c&3;b|=b<<2;b|=b<<2; 
	b*=a;b+=rp.b;b>>=14; 
	*PBYTE(rp.p)=BYTE(r|g|b); 
} 
void CROP8::AlphaBlend(CROP &rp) 
{ 
	DWORD r,g,b,c=*PWORD(rp.p),a=rp.a; 
	DWORD ar,ag,ab,ac=rp.c,aa=256-a; 
	ar=ac>>5;ar=(ar<<5)|(ar<<2)|(ar>>1); 
	ar*=aa;ar+=127; 
	ag=ac<<27;ag>>=29;ag=(ag<<5)|(ag<<2)|(ag>>1); 
	ag*=aa;ag+=127; 
	ab=ac&3;ab|=ab<<2;ab|=ab<<2; 
	ab*=aa;ab+=127; 
	r=c>>5;r=(r<<5)|(r<<2)|(r>>1); 
	r*=a;r+=ar;r>>=13;r<<=5; 
	g=c<<27;g>>=29;g=(g<<5)|(g<<2)|(g>>1); 
	g*=a;g+=ag;g>>=13;g<<=2; 
	b=c&3;b|=b<<2;b|=b<<2; 
	b*=a;b+=ab;b>>=14; 
	*PBYTE(rp.p)=BYTE(r|g|b); 
} 
void CROP8::AlphaBlendPen(CROP &rp) 
{ 
	CopyPen(rp); 
	AlphaPen(rp); 
} 
 
//8位ROP操作 
void CROP8::GetColorIndex(CROP &rp) 
{ 
	PDWORD aColor=PDWORD(rp.i); 
	*PDWORD(rp.c)=aColor[*PBYTE(rp.p)]; 
} 
void CROP8::GetColor1(CROP &rp) 
{ 
	*PDWORD(rp.c)=*PBYTE(rp.p)?1:0; 
} 
void CROP8::GetColor4(CROP &rp) 
{ 
	DWORD c=*PWORD(rp.p); 
	DWORD r=c<<24,g=c<<27,b=c<<30,h; 
	h=r|g|b;h>>=28;h&=8; 
	r>>=30;r|=r>>1;r&=1; 
	g>>=29;g|=g>>1;g&=2; 
	b>>=28;b|=b>>1;b&=4; 
	*PDWORD(rp.c)=r|g|b|h; 
} 
void CROP8::GetColor8(CROP &rp) 
{ 
	*PDWORD(rp.c)=*PBYTE(rp.p); 
} 
void CROP8::GetColor16(CROP &rp) 
{ 
	DWORD r,g,b,c=*PBYTE(rp.p); 
	r=c>>5;r=(r<<2)|(r>>1);r<<=5; 
	g=c<<27;g>>=29;g=(g<<3)|g;g<<=2; 
	b=c&3;b=(b<<3)|(b<<1)|(b>>1); 
	*PDWORD(rp.c)=r|g|b; 
} 
void CROP8::GetColor24(CROP &rp) 
{ 
	DWORD r,g,b,c=*PBYTE(rp.p); 
	r=c>>5;r=(r<<5)|(r<<2)|(r>>1);r<<=16; 
	g=c<<27;g>>=29;g=(g<<5)|(g<<2)|(g>>1);g<<=8; 
	b=c&3;b|=b<<2;b|=b<<4; 
	*PDWORD(rp.c)=r|g|b; 
} 
void CROP8::RpIfScr(CROP &rp) 
{ 
	DWORD c=*PBYTE(rp.p); 
	if(c==rp.i)rp.ROP(rp); 
} 
void CROP8::RpIfNotScr(CROP &rp) 
{ 
	DWORD c=*PBYTE(rp.p); 
	if(c!=rp.i)rp.ROP(rp); 
} 
void CROP8::SetPenColor(CROP &rp) 
{ 
	DWORD c=rp.c; 
	if(c & 0xff000000) 
	{ 
		rp.r=(c&0xff); 
		rp.g=(c>>8)&0xff; 
		rp.b=(c>>16)&0xff; 
		rp.c=(rp.r<<16)|(rp.g<<8)|(rp.b); 
		c>>=24;rp.a=c;c=256-c; 
		rp.r*=c;rp.r+=127; 
		rp.g*=c;rp.g+=127; 
		rp.b*=c;rp.b+=127; 
	} 
	else 
	{ 
		rp.r=(c>>5)&7; 
		rp.g=(c>>13)&7; 
		rp.b=(c>>22)&3; 
		rp.c=(rp.r<<5)|(rp.g<<2)|rp.b; 
		rp.a=0; 
	} 
} 
void CROP8::CopyPalette(CROP &rp) 
{ 
	DWORD r,g,b,c; 
	int nCount=rp.c; 
	PDWORD pSrc=PDWORD(rp.a); 
	PDWORD pDest=PDWORD(rp.i); 
	if(nCount<0) 
	{ 
		while(nCount++) 
		{ 
			c=*pSrc++; 
			r=(c>>5)&7;g=(c>>13)&7;b=(c>>22)&3; 
			*pDest++=(r<<5)|(g<<2)|b; 
		} 
 
	} 
	else 
	{ 
		while(nCount--) 
		{ 
			c=*pSrc++; 
			r=(c>>16)&7;g=(c>>11)&7;b=(c>>6)&3; 
			*pDest++=(r<<5)|(g<<2)|b; 
		} 
	} 
} 
PFNROP CROP8::GetProc(int nRop) 
{ 
	PFNROP pProc; 
	switch(nRop) 
	{ 
	case R2_COPYPEN:pProc=CopyPen;break; 
	case R2_PRVRPIFSCR:pProc=RpIfScr;break; 
	case R2_PRVRPIFNOTSCR:pProc=RpIfNotScr;break; 
	case R2_PRVRPIFPEN:pProc=RpIfPen;break; 
	case R2_PRVRPIFNOTPEN:pProc=RpIfNotPen;break; 
	case R2_XORPEN:pProc=XorPen;break; 
	case R2_MASKPEN:pProc=AndPen;break; 
	case R2_MASKNOTPEN:pProc=AndNotPen;break; 
	case R2_MASKPENNOT:pProc=AndPenNot;break; 
	case R2_MERGEPEN:pProc=OrPen;break; 
	case R2_MERGENOTPEN:pProc=OrNotPen;break; 
	case R2_MERGEPENNOT:pProc=OrPenNot;break; 
	case R2_NOTCOPYPEN:pProc=NotCopyPen;break; 
	case R2_NOTMASKPEN:pProc=NotAndPen;break; 
	case R2_NOTMERGEPEN:pProc=NotOrPen;break; 
	case R2_NOTXORPEN:pProc=NotXorPen;break; 
	case R2_ALPHAPEN:pProc=AlphaPen;break; 
	case R2_ALPHABLEND:pProc=AlphaBlend;break; 
	case R2_ALPHABLENDPEN:pProc=AlphaBlendPen;break; 
	case R2_GETCOLORINDEX:pProc=GetColorIndex;break; 
	case R2_GETCOLOR1:pProc=GetColor1;break; 
	case R2_GETCOLOR4:pProc=GetColor4;break; 
	case R2_GETCOLOR8:pProc=GetColor8;break; 
	case R2_GETCOLOR16:pProc=GetColor16;break; 
	case R2_GETCOLOR24:pProc=GetColor24;break; 
	case R2_SETPENCOLOR:pProc=SetPenColor;break; 
	case R2_COPYPALETTE:pProc=CopyPalette;break; 
	default: 
		pProc=RpNone;break; 
	} 
	return pProc; 
} 
 
//4位ROP渲染 
void CROP4::CopyPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=rp.c;*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=rp.c<<4;*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::XorPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=rp.c^sc;*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=(rp.c<<4)^sc;*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::AndPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=rp.c≻*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=(rp.c<<4)≻*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::AndNotPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=~rp.c≻*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=~(rp.c<<4)≻*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::AndPenNot(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=rp.c^sc;*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=(rp.c<<4)^sc;*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::OrPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=rp.c|sc;*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=(rp.c<<4)|sc;*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::OrNotPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=~rp.c|sc;*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=~(rp.c<<4)|sc;*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::OrPenNot(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=rp.c^~sc;*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=(rp.c<<4)^~sc;*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::NotCopyPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=~rp.c;*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=~(rp.c<<4);*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::NotAndPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=~(rp.c&sc);*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=~((rp.c<<4)&sc);*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::NotOrPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=~(rp.c|sc);*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=~((rp.c<<4)|sc);*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
void CROP4::NotXorPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD clr,sc=DWORD(*p); 
	if((nOffset&1)){clr=~(rp.c^sc);*p = BYTE(clr&0x0f|(sc&0xf0));} 
	else {clr=~((rp.c<<4)^sc);*p = BYTE(clr&0xf0|(sc&0x0f));} 
} 
//4位ROP操作 
void CROP4::GetColorIndex(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	PDWORD aColor=PDWORD(rp.i); 
	if(nOffset&4)sc&=0x0f;else sc>>=4; 
	*PDWORD(rp.c)=aColor[sc]; 
} 
void CROP4::GetColor1(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	if(nOffset&4)sc&=0x0f;else sc>>=4; 
	*PDWORD(rp.c)=sc?1:0; 
} 
void CROP4::GetColor4(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	if(nOffset&4)sc&=0x0f;else sc>>=4; 
	*PDWORD(rp.c)=sc; 
} 
void CROP4::GetColor8(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	if(nOffset&4)sc&=0x0f;else sc>>=4; 
	*PDWORD(rp.c)=m_aColor32[sc]>>24; 
} 
 
void CROP4::GetColor16(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	if(nOffset&4)sc&=0x0f;else sc>>=4; 
	*PDWORD(rp.c)=m_aColor16[sc]; 
} 
void CROP4::GetColor24(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	if((nOffset&1)==(rp.m_nStepX>0))sc&=0x0f;else sc>>=4; 
	*PDWORD(rp.c)=m_aColor32[sc]; 
} 
void CROP4::RpIfScr(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	if((nOffset&1)==(rp.m_nStepX>0))sc&=0x0f;else sc>>=4; 
	if(sc==rp.i)rp.ROP(rp); 
} 
void CROP4::RpIfNotScr(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	if((nOffset&1)==(rp.m_nStepX>0))sc&=0x0f;else sc>>=4; 
	if(sc!=rp.i)rp.ROP(rp); 
} 
void CROP4::SetPenColor(CROP &rp) 
{ 
	rp.r=rp.c;rp.g=rp.c>>8;rp.b=rp.c>>16; 
	rp.a=rp.r|rp.g|rp.b;rp.a>>=4;rp.a&=8; 
	rp.r>>=6;rp.r|=rp.r>>1;rp.r&=1; 
	rp.g>>=5;rp.g|=rp.g>>1;rp.g&=2; 
	rp.b>>=4;rp.b|=rp.b>>1;rp.b&=4; 
	rp.c=rp.r|rp.g|rp.b|rp.a; 
	rp.a=0; 
} 
void CROP4::CopyPalette(CROP &rp) 
{ 
	DWORD r,g,b,c,h; 
	int nCount=rp.c; 
	PDWORD pSrc=PDWORD(rp.a); 
	PDWORD pDest=PDWORD(rp.i); 
	if(nCount<0) 
	{ 
		while(nCount++) 
		{ 
			c=*pSrc++; 
			r=c;g=c>>8;b=c>>16; 
			h=r|g|b;h>>=4;h&=8; 
			r>>=6;r|=r>>1;r&=1; 
			g>>=5;g|=g>>1;g&=2; 
			b>>=4;b|=b>>1;b&=4; 
			*pDest++=r|g|b|h; 
		} 
 
	} 
	else 
	{ 
		while(nCount--) 
		{ 
			c=*pSrc++; 
			r=c>>16;g=c>>8;b=c; 
			h=r|g|b;h>>=4;h&=8; 
			r>>=6;r|=r>>1;r&=1; 
			g>>=5;g|=g>>1;g&=2; 
			b>>=4;b|=b>>1;b&=4; 
			*pDest++=r|g|b|h; 
		} 
	} 
} 
PFNROP CROP4::GetProc(int nRop) 
{ 
	PFNROP pProc; 
	switch(nRop) 
	{ 
	case R2_COPYPEN:pProc=CopyPen;break; 
	case R2_PRVRPIFSCR:pProc=RpIfScr;break; 
	case R2_PRVRPIFNOTSCR:pProc=RpIfNotScr;break; 
	case R2_PRVRPIFPEN:pProc=RpIfPen;break; 
	case R2_PRVRPIFNOTPEN:pProc=RpIfNotPen;break; 
	case R2_XORPEN:pProc=XorPen;break; 
	case R2_MASKPEN:pProc=AndPen;break; 
	case R2_MASKNOTPEN:pProc=AndNotPen;break; 
	case R2_MASKPENNOT:pProc=AndPenNot;break; 
	case R2_MERGEPEN:pProc=OrPen;break; 
	case R2_MERGENOTPEN:pProc=OrNotPen;break; 
	case R2_MERGEPENNOT:pProc=OrPenNot;break; 
	case R2_NOTCOPYPEN:pProc=NotCopyPen;break; 
	case R2_NOTMASKPEN:pProc=NotAndPen;break; 
	case R2_NOTMERGEPEN:pProc=NotOrPen;break; 
	case R2_NOTXORPEN:pProc=NotXorPen;break; 
	case R2_ALPHAPEN:pProc=CopyPen;break; 
	case R2_ALPHABLEND:pProc=CopyPen;break; 
	case R2_ALPHABLENDPEN:pProc=CopyPen;break; 
	case R2_GETCOLORINDEX:pProc=GetColorIndex;break; 
	case R2_GETCOLOR1:pProc=GetColor1;break; 
	case R2_GETCOLOR4:pProc=GetColor4;break; 
	case R2_GETCOLOR8:pProc=GetColor8;break; 
	case R2_GETCOLOR16:pProc=GetColor16;break; 
	case R2_GETCOLOR24:pProc=GetColor24;break; 
	case R2_SETPENCOLOR:pProc=SetPenColor;break; 
	case R2_COPYPALETTE:pProc=CopyPalette;break; 
	default: 
		pProc=RpNone;break; 
	} 
	return pProc; 
} 
 
//1位ROP渲染 
void CROP1::CopyPen(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=rp.c; 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=rp.c^sc; 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=rp.c≻ 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=~rp.c≻ 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=rp.c&~sc; 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=rp.c|sc; 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=~rp.c|sc; 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=rp.c|~sc; 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=~rp.c; 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=~(rp.c&sc); 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=~(rp.c|sc); 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	DWORD clr=~(rp.c^sc); 
	nOffset=~nOffset&7; 
	sc &= 1<>3); 
	DWORD sc=DWORD(*p); 
	nOffset=~nOffset&7; 
	*PDWORD(rp.c)=aColor[(sc>>nOffset)&1]; 
} 
void CROP1::GetColor1(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	nOffset=~nOffset&7; 
	*PDWORD(rp.c)=(sc>>nOffset)&1; 
} 
void CROP1::GetColor4(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	nOffset=~nOffset&7; 
	*PDWORD(rp.c)=((sc>>nOffset)&1)?15:0; 
} 
void CROP1::GetColor8(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	nOffset=~nOffset&7; 
	*PDWORD(rp.c)=((sc>>nOffset)&1)?255:0; 
} 
void CROP1::GetColor16(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	nOffset=~nOffset&7; 
	*PDWORD(rp.c)=((sc>>nOffset)&1)?0xffff:0; 
} 
void CROP1::GetColor24(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	nOffset=~nOffset&7; 
	*PDWORD(rp.c)=((sc>>nOffset)&1)?0xffffff:0; 
} 
void CROP1::RpIfScr(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	nOffset=~nOffset&7; 
	sc>>=nOffset;sc&=1; 
	if(sc==rp.i)rp.ROP(rp); 
} 
void CROP1::RpIfNotScr(CROP &rp) 
{ 
	int nOffset=PBYTE(rp.p)-rp.m_pBits; 
	PBYTE p=rp.m_pBits+(nOffset>>3); 
	DWORD sc=DWORD(*p); 
	nOffset=~nOffset&7; 
	sc>>=nOffset;sc&=1; 
	if(sc!=rp.i)rp.ROP(rp); 
} 
void CROP1::SetPenColor(CROP &rp) 
{ 
	rp.c=rp.c?1:0; 
	rp.a=0; 
} 
void CROP1::CopyPalette(CROP &rp) 
{ 
	DWORD c; 
	int nCount=rp.c; 
	PDWORD pSrc=PDWORD(rp.a); 
	PDWORD pDest=PDWORD(rp.i); 
	if(nCount<0) 
	{ 
		while(nCount++) 
		{ 
			c=*pSrc++; 
			*pDest++=c&0xffffff?1:0; 
		} 
 
	} 
	else 
	{ 
		while(nCount--) 
		{ 
			c=*pSrc++; 
			*pDest++=c&0xffffff?1:0; 
		} 
	} 
} 
PFNROP CROP1::GetProc(int nRop) 
{ 
	PFNROP pProc; 
	switch(nRop) 
	{ 
	case R2_COPYPEN:pProc=CopyPen;break; 
	case R2_PRVRPIFSCR:pProc=RpIfScr;break; 
	case R2_PRVRPIFNOTSCR:pProc=RpIfNotScr;break; 
	case R2_PRVRPIFPEN:pProc=RpIfPen;break; 
	case R2_PRVRPIFNOTPEN:pProc=RpIfNotPen;break; 
	case R2_XORPEN:pProc=XorPen;break; 
	case R2_MASKPEN:pProc=AndPen;break; 
	case R2_MASKNOTPEN:pProc=AndNotPen;break; 
	case R2_MASKPENNOT:pProc=AndPenNot;break; 
	case R2_MERGEPEN:pProc=OrPen;break; 
	case R2_MERGENOTPEN:pProc=OrNotPen;break; 
	case R2_MERGEPENNOT:pProc=OrPenNot;break; 
	case R2_NOTCOPYPEN:pProc=NotCopyPen;break; 
	case R2_NOTMASKPEN:pProc=NotAndPen;break; 
	case R2_NOTMERGEPEN:pProc=NotOrPen;break; 
	case R2_NOTXORPEN:pProc=NotXorPen;break; 
	case R2_ALPHAPEN:pProc=CopyPen;break; 
	case R2_ALPHABLEND:pProc=CopyPen;break; 
	case R2_ALPHABLENDPEN:pProc=CopyPen;break; 
	case R2_GETCOLORINDEX:pProc=GetColorIndex;break; 
	case R2_GETCOLOR1:pProc=GetColor1;break; 
	case R2_GETCOLOR4:pProc=GetColor4;break; 
	case R2_GETCOLOR8:pProc=GetColor8;break; 
	case R2_GETCOLOR16:pProc=GetColor16;break; 
	case R2_GETCOLOR24:pProc=GetColor24;break; 
	case R2_SETPENCOLOR:pProc=SetPenColor;break; 
	case R2_COPYPALETTE:pProc=CopyPalette;break; 
	default: 
		pProc=RpNone;break; 
	} 
	return pProc; 
}