coolbar.cpp

用户管理系统

		}
		break;
//----------------------------------------------------
	case 1:	//SHS_DIAGSHADE
		a=(idxmax-idxmin)/2;
		for(i = 0; i < sYSize; i++) {
			for(j = 0; j < sXSize; j++) {
				posDst[j]=(BYTE)(idxmin+a*i/sYSize+a*(sXSize-j)/sXSize);
				posDst[j]+=rand()/grainx2-granularity;
			}
			posDst+=bytes;
		}
		break;
//----------------------------------------------------
*/
	case 2:	//SHS_HSHADE
		a=idxmax-idxmin;
		for(i = 0; i < sYSize; i++) {
			k=a*i/sYSize+idxmin;
			for(j = 0; j < sXSize; j++) 
			{   
				if(k < 0 || k > 255) k = 0;
				rgb1 = szPalette[k];
				posDst[4*j]=GetRValue(rgb1);
				posDst[4*j+1]=GetGValue(rgb1);
				posDst[4*j+2]=GetBValue(rgb1);
				posDst[4*j+3]=0;
				posDst[4*j]+=rand()/grainx2-granularity;
				posDst[4*j+1]+=rand()/grainx2-granularity;
				posDst[4*j+2]+=rand()/grainx2-granularity;
//				posDst[j]=(BYTE)k;
//				posDst[j]+=rand()/grainx2-granularity;
			}
			posDst+=4*bytes;
		}
		break;
/*
//----------------------------------------------------
	case 3:	//SHS_VSHADE:
		a=idxmax-idxmin;
		for(j = 0; j < sXSize; j++) {
			k=a*(sXSize-j)/sXSize+idxmin;
			for(i = 0; i < sYSize; i++) {
				posDst[j+i*bytes]=(BYTE)k;
				posDst[j+i*bytes]+=rand()/grainx2-granularity;
			}
		}
		break;
*/
//----------------------------------------------------
	default:	//SHS_NOISE
		for(i = 0; i < sYSize; i++) 
		{
			for(j = 0; j < sXSize; j++) 
			{
				//posDst[j]=128+rand()/grainx2-granularity;
				iInd = 128+rand()/grainx2-granularity;
				if(iInd < 0 || iInd > 255) iInd = 0;
				rgb1 = szPalette[iInd];
				posDst[4*j]=GetRValue(rgb1);
				posDst[4*j+1]=GetGValue(rgb1);
				posDst[4*j+2]=GetBValue(rgb1);
				posDst[4*j+3]=0;
			}
			posDst+=4*bytes;
		}
    break;
	}
//----------------------------------------------------

/////////////////////////////////////
	if(!dcSrc.CreateCompatibleDC(NULL)) return NULL;
	HBITMAP	hBmp = CreateDIBSection(dcSrc, (BITMAPINFO*)&bi, DIB_RGB_COLORS, (void**)&pDest, NULL, 0);
	memcpy(pDest, pData, dwLen);
//	free(pData);
    dcSrc.Detach();
    return hBmp; //return handle to the DIB
}

/////////////////////////////////////////////
//用渐变色生成HBITMAP句柄
//dwWidth 宽度只可以为1，不愿多写
//dwHeight 高度
//clrBack  结尾色
//clrFore  起启色
//创建图
HBITMAP CCoolBar::CreateBmp2(COLORREF cl1, COLORREF cl2, 
							 int nWidth, int nHeight,
							 int nDir, int nNumColors)
{
	if(nNumColors > 256)
		nNumColors = 256;

	COLORREF		PalVal[256];
	memset(PalVal, 0, sizeof(COLORREF)*256);

	int nIndex;
	BYTE peRed=0,peGreen=0,peBlue=0;
 
	int r1=GetRValue(cl1);
	int r2=GetRValue(cl2);
	int g1=GetGValue(cl1);
	int g2=GetGValue(cl2);
	int b1=GetBValue(cl1);
	int b2=GetBValue(cl2);

    for (nIndex = 0; nIndex < nNumColors; nIndex++)
    {
        peRed = (BYTE) (r1 + MulDiv((r2-r1),nIndex,nNumColors-1));
        peGreen = (BYTE) (g1 + MulDiv((g2-g1),nIndex,nNumColors-1));
        peBlue = (BYTE) (b1 + MulDiv((b2-b1),nIndex,nNumColors-1));

		PalVal[nIndex]=(peRed << 16) | (peGreen << 8) | (peBlue);
	}

	int x,y,w,h;
	w=nWidth;
	h=nHeight;
	
	LPDWORD			pGradBits;
	BITMAPINFO		GradBitInfo;

	pGradBits=(DWORD*) malloc(w*h*sizeof(DWORD));
	memset(&GradBitInfo,0,sizeof(BITMAPINFO));

	GradBitInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
	GradBitInfo.bmiHeader.biWidth=w;
	GradBitInfo.bmiHeader.biHeight=h;
	GradBitInfo.bmiHeader.biPlanes=1;
	GradBitInfo.bmiHeader.biBitCount=32;
	GradBitInfo.bmiHeader.biCompression=BI_RGB;
	
	if(nDir==0) 
	{
		for(y=0;y<h;y++) 
		{
			for(x=0;x<w;x++) 
			{
				*(pGradBits+(y*w)+x)=PalVal[MulDiv(nNumColors,y,h)];
			}
		}
	}
	else if(nDir==1) 
	{
		for(y=0;y<h;y++)
		{
			int l,r;
			l=MulDiv((nNumColors/2),y,h);
			r=l+(nNumColors/2)-1;
			for(x=0;x<w;x++)
			{
				*(pGradBits+(y*w)+x)=PalVal[l+MulDiv((r-l),x,w)];
			}
		}
	}
	else if(nDir==2)
	{
		for(x=0;x<w;x++)
		{
			for(y=0;y<h;y++)
			{
				*(pGradBits+(y*w)+x)=PalVal[MulDiv(nNumColors,x,w)];
			}
		}
	}
	else if(nDir==3)
	{
		for(y=0;y<h;y++)
		{
			int l,r;
			r=MulDiv((nNumColors/2),y,h);
			l=r+(nNumColors/2)-1;
			for(x=0;x<w;x++)
			{
				*(pGradBits+(y*w)+x)=PalVal[l+MulDiv((r-l),x,w)];
			}
		}
	}
	CDC dcSrc;
	HBITMAP hBmp;
   	if(!dcSrc.CreateCompatibleDC(NULL))
	{
		hBmp = NULL;
	}
	else
	{
	    hBmp = CreateDIBitmap(dcSrc,&GradBitInfo.bmiHeader,CBM_INIT,
						pGradBits,&GradBitInfo,DIB_RGB_COLORS);
	}

	free(pGradBits);
    dcSrc.Detach();
	return hBmp;
}

/////////////////////////////////////////////
//用渐变色生成HBITMAP句柄
//dwWidth 宽度只可以为1，不愿多写
//dwHeight 高度
//clrBack  结尾色
//clrFore  起启色
HBITMAP  CCoolBar::CreateBmp3(DWORD dwWidth, 
							 DWORD dwHeight,
							 COLORREF clrBack, 
					         COLORREF clrFore
					     )
{
    DWORD               dwLen;	// size of memory block
	CDC dcSrc;
    BITMAPINFOHEADER    bi;
    dwLen = WIDTHBYTES(24 * dwWidth) * dwHeight;

    // initialize BITMAPINFOHEADER
    bi.biSize = sizeof(BITMAPINFOHEADER);
    bi.biWidth = dwWidth;         // fill in width from parameter
    bi.biHeight = dwHeight;       // fill in height from parameter
    bi.biPlanes = 1;              // must be 1
    bi.biBitCount = 24;    // from parameter
    bi.biCompression = BI_RGB;    
    bi.biSizeImage = dwLen;
    bi.biXPelsPerMeter = 0;
    bi.biYPelsPerMeter = 0;
    bi.biClrUsed = 0;
    bi.biClrImportant = 0;

	BYTE* pDest = NULL, *pData;
    pData = (BYTE *)malloc(dwLen); // alloc memory block to store our bitmap
	if(!pData) return NULL;
//    memset(pData, 0, dwLen);
	BYTE  R0 = GetRValue(clrFore);
	BYTE  G0 = GetGValue(clrFore);
	BYTE  B0 = GetBValue(clrFore);
	BYTE  R1 = GetRValue(clrBack);
	BYTE  G1 = GetGValue(clrBack);
	BYTE  B1 = GetBValue(clrBack);
//	float  R9,G9,B9;
	DOUBLE  R9 = (DOUBLE)(R1-R0)/dwHeight;
	DOUBLE  G9 = (DOUBLE)(G1-G0)/dwHeight;
	DOUBLE  B9 = (DOUBLE)(B1-B0)/dwHeight;
/////////////////////////////////////
//填充方案
	int k = 0;
    for (DWORD i =0 ; i < dwHeight; i++)
	{//R G B
	  pData[k]= (BYTE)(B0 + B9*i);
	  pData[k+1] =(BYTE)(G0 + G9*i);
	  pData[k+2] =(BYTE)(R0 + R9*i);
	  pData[k+3]=0;
	  k += 4;
		   
	}

/////////////////////////////////////
	if(!dcSrc.CreateCompatibleDC(NULL))
	{   
		free(pData);
		return NULL;
	}
	HBITMAP	hBmp = CreateDIBSection(dcSrc, (BITMAPINFO*)&bi, DIB_RGB_COLORS, (void**)&pDest, NULL, 0);
	memcpy(pDest, pData, dwLen);
//	free(pData);
    dcSrc.Detach();
    return hBmp; //return handle to the DIB
}

COLORREF CCoolBar::BlendColors(COLORREF crA, COLORREF crB, float fAmountA)
{
	BYTE btRed = (BYTE)min(255, (int)(GetRValue(crA) * fAmountA + GetRValue(crB) * (1.0f - fAmountA)));
	BYTE btGreen = (BYTE)min(255, (int)(GetGValue(crA) * fAmountA + GetGValue(crB) * (1.0f - fAmountA)));
	BYTE btBlue = (BYTE)min(255, (int)(GetBValue(crA) * fAmountA + GetBValue(crB) * (1.0f - fAmountA)));
	
	return RGB(btRed, btGreen, btBlue);
}
BOOL CCoolBar::CreateGradientBMP(CBitmap* pBitmap, int nDir, COLORREF cl, COLORREF cm, COLORREF cr)
{
#ifdef _DEBUG
    ASSERT(pBitmap->m_hObject != NULL);
#else
    if(pBitmap->m_hObject == NULL)return FALSE;
#endif

    // Get the Bitmap info
    BITMAP bm;
    pBitmap->GetBitmap(&bm);
    int w = bm.bmWidth;
    int    h = bm.bmHeight;
    BYTE *pBits = (BYTE*)bm.bmBits;
    int BytesofLine = bm.bmWidthBytes;

#ifdef _DEBUG
    ASSERT(bm.bmBitsPixel == 24);
#else
    if(bm.bmBitsPixel!=24)return FALSE;
#endif

    //colors
    int BlueLeft    = GetBValue(cl);
    int GreenLeft   = GetGValue(cl);
    int RedLeft     = GetRValue(cl);
    int BlueMiddle  = GetBValue(cm);
    int GreenMiddle = GetGValue(cm);
    int RedMiddle   = GetRValue(cm);
    int BlueRight   = GetBValue(cr);
    int GreenRight  = GetGValue(cr);
    int RedRight    = GetRValue(cr);

    BYTE clrRed,clrGreen,clrBlue;

    BYTE *pData;
	pData = (BYTE*)(DWORD*) malloc(BytesofLine*w*h*sizeof(DWORD));
    if(nDir==0) //from up to bottom
    {
        int rh = h/2;    //middle height
        for(int y=0;y<h;y++) 
        {
            if(y<=rh)
            {
                clrBlue  = (BYTE)( (BlueMiddle - BlueLeft) * y/rh + BlueLeft);    
                clrGreen = (BYTE)( (GreenMiddle - GreenLeft) * y/rh + GreenLeft);
                clrRed   = (BYTE)( (RedMiddle - RedLeft) * y/rh + RedLeft);
            }
            else
            {
                clrBlue  = (BYTE)( (BlueRight - BlueMiddle) * (y - rh)/rh + BlueMiddle);    
                clrGreen = (BYTE)( (GreenRight - GreenMiddle) * (y - rh)/rh + GreenMiddle);
                clrRed   = (BYTE)( (RedRight - RedMiddle) * (y - rh)/rh + RedMiddle);
            }
            for(int x=0;x<w;x++) 
            {
                pData = pBits + y*BytesofLine + x*3;
                pData[0] = clrBlue;        //蓝色
                pData[1] = clrGreen;    //绿色
                pData[2] = clrRed;        //红色
            }
        }
    }
    else 
    {
        int rw = w/2;
        for(int x=0;x<w;x++)
        {
            if(x<=rw)
            {
                clrBlue  = (BYTE)( (BlueMiddle - BlueLeft) * x/rw + BlueLeft);    
                clrGreen = (BYTE)( (GreenMiddle - GreenLeft) * x/rw + GreenLeft);
                clrRed   = (BYTE)( (RedMiddle - RedLeft) * x/rw + RedLeft);
            }
            else
            {
                clrBlue  = (BYTE)( (BlueRight - BlueMiddle) * (x - rw)/rw + BlueMiddle);    
                clrGreen = (BYTE)( (GreenRight - GreenMiddle) * (x - rw)/rw + GreenMiddle);
                clrRed   = (BYTE)( (RedRight - RedMiddle) * (x - rw)/rw + RedMiddle);
            }
            for(int y=0;y<h;y++)
            {
                pData = pBits + y*BytesofLine + x*3;
                pData[0] = clrBlue;        //蓝色
                pData[1] = clrGreen;    //绿色
                pData[2] = clrRed;        //红色
            }
        }
    }//else
    free(pData);
    return TRUE;
}