Esempio n. 1
0
//位图转换到区域 (需要重写)
HRGN AFCBmpToRgn(HBITMAP hBmp, COLORREF cTransparentColor, COLORREF cTolerance)
{
	if (hBmp==NULL) return NULL;

	HRGN hRgn=NULL;
	HDC hMemDC=::CreateCompatibleDC(NULL);
	if (hMemDC!=NULL)
	{
		BITMAP bm;
		GetObject(hBmp, sizeof(bm), &bm);
		VOID * pbits32=NULL; 
		BITMAPINFOHEADER RGB32BITSBITMAPINFO = {sizeof(BITMAPINFOHEADER),bm.bmWidth,bm.bmHeight,1,32,BI_RGB,0,0,0,0,0};
		HBITMAP hbm32 = CreateDIBSection(hMemDC, (BITMAPINFO *)&RGB32BITSBITMAPINFO, DIB_RGB_COLORS, &pbits32, NULL, 0);
		if (hbm32)
		{
			HBITMAP holdBmp = (HBITMAP)SelectObject(hMemDC, hbm32);
			HDC hDC = CreateCompatibleDC(hMemDC);
			if (hDC)
			{
				BITMAP bm32;
				GetObject(hbm32,sizeof(bm32),&bm32);
				while (bm32.bmWidthBytes%4) bm32.bmWidthBytes++;
				HBITMAP holdBmp=(HBITMAP)SelectObject(hDC,hBmp);
				BitBlt(hMemDC,0,0,bm.bmWidth,bm.bmHeight,hDC,0,0,SRCCOPY);
				#define ALLOC_UNIT    100
				DWORD maxRects=ALLOC_UNIT;
				HANDLE hData=GlobalAlloc(GMEM_MOVEABLE, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects));
				RGNDATA *pData=(RGNDATA *)GlobalLock(hData);
				pData->rdh.dwSize=sizeof(RGNDATAHEADER);
				pData->rdh.iType=RDH_RECTANGLES;
				pData->rdh.nCount=pData->rdh.nRgnSize=0;
				SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);

				// Keep on hand highest and lowest values for the "transparent" pixels
				BYTE lr = GetRValue(cTransparentColor);
				BYTE lg = GetGValue(cTransparentColor);
				BYTE lb = GetBValue(cTransparentColor);
				BYTE hr = min(0xff, lr + GetRValue(cTolerance));
				BYTE hg = min(0xff, lg + GetGValue(cTolerance));
				BYTE hb = min(0xff, lb + GetBValue(cTolerance));

				// Scan each bitmap row from bottom to top (the bitmap is inverted vertically)
				BYTE *p32=(BYTE *)bm32.bmBits + (bm32.bmHeight - 1) * bm32.bmWidthBytes;
				for (int y=0;y<bm.bmHeight;y++)
				{
					// Scan each bitmap pixel from left to right
					for (int x=0;x<bm.bmWidth;x++)
					{
						// Search for a continuous range of "non transparent pixels"
						int x0=x;
						LONG *p=(LONG *)p32+x;
						while (x<bm.bmWidth)
						{
							BYTE b=GetRValue(*p);
							if (b>=lr&&b<=hr)
							{
								b=GetGValue(*p);
								if (b>=lg&&b<=hg)
								{
									b = GetBValue(*p);
									if (b >= lb && b <= hb) break;
								}
							}
							p++;
							x++;
						}

						if (x>x0)
						{
							// Add the pixels (x0, y) to (x, y+1) as a new rectangle in the region
							if (pData->rdh.nCount >= maxRects)
							{
								GlobalUnlock(hData);
								maxRects += 100;
								hData = GlobalReAlloc(hData, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), GMEM_MOVEABLE);
								pData = (RGNDATA *)GlobalLock(hData);
							}
							RECT *pr = (RECT *)&pData->Buffer;
							SetRect(&pr[pData->rdh.nCount], x0, y, x, y+1);
							if (x0 < pData->rdh.rcBound.left)
								pData->rdh.rcBound.left = x0;
							if (y < pData->rdh.rcBound.top)
								pData->rdh.rcBound.top = y;
							if (x > pData->rdh.rcBound.right)
								pData->rdh.rcBound.right = x;
							if (y+1 > pData->rdh.rcBound.bottom)
								pData->rdh.rcBound.bottom = y+1;
							pData->rdh.nCount++;

							// On Windows98, ExtCreateRegion() may fail if the number of rectangles is too
							// large (ie: > 4000). Therefore, we have to create the region by multiple steps.
							if (pData->rdh.nCount == 2000)
							{
								HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
								if (hRgn)
								{
									CombineRgn(hRgn, hRgn, h, RGN_OR);
									DeleteObject(h);
								}
								else
									hRgn = h;
								pData->rdh.nCount = 0;
								SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
							}
						}
					}
					p32 -= bm32.bmWidthBytes;
				}
				HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
				if (hRgn)
				{
					CombineRgn(hRgn, hRgn, h, RGN_OR);
					DeleteObject(h);
				}
				else hRgn = h;

				// Clean up
				GlobalFree(hData);
				SelectObject(hDC, holdBmp);
				DeleteDC(hDC);
			}
			DeleteObject(SelectObject(hMemDC, holdBmp));
		}
		DeleteDC(hMemDC);
	}    

	return hRgn;
}
Esempio n. 2
0
 /**
  * Returns the red part of the color
  * @return The red part of the color (0-255)
  */
 constexpr
 uint8_t Red() const
 {
   return GetRValue(value);
 }
Esempio n. 3
0
BOOL CImageDialog::OnInitDialog()
{
    CDialog::OnInitDialog();

    // TODO:  Add extra initialization here
    m_btnMask.EnableOtherButton(_T("Other"));
    m_btnMask.SetColor((COLORREF)0);
    m_btnMask.SetColumnsNumber(10);

    m_ctlFade.SetRange(0,255);
    m_ctlFade.SetPos(255);

    m_pManager=g_pMainFrame->GetActiveUIView()->GetPaintManager();
    m_ImagePreview.SetManager(m_pManager);

    g_HookAPI.EnableAddImage(false);

    m_strImagePathName=m_strImageProperty;
    LPCTSTR pStrImage=m_strImageProperty;
    CStdString sItem;
    CStdString sValue;
    LPTSTR pstr = NULL;
    while( *pStrImage != _T('\0') ) {
        sItem.Empty();
        sValue.Empty();
        while( *pStrImage != _T('\0') && *pStrImage != _T('=') ) {
            LPTSTR pstrTemp = ::CharNext(pStrImage);
            while( pStrImage < pstrTemp) {
                sItem += *pStrImage++;
            }
        }
        if( *pStrImage++ != _T('=') ) break;
        if( *pStrImage++ != _T('\'') ) break;
        while( *pStrImage != _T('\0') && *pStrImage != _T('\'') ) {
            LPTSTR pstrTemp = ::CharNext(pStrImage);
            while( pStrImage < pstrTemp) {
                sValue += *pStrImage++;
            }
        }
        if( *pStrImage++ != _T('\'') ) break;
        if( !sValue.IsEmpty() ) {
            if( sItem == _T("file"))
                m_strImagePathName = sValue;
            else if( sItem == _T("dest") )
                m_strDest = sValue;
            else if( sItem == _T("source") )
                m_strSource = sValue;
            else if( sItem == _T("corner") )
                m_strCorner = sValue;
            else if( sItem == _T("mask") ) {
                DWORD dwMask;
                if( sValue[0] == _T('#')) dwMask = _tcstoul(sValue.GetData() + 1, &pstr, 16);
                else dwMask = _tcstoul(sValue.GetData(), &pstr, 16);
                dwMask&=0x00FFFFFF;
                m_btnMask.SetColor(RGB(GetBValue(dwMask),GetGValue(dwMask),GetRValue(dwMask)));
            }
            else if( sItem == _T("fade") ) {
                m_nFade = (BYTE)_tcstoul(sValue.GetData(), &pstr, 10);
            }
            else if( sItem == _T("hole") ) {
                m_bHole = (_tcscmp(sValue.GetData(), _T("true")) == 0);
            }
        }
        if( *pStrImage++ != _T(' ') ) break;
    }
    m_ctlFade.SetPos(m_nFade);

    int nIndex=m_lstImages.AddString(_T("(无)"));
    m_lstImages.SetItemDataPtr(nIndex,(void*)(LPCTSTR)m_strNullImage);
    const CStringArray* parrImage=g_pResourceView->GetAllImage();
    LPCTSTR pstrImage=NULL;
    LPTSTR pszFileName=NULL;
    for(int i=0; i<parrImage->GetSize(); i++)
    {
        pstrImage=parrImage->GetAt(i);
        pszFileName=_tcsrchr((LPTSTR)pstrImage,_T('\\'))+1;
        nIndex=m_lstImages.AddString(pszFileName);
        m_lstImages.SetItemDataPtr(nIndex,(void*)pstrImage);
    }
    pstrImage=m_strImagePathName;
    pszFileName=_tcsrchr((LPTSTR)pstrImage,_T('\\'))+1;
    m_strImagePathName.IsEmpty()?m_lstImages.SelectString(-1,_T("(无)")):m_lstImages.SelectString(-1,pszFileName);

    UpdateData(FALSE);
    SetImageProperty(m_strImagePathName);

    return TRUE;  // return TRUE unless you set the focus to a control
    // EXCEPTION: OCX Property Pages should return FALSE
}
void MaterialPreviewPropView::OnPropertyChangeNotification( NMHDR *nmhdr, LRESULT *lresult ) {
	idVec3			testColor;
	int				lightId = 0;
	COLORREF		color;
	NMPROPTREE		*nmProp;
	CPropTreeItem	*item;
	CPropTreeItem	*parent;

	nmProp = (NMPROPTREE *)nmhdr;
	item = nmProp->pItem;

	// Determine which light this item modifies
	parent = item->GetParent();
	if ( parent ) {
		lightId = parent->GetCtrlID();
	}

	idStr	itemLabel = item->GetLabelText();
	
	if ( itemLabel == "Model Type" ) {
		materialPreview->OnModelChange( item->GetItemValue() );

	} else if ( itemLabel == "Custom Model" ) {
		materialPreview->OnCustomModelChange( (const char *)item->GetItemValue() );

	} else if ( itemLabel == "Show Lights" ) {
		materialPreview->OnShowLightsChange( item->GetItemValue() ? true : false );

	} else if ( itemLabel == "Shader" ) {
		CPropTreeItemCombo	*combo = (CPropTreeItemCombo *)item;
		CString materialName;

		combo->GetLBText( combo->GetCurSel(), materialName );

		materialPreview->OnLightShaderChange( lightId, materialName.GetBuffer() );

	} else if ( itemLabel == "Radius" ) {
		materialPreview->OnLightRadiusChange( lightId, atof( (char *)item->GetItemValue() ) );

	} else if ( itemLabel == "Color" ) {
		color = item->GetItemValue();

		testColor.x = (float)GetRValue( color ) * (float)( 1.f/255.f );
		testColor.y = (float)GetGValue( color ) * (float)( 1.f/255.f );
		testColor.z = (float)GetBValue( color ) * (float)( 1.f/255.f );

		materialPreview->OnLightColorChange( lightId, testColor );

	} else if ( itemLabel == "Move light" ) {
		materialPreview->OnLightAllowMoveChange( lightId, item->GetItemValue() ? true : false );

	} else if ( itemLabel.Left(4) == "parm" ) {
		int index;

		itemLabel.Strip( "parm" );
		index = atoi( itemLabel.c_str() );

		materialPreview->OnLocalParmChange( index, atof( (char *)item->GetItemValue() ) );

	} else if ( itemLabel.Left(6) == "global" ) {
		int index;

		itemLabel.Strip( "global" );
		index = atoi( itemLabel.c_str() );

		materialPreview->OnGlobalParmChange( index, atof( (char *)item->GetItemValue() ) );
	}
}
long CMUSHclientDoc::FilterPixel(long Pixel, short Operation, double Options) 
{
long r = GetRValue (Pixel),
     g = GetGValue (Pixel),
     b = GetBValue (Pixel);

   switch (Operation)
     {
     case 1:        // Noise
       {
       double threshold = Options / 100.0;
       r += (128 - genrand () * 256) * threshold;
       g += (128 - genrand () * 256) * threshold;
       b += (128 - genrand () * 256) * threshold;
       break;
       }

     case 2:    // MonoNoise
       {
       double threshold = Options / 100.0;
       long j = (128 - genrand () * 256) * threshold;
       r += j;
       g += j;
       b += j;
       break;
       }


     case  7: // Brightness     
        {
        r += Options;
        g += Options;
        b += Options;
        break;
        }


     case  8: // Contrast        
        {
        double c;

        c = r - 128;   // center on zero
        c *= Options;  // multiply by contrast
        r = c + 128;   // put back

        c = g - 128;   // center on zero
        c *= Options;  // multiply by contrast
        g = c + 128;   // put back

        c = b - 128;   // center on zero
        c *= Options;  // multiply by contrast
        b = c + 128;   // put back

        break;
        }


     case  9: // Gamma         
        {
        double c;

        if (Options < 0.0)
          Options = 0.0;

        c = ( (double) r) / 255.0;  // normalize it
        c = pow (c, Options);
        r = c * 255.0;

        c = ( (double) g) / 255.0;  // normalize it
        c = pow (c, Options);
        g = c * 255.0;

        c = ( (double) b) / 255.0;  // normalize it
        c = pow (c, Options);
        b = c * 255.0;

        break;
        }

     case  10: // ColourBrightness - red     
        {
        r += Options;
        break;
        }

     case  11: // ColourContrast - red        
        {
        double c;

        c = r - 128;   // center on zero
        c *= Options;  // multiply by contrast
        r = c + 128;   // put back

        break;
        }

     case  12: // ColourGamma - red         
        {
        double c;

        if (Options < 0.0)
          Options = 0.0;

        c = ( (double) r) / 255.0;  // normalize it
        c = pow (c, Options);
        r = c * 255.0;

        break;
        }

     case  13: // ColourBrightness - green     
        {
        g += Options;
        break;
        }

     case  14: // ColourContrast - green        
        {
        double c;

        c = g - 128;   // center on zero
        c *= Options;  // multiply by contrast
        g = c + 128;   // put back

        break;
        }

     case  15: // ColourGamma - green         
        {
        double c;

        if (Options < 0.0)
          Options = 0.0;

        c = ( (double) g) / 255.0;  // normalize it
        c = pow (c, Options);
        g = c * 255.0;

        break;
        }

     case  16: // ColourBrightness - blue     
        {
        b += Options;
        break;
        }

     case  17: // ColourContrast - blue        
        {
        double c;

        c = b - 128;   // center on zero
        c *= Options;  // multiply by contrast
        b = c + 128;   // put back

        break;
        }

     case  18: // ColourGamma - blue         
        {
        double c;

        if (Options < 0.0)
          Options = 0.0;

        c = ( (double) b) / 255.0;  // normalize it
        c = pow (c, Options);
        b = c * 255.0;

        break;
        }

     case 19: // MakeGreyscale  - linear
       {
        double c;
        c =  r + g + b;
        c /= 3;
        r = c;
        g = c;
        b = c;
        break;
       }

     case 20: // MakeGreyscale  - perceptual
       {
        double c;
        c = b * 0.11 + // blue   (perceptual)
            g * 0.59 + // green
            r * 0.30;  // red
        c /= 3;
        r = c;
        g = c;
        b = c;
        break;
       }

     case  21: // Brightness - multiplicative    
        {
        r *= Options;
        g *= Options;
        b *= Options;
        break;
        }

     case  22: // Brightness - multiplicative - red    
        {
        r *= Options;
        break;
        }

     case  23: // Brightness - multiplicative - green    
        {
        g *= Options;
        break;
        }

     case  24: // Brightness - multiplicative - blue    
        {
        b *= Options;
        break;
        }


     case 27:  // Average (of 1 pixel is itself)
       break;

     default: return -1;

     } // end of switch


	return RGB (CLAMP (r), CLAMP (g), CLAMP (b));
}   // end of CMUSHclientDoc::FilterPixel
Esempio n. 6
0
void Site::Draw(CDC* pDC)
{	
	//设置TextOut的属性
	CFont   font;   
	LOGFONT   lf;   
	memset(&lf,   0,   sizeof(LOGFONT));   
	lf.lfHeight   =   15;         //字体的高   
	lf.lfWidth    =   8;         //字体宽
	font.CreateFontIndirect(&lf);
	pDC->SelectObject(&font);

	HDC hdc=pDC->GetSafeHdc ();
	::SetBkMode(hdc,TRANSPARENT);
	::SetTextColor (hdc,	RGB(255,255,0));
	if(ID>0)//只绘制动态点,静态点副本不绘制!
	{
		COLORREF c=RGB(255-GetRValue(Color)
			,255-GetGValue(Color)
			,255-GetBValue(Color));
		App_Veriable::DefaultSiteSeletedModeColor=c;
		CPen pen;
		if(ID==App_Veriable::SelectedSiteID)//选中的路径
		{
			pen.CreatePen (PS_SOLID,1,App_Veriable::DefaultSiteSeletedModeColor);
		}
		else
			pen.CreatePen (PS_SOLID,1,Color);
		pDC->SelectObject(pen);

		if(Style=='C')
			pDC->Ellipse(Position.x-Size/2,Position.y-Size/2,Position.x+Size/2,Position.y+Size/2);
		if(Style=='T')
		{
			pDC->MoveTo(Position.x,Position.y-sqrt(3.0)*Size/3);
			pDC->LineTo(Position.x-Size/2,Position.y+sqrt(3.0)*Size/6);

			pDC->MoveTo(Position.x-Size/2,Position.y+sqrt(3.0)*Size/6);
			pDC->LineTo(Position.x+Size/2,Position.y+sqrt(3.0)*Size/6);

			pDC->MoveTo(Position.x+Size/2,Position.y+sqrt(3.0)*Size/6);
			pDC->LineTo(Position.x,Position.y-sqrt(3.0)*Size/3);
		}
		if(Style=='R')
			pDC->Rectangle(Position.x-Size/2,Position.y-Size/2,Position.x+Size/2,Position.y+Size/2);

		pen.DeleteObject();

		CBrush brush;
		if(ID==App_Veriable::SelectedSiteID)//选中的路径
			brush.CreateSolidBrush (App_Veriable::DefaultSiteSeletedModeColor);
		else
			brush.CreateSolidBrush (Color);
		pDC->SelectObject(brush);

		if(Style=='C')
		{
			/*CRgn c;
			c.CreateEllipticRgn(Position.x-Size/2,Position.y-Size/2,Position.x+Size/2,Position.x+Size/2);
			pDC->FillRgn (&c,&brush);
			c.DeleteObject();*/
			pDC->Ellipse(Position.x-Size/2,Position.y-Size/2,Position.x+Size/2,Position.y+Size/2);//效果更好???
		}
		if(Style=='T')
		{
			CPoint points[3];
			points[0].x=Position.x;
			points[0].y=Position.y-sqrt(3.0)*Size/3;
			points[1].x=Position.x-Size/2;
			points[1].y=Position.y+sqrt(3.0)*Size/6;
			points[2].x=Position.x+Size/2;
			points[2].y=Position.y+sqrt(3.0)*Size/6;
			CRgn c;
			c.CreatePolygonRgn (points,3,WINDING);
			pDC->FillRgn (&c,&brush);
			c.DeleteObject();
		}
		if(Style=='R')
		{
			CRgn c;
			c.CreateRectRgn (Position.x-Size/2,Position.y-Size/2,Position.x+Size/2,Position.y+Size/2);
			pDC->FillRgn (&c,&brush);
			c.DeleteObject();
			/*pDC->Rectangle(Position.x-Size/2,Position.y-Size/2,Position.x+Size/2,Position.x+Size/2);*///不能用,好奇怪???
		}

		if(this->SiteInfo!=App_Veriable::DefaultSiteInfo&&App_Veriable::ShowSiteInfo)
			pDC->TextOutW(this->Position.x,this->Position.y,this->SiteInfo);

		brush.DeleteObject();
	}

}
Esempio n. 7
0
// This is what does the work in the background thread
UINT CHexEditDoc::RunAerialThread()
{
    // Keep looping until we are told to die
    for (;;)
    {
        // Signal that we are waiting then wait for start_aerial_event_ to be pulsed
        {
            CSingleLock sl(&docdata_, TRUE);
            aerial_state_ = WAITING;
        }
        TRACE1("+++ BGAerial: waiting for %p\n", this);
        DWORD wait_status = ::WaitForSingleObject(HANDLE(start_aerial_event_), INFINITE);
        docdata_.Lock();
        aerial_state_ = SCANNING;
        docdata_.Unlock();
        start_aerial_event_.ResetEvent();
        ASSERT(wait_status == WAIT_OBJECT_0);
        TRACE1("+++ BGAerial: got event for %p\n", this);

        if (AerialProcessStop())
            continue;

        // Reset for new scan
        docdata_.Lock();
        aerial_fin_ = false;
        aerial_addr_ = 0;
        FILE_ADDRESS file_len = length_;
        int file_bpe = bpe_;
        unsigned char *file_dib = FreeImage_GetBits(dib_);
        unsigned dib_size = FreeImage_GetDIBSize(dib_);
        docdata_.Unlock();
        TRACE("+++ BGAerial: using bitmap at %p\n", file_dib);

        // Get the file buffer
        size_t buf_len = (size_t)min(file_len, 65536);
        ASSERT(aerial_buf_ == NULL);
        aerial_buf_ = new unsigned char[buf_len];

        for (;;)
        {
            // First check if we need to stop
            if (AerialProcessStop())
                break;   // stop processing and go back to WAITING state

            // Check if we have finished scanning the file
            if (aerial_addr_ >= file_len)
            {
                TRACE2("+++ BGAerial: finished scan for %p at address %p\n", this, file_dib + 3*size_t(aerial_addr_/file_bpe));
                CSingleLock sl(&docdata_, TRUE); // Protect shared data access

                aerial_fin_ = true;
                break;                          // falls out to end_scan
            }

            // Get the next buffer full from the file and scan it
            size_t got = GetData(aerial_buf_, buf_len, aerial_addr_, 3);
            ASSERT(got <= buf_len);

            unsigned char *pbm = file_dib + 3*size_t(aerial_addr_/file_bpe);    // where we write to bitmap
            unsigned char *pbuf;                                        // where we read from the file buffer
            for (pbuf = aerial_buf_; pbuf < aerial_buf_ + got; pbuf += file_bpe, pbm += 3)
            {
                int r, g, b;
                r = g = b = 0;
                for (unsigned char *pp = pbuf; pp < pbuf + file_bpe; ++pp)
                {
                    r += GetRValue(kala_[*pp]);
                    g += GetGValue(kala_[*pp]);
                    b += GetBValue(kala_[*pp]);
                }
                *pbm     = unsigned char(b/file_bpe);
                *(pbm+1) = unsigned char(g/file_bpe);
                *(pbm+2) = unsigned char(r/file_bpe);
            }
            aerial_addr_ += got;
        }

        delete[] aerial_buf_;
        aerial_buf_ = NULL;
    }
    return 0;   // never reached
}
Esempio n. 8
0
Color RenderThemeWinCE::platformActiveSelectionForegroundColor() const
{
    COLORREF color = GetSysColor(COLOR_HIGHLIGHTTEXT);
    return Color(GetRValue(color), GetGValue(color), GetBValue(color), 255);
}
//*****************************************************************************************
void CBCGPColorMenuButton::OnDraw (CDC* pDC, const CRect& rect, CBCGPToolBarImages* pImages,
			BOOL bHorz, BOOL bCustomizeMode, BOOL bHighlight,
			BOOL bDrawBorder, BOOL bGrayDisabledButtons)
{
	ASSERT_VALID (this);
	ASSERT_VALID (pDC);

	CBCGPToolbarMenuButton::OnDraw (pDC, rect, pImages, bHorz, bCustomizeMode,
		bHighlight, bDrawBorder, bGrayDisabledButtons);

	if (!IsDrawImage () || pImages == NULL)
	{
		return;
	}

    CPalette* pOldPalette = NULL;
	if (globalData.m_nBitsPerPixel == 8) // 256 colors
	{
		if (m_Palette.GetSafeHandle () == NULL)
		{
			//----------------------------------------
			// Palette not created yet; create it now
			//----------------------------------------
			CBCGPColorBar::CreatePalette (m_Colors, m_Palette);
		}

		ASSERT (m_Palette.GetSafeHandle () != NULL);

		pOldPalette = pDC->SelectPalette (&m_Palette, FALSE);
		pDC->RealizePalette ();
	}
	else if (m_Palette.GetSafeHandle () != NULL)
	{
		::DeleteObject (m_Palette.Detach ());
		ASSERT (m_Palette.GetSafeHandle () == NULL);
	}

	ASSERT (pImages != NULL);
	CRect rectColor = pImages->GetLastImageRect ();
	const int nColorBoxSize = CBCGPToolBar::IsLargeIcons () && !m_bMenuMode ? 10 : 5;

	rectColor.top = rectColor.bottom - nColorBoxSize;
	rectColor.OffsetRect (0, 1);

	//----------------
	// Draw color bar:
	//----------------
	BOOL bDrawImageShadow = 
		bHighlight && !bCustomizeMode &&
		CBCGPVisualManager::GetInstance ()->IsShadowHighlightedImage () &&
		!globalData.IsHighContastMode () &&
		((m_nStyle & TBBS_PRESSED) == 0) &&
		((m_nStyle & TBBS_CHECKED) == 0) &&
		((m_nStyle & TBBS_DISABLED) == 0);

	if (bDrawImageShadow)
	{
		CBrush brShadow (globalData.clrBarShadow);
		pDC->FillRect (rectColor, &brShadow);
		rectColor.OffsetRect (-1, -1);
	}

	COLORREF color = (m_nStyle & TBBS_DISABLED) ?
		globalData.clrBarShadow :
			(m_Color == (COLORREF)-1 ? m_colorAutomatic : m_Color);

	CBrush br (PALETTERGB(	GetRValue (color),
							GetGValue (color), 
							GetBValue (color)));

	CBrush* pOldBrush = pDC->SelectObject (&br);
	CPen* pOldPen = (CPen*) pDC->SelectStockObject (NULL_PEN);
	
	pDC->Rectangle (&rectColor);

	pDC->SelectObject (pOldPen);
	pDC->SelectObject (pOldBrush);

	if (CBCGPVisualManager::GetInstance ()->IsMenuFlatLook ())
	{
		if (color == globalData.clrBarFace)
		{
			pDC->Draw3dRect (rectColor, globalData.clrBarDkShadow, globalData.clrBarDkShadow);
		}
	}
	else
	{
		pDC->Draw3dRect (rectColor, globalData.clrBarShadow, globalData.clrBarLight);
	}
	
    if (pOldPalette != NULL)
	{
        pDC->SelectPalette (pOldPalette, FALSE);
	}
}
void CAtmoGdiDisplayCaptureInput::CalcColors() 
{
     tRGBColor pixelColor;
#ifdef UseGdiGetPixel
     COLORREF pixel;
#ifdef UseGdiDesktopGetPixel 
 	 HDC hdcScreen;
#endif
#endif

     int xx,yy;

     int capture_area_width  = (m_ScreenSourceRect.right-m_ScreenSourceRect.left);
     int capture_area_height = (m_ScreenSourceRect.bottom-m_ScreenSourceRect.top);

#ifndef UseGdiDesktopGetPixel
     HBITMAP hTempBitmap  = CreateCompatibleBitmap(m_hdcScreen, capture_area_width, capture_area_height);
     HGDIOBJ hOldBmp = SelectObject(m_hTempBitmapDC, hTempBitmap);
#endif

#ifndef UseGdiGetPixel
     BITMAPINFO bmpInfo;
     ZeroMemory(&bmpInfo, sizeof(BITMAPINFO));
     bmpInfo.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);

     GetDIBits(m_hTempBitmapDC,hTempBitmap,0,1,NULL,&bmpInfo,DIB_RGB_COLORS);

   //  bmpInfo.bmiHeader.biWidth  = capture_area_width;
   //  bmpInfo.bmiHeader.biHeight = -capture_area_height;

     if(bmpInfo.bmiHeader.biSizeImage<=0)
        bmpInfo.bmiHeader.biSizeImage=bmpInfo.bmiHeader.biWidth * abs(bmpInfo.bmiHeader.biHeight)*(bmpInfo.bmiHeader.biBitCount+7)/8;

     bmpInfo.bmiHeader.biCompression=BI_RGB;
#endif


//    have a look into VncDesktop.cpp :-) **g vncDesktop::CaptureScreen
//    vncDesktop::EnableOptimisedBlits() vncDesktop::CopyToBuffer(
//    http://cboard.cprogramming.com/archive/index.php/t-89037.html
//    http://cboard.cprogramming.com/showthread.php?t=76907   das schaut gut aus!!!!!!
//    damit spart man die GetDIBits(...) aufrufe... und bekommt mittelsBitBlit gleich alles
//    ins eigene Ram Kopiert... Full Access to display ram... :-)))
//

#ifndef UseGdiDesktopGetPixel
     BitBlt(m_hTempBitmapDC, 0, 0, capture_area_width, capture_area_height, m_hdcScreen, m_ScreenSourceRect.left, m_ScreenSourceRect.top, SRCCOPY);
#endif

     int index = (m_CurrentFrame * CAP_WIDTH);
     int indexSkip = ((m_rowsPerFrame-1) * CAP_WIDTH);
     unsigned int col = 0;

#ifdef UseGdiGetPixel
    #ifdef UseGdiDesktopGetPixel
       hdcScreen      = GetDC(NULL);  
    #endif


      for(int y=m_CurrentFrame; y<CAP_HEIGHT; y+=m_rowsPerFrame ) {
            // yy = (y * capture_area_height) / CAP_HEIGHT;
            // yy = yy + m_ScreenSourceRect.top + m_tShift;
            yy = m_iSrcRows[y];

            for(int x=0;x<CAP_WIDTH;x++) {
                // xx = (x * capture_area_width) / CAP_WIDTH;
                // xx = xx + m_ScreenSourceRect.left + m_lShift;
      #ifndef UseGdiDesktopGetPixel
                pixel = GetPixel(m_hTempBitmapDC, m_iSrcCols[x], yy);
      #else
                pixel = GetPixel(hdcScreen, m_iSrcCols[x], yy);
      #endif
                pixelColor.r = GetRValue(pixel);
                pixelColor.g = GetGValue(pixel);
                pixelColor.b = GetBValue(pixel);

                HSV_Img[index++] = RGB2HSV(pixelColor);
            }
            index += indexSkip;
       }

  #ifdef UseGdiDesktopGetPixel
      ReleaseDC(NULL, hdcScreen);
  #endif


#else
     switch(bmpInfo.bmiHeader.biBitCount) {
            case  8: { // [TF] 8bit support added by Tobias Fleischer/Tobybear - still untested and experimental, might not work!
				int nColors = bmpInfo.bmiHeader.biClrUsed ? bmpInfo.bmiHeader.biClrUsed : 1 << bmpInfo.bmiHeader.biBitCount;
				for( int y=m_CurrentFrame; y<CAP_HEIGHT; y+=m_rowsPerFrame ) {
                    // yy = (y * capture_area_height) / CAP_HEIGHT;
                    // yy = yy + m_ScreenSourceRect.top + m_tShift;

                   if(bmpInfo.bmiHeader.biHeight>0)
                      yy = bmpInfo.bmiHeader.biHeight - m_iSrcRows[y] - 1;
                   else
                      yy = m_iSrcRows[y];


                    // eine Bildzeile in meinen Arbeitsbuffer kopieren!
                    // geht vielfach schneller als GetPixel aufrufen... wenn man dein Speicher dann direkt
                    // zugreift... :-)
                    GetDIBits(m_hTempBitmapDC,hTempBitmap,yy,1,m_PixelBuffer,&bmpInfo,DIB_RGB_COLORS);
                    for(int x=0; x<CAP_WIDTH; x++) {
						xx           = m_iSrcCols[x];
						col			 = m_PixelBuffer[xx] % nColors;
						pixelColor.b = bmpInfo.bmiColors[col].rgbBlue;
						pixelColor.g = bmpInfo.bmiColors[col].rgbGreen;
						pixelColor.r = bmpInfo.bmiColors[col].rgbRed;
                        HSV_Img[index++] = RGB2HSV(pixelColor);					
					}
                    index += indexSkip;
                }
                break;
            }

            case 16: { // [TF] 16bit support added by Tobias Fleischer/Tobybear - tested
                for(int y=m_CurrentFrame; y<CAP_HEIGHT; y+=m_rowsPerFrame ) {
                    // yy = (y * capture_area_height) / CAP_HEIGHT;
                    // yy = yy + m_ScreenSourceRect.top + m_tShift;

                   if(bmpInfo.bmiHeader.biHeight>0)
                      yy = bmpInfo.bmiHeader.biHeight - m_iSrcRows[y] - 1;
                   else
                      yy = m_iSrcRows[y];


                    // eine Bildzeile in meinen Arbeitsbuffer kopieren!
                    // geht vielfach schneller als GetPixel aufrufen... wenn man dein Speicher dann direkt
                    // zugreift... :-)
                    GetDIBits(m_hTempBitmapDC,hTempBitmap,yy,1,m_PixelBuffer,&bmpInfo,DIB_RGB_COLORS);
                    for(int x=0;x<CAP_WIDTH;x++) {
                        xx           = m_iSrcCols[x] * 2;
						col = m_PixelBuffer[xx] + (m_PixelBuffer[xx+1]<<8);
						pixelColor.b = (col & 0x1F)<<3;
						pixelColor.g = (col & 0x3E0)>>2;
						pixelColor.r = (col & 0x7C00)>>7;
                        HSV_Img[index++] = RGB2HSV(pixelColor);
                    }
                    index += indexSkip;
                }
                break;
            }

            case 24: {
                for(int y=m_CurrentFrame; y<CAP_HEIGHT; y+=m_rowsPerFrame ) {
                    // yy = (y * capture_area_height) / CAP_HEIGHT;
                    // yy = yy + m_ScreenSourceRect.top + m_tShift;


                   if(bmpInfo.bmiHeader.biHeight>0)
                      yy = bmpInfo.bmiHeader.biHeight - m_iSrcRows[y] - 1;
                   else
                      yy = m_iSrcRows[y];


                    // eine Bildzeile in meinen Arbeitsbuffer kopieren!
                    // geht vielfach schneller als GetPixel aufrufen... wenn man dein Speicher dann direkt
                    // zugreift... :-)
                    GetDIBits(m_hTempBitmapDC,hTempBitmap,yy,1,m_PixelBuffer,&bmpInfo,DIB_RGB_COLORS);
                    for(int x=0;x<CAP_WIDTH;x++) {
                        xx           = m_iSrcCols[x] * 3;
                        pixelColor.b = m_PixelBuffer[xx++];
                        pixelColor.g = m_PixelBuffer[xx++];
                        pixelColor.r = m_PixelBuffer[xx++];
                        HSV_Img[index++] = RGB2HSV(pixelColor);
                    }
                    index += indexSkip;
                }
                break;
            }

            case 32: {
                for(int y=m_CurrentFrame; y<CAP_HEIGHT; y+=m_rowsPerFrame ) {
                   if(bmpInfo.bmiHeader.biHeight>0)
                      yy = bmpInfo.bmiHeader.biHeight - m_iSrcRows[y] - 1;
                   else
                      yy = m_iSrcRows[y];

                    // eine Bildzeile in meinen Arbeitsbuffer kopieren!
                    // geht vielfach schneller als GetPixel aufrufen... wenn man dein Speicher dann direkt
                    // zugreift... :-)
                    GetDIBits(m_hTempBitmapDC,hTempBitmap,yy,1,m_PixelBuffer,&bmpInfo,DIB_RGB_COLORS);

                    for(int x=0;x<CAP_WIDTH;x++) {
                        // xx = (x * capture_area_width) / CAP_WIDTH;
                        // xx = xx + m_ScreenSourceRect.left + m_lShift;
                        xx = m_iSrcCols[x] * 4;
                        pixelColor.b = m_PixelBuffer[xx++];
                        pixelColor.g = m_PixelBuffer[xx++];
                        pixelColor.r = m_PixelBuffer[xx++];
                        HSV_Img[index++] = RGB2HSV(pixelColor);
                    }
                    index += indexSkip;
                }
                break;
            }
     }

#endif

#ifndef UseGdiDesktopGetPixel
     SelectObject(m_hTempBitmapDC, hOldBmp);
     DeleteObject(hTempBitmap);
#endif

     m_CurrentFrame++;
     if(m_CurrentFrame >= m_rowsPerFrame) 
        m_CurrentFrame = 0;
 
     m_pAtmoDynData->getLivePacketQueue()->AddPacket( m_pAtmoColorCalculator->AnalyzeHSV( HSV_Img ) );
}
Esempio n. 11
0
Color RenderThemeWinCE::platformInactiveSelectionBackgroundColor() const
{
    COLORREF color = GetSysColor(COLOR_GRAYTEXT);
    return Color(GetRValue(color), GetGValue(color), GetBValue(color), 255);
}
Esempio n. 12
0
void vxPaintDC::_FillGradient(const LPRECT lpRect, COLORREF colorStart, COLORREF colorFinish,
			bool bHorz /* = TRUE */, int nStartFlatPercentage /* = 0 */, int nEndFlatPercentage /* = 0 */)
{
	if (NULL == lpRect)
		return;

	if (colorStart == colorFinish)
	{
		HBRUSH hbr = ::CreateSolidBrush(colorStart);
		assert(NULL != hbr);
		::FillRect(m_hDC, lpRect, hbr);
		::DeleteObject((HGDIOBJ)hbr);
		return;
	}

	if (nStartFlatPercentage > 0)
	{
		assert(nStartFlatPercentage <= 100);

		if (bHorz)
		{
			RECT rectTop;
			memcpy(&rectTop, lpRect, sizeof(RECT));
			rectTop.bottom = rectTop.top + (rectTop.bottom - rectTop.top) * nStartFlatPercentage / 100;
			lpRect->top = rectTop.bottom;

			HBRUSH hbr = ::CreateSolidBrush(colorFinish);
			assert(NULL != hbr);
			::FillRect(m_hDC, &rectTop, hbr);
			::DeleteObject((HGDIOBJ)hbr);
		}
		else
		{
			RECT rectLeft;
			memcpy(&rectLeft, lpRect, sizeof(RECT));
			rectLeft.right = rectLeft.left + (rectLeft.right - rectLeft.left) * nStartFlatPercentage / 100;
			lpRect->left = rectLeft.right;

			HBRUSH hbr = ::CreateSolidBrush(colorStart);
			assert(NULL != hbr);
			::FillRect(m_hDC, &rectLeft, hbr);
			::DeleteObject((HGDIOBJ)hbr);
		}
	}

	if (nEndFlatPercentage > 0)
	{
		assert(nEndFlatPercentage <= 100);

		if (bHorz)
		{
			RECT rectBottom;
			memcpy(&rectBottom, lpRect, sizeof(RECT));
			rectBottom.top = rectBottom.bottom - (rectBottom.bottom - rectBottom.top) * nEndFlatPercentage / 100;
			lpRect->bottom = rectBottom.top;

			HBRUSH hbr = ::CreateSolidBrush(colorStart);
			assert(NULL != hbr);
			::FillRect(m_hDC, &rectBottom, hbr);
			::DeleteObject((HGDIOBJ)hbr);
		}
		else
		{
			RECT rectRight;
			memcpy(&rectRight, lpRect, sizeof(RECT));
			rectRight.left = rectRight.right - (rectRight.right - rectRight.left) * nEndFlatPercentage / 100;
			lpRect->right = rectRight.left;

			HBRUSH hbr = ::CreateSolidBrush(colorFinish);
			assert(NULL != hbr);
			::FillRect(m_hDC, &rectRight, hbr);
			::DeleteObject((HGDIOBJ)hbr);
		}
	}

	if (nEndFlatPercentage + nStartFlatPercentage > 100)
	{
		assert(FALSE);
		return;
	}

	// this will make 2^6 = 64 fountain steps
	int nShift = 6;
	int nSteps = 1 << nShift;

	for (int i = 0; i < nSteps; i++)
	{
		// do a little alpha blending
		BYTE bR = (BYTE)((GetRValue(colorStart) * (nSteps - i) + GetRValue(colorFinish) * i) >> nShift);
		BYTE bG = (BYTE)((GetGValue(colorStart) * (nSteps - i) + GetGValue(colorFinish) * i) >> nShift);
		BYTE bB = (BYTE)((GetBValue(colorStart) * (nSteps - i) + GetBValue(colorFinish) * i) >> nShift);

		HBRUSH hbr = ::CreateSolidBrush(RGB(bR, bG, bB));

		// then paint with the resulting color
		RECT r2;
		memcpy(&r2, lpRect, sizeof(RECT));
		if (bHorz)
		{
			r2.bottom = lpRect->bottom - ((i * (lpRect->bottom - lpRect->top)) >> nShift);
			r2.top = lpRect->bottom - (((i + 1) * (lpRect->bottom - lpRect->top)) >> nShift);
			if ((r2.bottom - r2.top) > 0)
			{
				::FillRect(m_hDC, &r2, hbr);
			}
		}
		else
		{
			r2.left = lpRect->left + ((i * (lpRect->right - lpRect->left)) >> nShift);
			r2.right = lpRect->left + (((i + 1) * (lpRect->right - lpRect->left)) >> nShift);
			if ((r2.right - r2.left) > 0)
			{
				::FillRect(m_hDC, &r2, hbr);
			}
		}

		::DeleteObject((HGDIOBJ)hbr);
	}
Esempio n. 13
0
void CDigistring::OnPaint() 
{
	CRect rect;
	CDoubleRect CharRect;
	GetClientRect(&rect);

	CPaintDC dc(this); // device context for painting
	dc.SetBkColor(m_BackColor);
	CMyMemDC memDC(&dc, &rect);

	CBrush hBrushOff, hBrushOn;
	hBrushOff.CreateSolidBrush(m_OffColor);
	hBrushOn.CreateSolidBrush(m_OnColor);
	CBrush *pOldBrush = memDC.SelectObject(&hBrushOn);

		int r = int(GetRValue(m_OffColor) * 0.75 + GetRValue(m_BackColor) * 0.25);
		int g = int(GetGValue(m_OffColor) * 0.75 + GetGValue(m_BackColor) * 0.25);
		int b = int(GetBValue(m_OffColor) * 0.75 + GetBValue(m_BackColor) * 0.25);

	CPen OffPen(PS_SOLID | PS_ENDCAP_ROUND, 1, RGB(r,g,b));
		r = int(GetRValue(m_OnColor) * 0.75 + GetRValue(m_BackColor) * 0.25);
		g = int(GetGValue(m_OnColor) * 0.75 + GetGValue(m_BackColor) * 0.25);
		b = int(GetBValue(m_OnColor) * 0.75 + GetBValue(m_BackColor) * 0.25);
	CPen OnPen(PS_SOLID | PS_ENDCAP_ROUND, 1, RGB(r,g,b));
	CPen *pOldPen = memDC.SelectObject(&OffPen);

	int iTotWidth = 0;
	double dRelWidth, dRelHeight;
	// TODO: Add your message handler code here

	DigiCharVector::iterator CharIterator;

	// Calculate resizing factors...
	BuildString();
	for (CharIterator = m_CharVector.begin(); CharIterator != m_CharVector.end();
		CharIterator++)
	{
		iTotWidth += CharIterator->GetNormWidth();
	}
	dRelWidth = double(rect.Width()) / iTotWidth;
	dRelHeight = double(rect.Height()) / NORM_DIGIHEIGHT;

	// If proportional make offset for centered text
	if (m_DispStyle & DS_SZ_PROP)
	{
		if (dRelWidth < dRelHeight)
			dRelHeight = dRelWidth;
		else
			dRelWidth = dRelHeight;

		CharRect.left = (rect.Width() - dRelWidth * iTotWidth) / 2;
		CharRect.top = (rect.Height() - dRelHeight * NORM_DIGIHEIGHT) / 2; 
	}
	else
		CharRect.SetRectEmpty();

	// Draw all characters...
	for (CharIterator = m_CharVector.begin(); CharIterator != m_CharVector.end();
		CharIterator++)
	{
		CharRect.SetRect(CharRect.left, CharRect.top,
			CharRect.left + dRelWidth * CharIterator->GetNormWidth(), 
			CharRect.top  + dRelHeight * NORM_DIGIHEIGHT);

		CharIterator->Draw(&memDC, CharRect, &OffPen, &OnPen, &hBrushOff, &hBrushOn);

		CharRect.left += dRelWidth * CharIterator->GetNormWidth();
	}

	// Mama says: Clean up your mess!
	memDC.SelectObject(pOldPen);
	memDC.SelectObject(pOldBrush);
	OffPen.DeleteObject();
	OnPen.DeleteObject();
	hBrushOff.DeleteObject();
	hBrushOn.DeleteObject();
}
Esempio n. 14
0
/*
=====================
	paint_Pathcast
=====================
*/
void paint_Pathcast( place_t place ) {
	int xi, yi;
	int xf, yf;
	int i,j;
	COLORREF cr;
	int tmp;
	game_t *game = NULL;
	figure_t *fig = NULL;
	int blocksize = BLOCKSIZE;

	switch( place ) {
		case LEFTGAME:
			game = k_system.pLeftGame;
			break;
		
		case RIGHTGAME:
			game = k_system.pRightGame;
			break;
		
		default:
			return;
	}
	
	if( game == NULL ) {
		return;
	}

	//validate figure
	//
	if( game->pFig == NULL ) {
		return;
	}

	fig = game->pFig;
	if( fig->desintegrated ) {
		return;
	}
	
	//sometimes the figure has an invalid position
	//and seqProc has not been called yet to fix the problem
	//
	if( (fig->pos.y >= CYSPACE) ) {
		return;
	}
	
	cr = kcfTable[VAR_EFF_PATHCAST_COLOR].v.dw;
	glColor3f( GetRValue(cr)/255.0f, GetGValue(cr)/255.0f, GetBValue(cr)/255.0f );

	//draw pathcast effect
	//
	glBegin( GL_QUADS );
	for( j=0; j<CXFIG; j++ ) {
		i = 0;
		tmp = -1;
		while( i<CYFIG ) {
			if( kFigRes[fig->type][i][fig->state*CSTATE + j] == 1 ) {
				tmp=i;
			}
			i++;
		}
		
		//cast "shadow"
		//
		if( (tmp < 4) && (tmp > -1) ) {

			xi = ( j + fig->pos.x );
			yi = ( tmp + fig->pos.y + 1 );
			
			yf = yi;
			xf = xi;

			while( (yf < CYSPACE) && (SPACE_CELL( game->AS, yf, xf ) != MAPCELL_BLOCK) ) {
				yf++;
			}
			
			if( yf > yi ) {
				NGL_polygon( (GLfloat)( xi*blocksize ), (GLfloat)( yf*blocksize - blocksize/3 ),
					(GLfloat)( (xi+1)*blocksize ), (GLfloat)( yf*blocksize ) );
			}
		}
	}
	glEnd();
}
Esempio n. 15
0
//////////////////////////////////////////////////////////////////////////
//函数名:BitmapToRegion
//功能:输入图像句柄,得到抠除了蒙板色的区域
//原作者:Jean-Edouard Lachand Robert, August 5, 1998
//修改人:C瓜哥(www.cguage.com)
HRGN CAnimateButton::BitmapToRegion(HBITMAP hBmp, int nSplit, int n, 
			COLORREF cTransparentColor = RGB(255, 0, 255), 	COLORREF cTolerance = RGB(255, 0, 255))
{
	HRGN hRgn = NULL;

	if (hBmp)
	{
		// Create a memory DC inside which we will scan the bitmap content
		HDC hMemDC = CreateCompatibleDC(NULL);
		if (hMemDC)
		{
			// Get bitmap size
			BITMAP bm;
			GetObject(hBmp, sizeof(bm), &bm);

			// Create a 32 bits depth bitmap and select it into the memory DC 
			BITMAPINFOHEADER RGB32BITSBITMAPINFO =
			{	
				sizeof(BITMAPINFOHEADER),	// biSize 
				bm.bmWidth,					// biWidth; 
				bm.bmHeight,				// biHeight; 
				1,							// biPlanes; 
				32,							// biBitCount 
				BI_RGB,						// biCompression; 
				0,							// biSizeImage; 
				0,							// biXPelsPerMeter; 
				0,							// biYPelsPerMeter; 
				0,							// biClrUsed; 
				0							// biClrImportant; 
			};

			//每种状态图的宽度
			int nBlockWidth = bm.bmWidth / nSplit;

			VOID * pbits32; 
			HBITMAP hbm32 = CreateDIBSection(hMemDC, (BITMAPINFO *)&RGB32BITSBITMAPINFO, DIB_RGB_COLORS, &pbits32, NULL, 0);
			if (hbm32)
			{
				HBITMAP holdBmp = (HBITMAP)SelectObject(hMemDC, hbm32);

				// Create a DC just to copy the bitmap into the memory DC
				HDC hDC = CreateCompatibleDC(hMemDC);
				if (hDC)
				{
					// Get how many bytes per row we have for the bitmap bits (rounded up to 32 bits)
					BITMAP bm32;
					GetObject(hbm32, sizeof(bm32), &bm32);
					while (bm32.bmWidthBytes % 4)
						bm32.bmWidthBytes++;

					// Copy the bitmap into the memory DC
					HBITMAP holdBmp = (HBITMAP)SelectObject(hDC, hBmp);
					BitBlt(hMemDC, 0, 0, nBlockWidth, bm.bmHeight, hDC, nBlockWidth * n, 0, SRCCOPY);

					// For better performances, we will use the ExtCreateRegion() function to create the
					// region. This function take a RGNDATA structure on entry. We will add rectangles by
					// amount of ALLOC_UNIT number in this structure.
#define ALLOC_UNIT	100
					DWORD maxRects = ALLOC_UNIT;
					HANDLE hData = GlobalAlloc(GMEM_MOVEABLE, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects));
					RGNDATA *pData = (RGNDATA *)GlobalLock(hData);
					pData->rdh.dwSize = sizeof(RGNDATAHEADER);
					pData->rdh.iType = RDH_RECTANGLES;
					pData->rdh.nCount = pData->rdh.nRgnSize = 0;
					SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);

					// Keep on hand highest and lowest values for the "transparent" pixels
					BYTE lr = GetRValue(cTransparentColor);
					BYTE lg = GetGValue(cTransparentColor);
					BYTE lb = GetBValue(cTransparentColor);
					BYTE hr = min(0xff, lr + GetRValue(cTolerance));
					BYTE hg = min(0xff, lg + GetGValue(cTolerance));
					BYTE hb = min(0xff, lb + GetBValue(cTolerance));

					// Scan each bitmap row from bottom to top (the bitmap is inverted vertically)
					BYTE *p32 = (BYTE *)bm32.bmBits + (bm32.bmHeight - 1) * bm32.bmWidthBytes;
					for (int y = 0; y < bm.bmHeight; y++)
					{
						// Scan each bitmap pixel from left to right
						for (int x = 0; x < nBlockWidth; x++)
						{
							// Search for a continuous range of "non transparent pixels"
							int x0 = x;
							LONG *p = (LONG *)p32 + x;
							while (x < nBlockWidth)
							{

								BYTE b = GetRValue(*p);
								if (b >= lr && b <= hr)
								{
									b = GetGValue(*p);
									if (b >= lg && b <= hg)
									{
										b = GetBValue(*p);
										if (b >= lb && b <= hb)
											// This pixel is "transparent"
											break;
									}
								}
								p++;
								x++;
							}

							if (x > x0)
							{
								// Add the pixels (x0, y) to (x, y+1) as a new rectangle in the region
								if (pData->rdh.nCount >= maxRects)
								{
									GlobalUnlock(hData);
									maxRects += ALLOC_UNIT;
									hData = GlobalReAlloc(hData, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), GMEM_MOVEABLE);
									pData = (RGNDATA *)GlobalLock(hData);
								}
								RECT *pr = (RECT *)&pData->Buffer;
								SetRect(&pr[pData->rdh.nCount], x0, y, x, y+1);
								if (x0 < pData->rdh.rcBound.left)
									pData->rdh.rcBound.left = x0;
								if (y < pData->rdh.rcBound.top)
									pData->rdh.rcBound.top = y;
								if (x > pData->rdh.rcBound.right)
									pData->rdh.rcBound.right = x;
								if (y+1 > pData->rdh.rcBound.bottom)
									pData->rdh.rcBound.bottom = y+1;
								pData->rdh.nCount++;

								// On Windows98, ExtCreateRegion() may fail if the number of rectangles is too
								// large (ie: > 4000). Therefore, we have to create the region by multiple steps.
								if (pData->rdh.nCount == 2000)
								{
									HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
									if (hRgn)
									{
										CombineRgn(hRgn, hRgn, h, RGN_OR);
										DeleteObject(h);
									}
									else
										hRgn = h;
									pData->rdh.nCount = 0;
									SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
								}
							}
						}

						// Go to next row (remember, the bitmap is inverted vertically)
						p32 -= bm32.bmWidthBytes;
					}

					// Create or extend the region with the remaining rectangles
					HRGN h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * maxRects), pData);
					if (hRgn)
					{
						CombineRgn(hRgn, hRgn, h, RGN_OR);
						DeleteObject(h);
					}
					else
						hRgn = h;

					// Clean up
					SelectObject(hDC, holdBmp);
					DeleteDC(hDC);
				}

				DeleteObject(SelectObject(hMemDC, holdBmp));
			}

			DeleteDC(hMemDC);
		}	
	}// if hBmp

	return hRgn;
}
Esempio n. 16
0
/**
 * colorize an image item (both standalone items with their own bitmap and glyph items).
 *
 * @param item			image item to colorize
 * @param clr			color to use (note: BGRA format required, although, alpha is ignored)
 * @param hue			hue adjustment (in degrees, -180 .. +180
 * @param saturation	scalar value (0.0 ... 1.0)
 * @param value			scalar value (0.0 ... 1.0)
 *
 * note: this isn't performance critical as it only runs at skin loading time or when
 * the user changes colorization options, never during rendering.
 *
 * if clr == 0, hsv transformation will be applied, otherwise it's rgb colorization.
 */
void Gfx::colorizeGlyph(TImageItem *item, const COLORREF clr, float hue, float saturation, float value)
{
	LONG	stride = 0, line, pixel;
	HBITMAP hBitmap = 0;
	LONG	x, y, x1, y1;
	BITMAP 	bmp = {0};
	DWORD	dwLen;
	BYTE*	pOrig, *pLine, alpha;
	float	v_s_u = 0, v_s_w = 0, r = 0, g = 0, b = 0;

    if(0 == clr) {			// do hsv transformation
    	v_s_u = value * saturation * cos(hue * M_PI/180);
    	v_s_w = value * saturation * sin(hue * M_PI/180);
    }
    else {					// rgb colorization
    	BYTE	rValue = GetRValue(clr);
    	BYTE	gValue = GetGValue(clr);
    	BYTE	bValue = GetBValue(clr);

    	r = (float)rValue / 2.55;
    	g = (float)gValue / 2.55;
    	b = (float)bValue / 2.55;
    }
	if(item) {
		/*
		 * colorize a rectangular glyph
		 */
		if(item->dwFlags & IMAGE_GLYPH) {
			hBitmap = Skin::glyphItem->hbm;
			x = item->glyphMetrics[0];
			y = item->glyphMetrics[1];
			x1 = x + item->glyphMetrics[2] - 1;
			y1 = y + item->glyphMetrics[3] - 1;

			GetObject(hBitmap, sizeof(bmp), &bmp);

			if (bmp.bmBitsPixel != 32)
				return;

			dwLen = bmp.bmWidth * bmp.bmHeight * 4;
			if (dwLen > m_sAllocated) {
				m_p = (BYTE *)realloc(m_p, dwLen);
				dwLen = (DWORD)m_sAllocated;
			}
			memset(m_p, 0, dwLen);
			pOrig = m_p;
			GetBitmapBits(hBitmap, dwLen, m_p);

			stride = bmp.bmWidthBytes;

			m_p += ((y * stride) + (4 * x));

			for(line = y; line <= y1; line++) {
				pLine = m_p;
				for(pixel = x; pixel <= x1; pixel++) {
                    alpha = m_p[3];
                    if(alpha > 0) {
                    	if(0 == clr)
                    		hsvTransformPixel(m_p, value, v_s_u, v_s_w, alpha);
                    	else
                    		rgbTransformPixel(m_p, r, g, b, alpha);
                    }
					m_p += 4;
				}
				m_p = pLine + stride;
			}
			SetBitmapBits(hBitmap, dwLen, pOrig);
		}
		else if (item->hbm) {
			GetObject(item->hbm, sizeof(bmp), &bmp);
			if (bmp.bmBitsPixel != 32)
				return;

			dwLen = bmp.bmWidth * bmp.bmHeight * 4;
			if (dwLen > m_sAllocated) {
				m_p = (BYTE *)realloc(m_p, dwLen);
				m_sAllocated = dwLen;
			}
			memset(m_p, 0, dwLen);
			pOrig = m_p;
			GetBitmapBits(item->hbm, dwLen, m_p);

			for(pixel = 0; pixel < (bmp.bmWidth * bmp.bmHeight); pixel++) {
                alpha = m_p[3];
                if(alpha > 0) {
                	if(0 == clr)
                		hsvTransformPixel(m_p, value, v_s_u, v_s_w, alpha);
                	else
                		rgbTransformPixel(m_p, r, g, b, alpha);
                }
				m_p += 4;
			}
			SetBitmapBits(item->hbm, dwLen, pOrig);
		}
	}
}
/**************************************************
void CImg::SetPixel(int x, int y, COLORREF color)

功能:
	设定指定坐标位置像素的颜色值

限制:
	无

参数:
	int x, int y
		指定的像素横、纵坐标值
	COLORREF
		欲设定的指定位置的颜色值,RGB形式给出
返回值:
	无
***************************************************/
void CImg::SetPixel(int x, int y, COLORREF color)
{
	if(m_pBMIH->biBitCount == 8)			// 256色图
	{
		m_lpData[m_pBMIH->biHeight - y - 1][x] = GetRValue(color);
	}
	else if(m_pBMIH->biBitCount == 1)		// 单色图
	{
		BYTE Color = GetRValue(color);


		// 令0代表黑
		RGBQUAD *p = (RGBQUAD*)m_lpvColorTable;
		if(p[0].rgbBlue != 0)
			Color = !Color;

		y = m_pBMIH->biHeight - y - 1;
		
		// 黑色点
		if (Color == 0)  // 设置对应位为0
		{
			if(x % 8==0)
			{
				m_lpData[y][x/8] &= 0x7F;  
			}
			else if(x % 8==1)
			{
				m_lpData[y][x/8] &= 0xBF;
			}
			else if(x % 8==2)
			{
				m_lpData[y][x/8] &= 0xDF;
			}
			else if(x % 8==3)
			{
				m_lpData[y][x/8] &= 0xEF;
			}
			else if(x % 8==4)
			{
				m_lpData[y][x/8] &= 0xF7;
			}
			else if(x % 8==5)
			{
				m_lpData[y][x/8] &= 0xFB;
			}
			else if(x % 8==6)
			{
				m_lpData[y][x/8] &= 0xFD;
			}
			else if(x % 8==7)
			{
				m_lpData[y][x/8] &= 0xFE;
			}
		}
		else // 白色点
		{
			if(x % 8==0)
			{
				m_lpData[y][x/8] |= 0x80;
			}
			else if(x % 8==1)
			{
				m_lpData[y][x/8] |= 0x40;
			}
			else if(x % 8==2)
			{
				m_lpData[y][x/8] |= 0x20;
			}
			else if(x % 8==3)
			{
				m_lpData[y][x/8] |= 0x10;
			}
			else if(x % 8==4)
			{
				m_lpData[y][x/8] |= 0x08;
			}
			else if(x % 8==5)
			{
				m_lpData[y][x/8] |= 0x04;
			}
			else if(x % 8==6)
			{
				m_lpData[y][x/8] |= 0x02;
			}
			else if(x % 8==7)
			{
				m_lpData[y][x/8] |= 0x01;
			}
		}
	}
	else if(m_pBMIH->biBitCount == 24)
	{
		m_lpData[m_pBMIH->biHeight - y - 1][x*3] = GetBValue(color);
		m_lpData[m_pBMIH->biHeight - y - 1][x*3 + 1] = GetGValue(color);
		m_lpData[m_pBMIH->biHeight - y - 1][x*3 + 2] = GetRValue(color);
	}
}
Esempio n. 18
0
VOID CZUIRender::DrawRect(HDC hDC, RECT& rc, DWORD dwBorderSize, DWORD dwBorderColor, SIZE* pxyBorderRound /* = NULL */)
{
	HPEN hPen = ::CreatePen(PS_SOLID | PS_INSIDEFRAME, dwBorderSize, RGB(GetBValue(dwBorderColor), GetGValue(dwBorderColor), GetRValue(dwBorderColor)));
	if(hPen != NULL)
	{
		HPEN hOldPen = (HPEN)::SelectObject(hDC, hPen);
		::SelectObject(hDC, ::GetStockObject(NULL_BRUSH));	// »­Ë¢Ñ¡Óÿջ­Ë¢, ¼´²»ÊµÐÄ
		if(pxyBorderRound != NULL)
		{
			// Ô²½Ç¾ØÐÎ
			::RoundRect(hDC, rc.left, rc.top, rc.right, rc.bottom, pxyBorderRound->cx, pxyBorderRound->cy);
		}
		else
		{
			::Rectangle(hDC, rc.left, rc.top, rc.right, rc.bottom);
		}
		::SelectObject(hDC, hOldPen);
		::DeleteObject(hPen);
	}
}
Esempio n. 19
0
bool wxTabCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
            long style, const wxString& name)
{
  m_imageList = NULL;

  m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
      GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
  m_foregroundColour = *wxBLACK ;

  SetName(name);

  int x = pos.x;
  int y = pos.y;
  int width = size.x;
  int height = size.y;

  m_windowStyle = style;

  SetParent(parent);

  if (width <= 0)
    width = 100;
  if (height <= 0)
    height = 30;
  if (x < 0)
    x = 0;
  if (y < 0)
    y = 0;

  m_windowId = (id < 0 ? NewControlId() : id);

  long tabStyle = WS_CHILD | WS_VISIBLE;
  if (m_windowStyle & wxTC_MULTILINE)
    tabStyle |= TCS_MULTILINE;
  if (m_windowStyle & wxTC_RIGHTJUSTIFY)
    tabStyle |= TCS_RIGHTJUSTIFY;
  if (m_windowStyle & wxTC_FIXEDWIDTH)
    tabStyle |= TCS_FIXEDWIDTH;
  if (m_windowStyle & wxTC_OWNERDRAW)
    tabStyle |= TCS_OWNERDRAWFIXED;
  if (m_windowStyle & wxBORDER)
    tabStyle |= WS_BORDER;

#ifndef __WXWINCE__
  tabStyle |= TCS_TOOLTIPS;
#endif

  // Create the toolbar control.
  HWND hWndTabCtrl = CreateWindowEx(0L,     // No extended styles.
    WC_TABCONTROL,                          // Class name for the tab control
    wxEmptyString,                          // No default text.
    tabStyle,    // Styles and defaults.
    x, y, width, height,                    // Standard size and position.
    (HWND) parent->GetHWND(),               // Parent window
    (HMENU)m_windowId,                      // ID.
    wxGetInstance(),                        // Current instance.
    NULL );                                 // No class data.

  m_hWnd = (WXHWND) hWndTabCtrl;
  if (parent) parent->AddChild(this);

  SubclassWin((WXHWND) hWndTabCtrl);

  SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));

  return true;
}
Esempio n. 20
0
static inline QRgb colorref2qrgb(COLORREF col)
{
    return qRgb(GetRValue(col),GetGValue(col),GetBValue(col));
}
Esempio n. 21
0
void CGradientProgressCtrl::DrawGradient(CPaintDC *pDC, const RECT &rectClient, const int &nMaxWidth, const BOOL &bVertical)
{
	RECT rectFill;			   // Rectangle for filling band
	float fStep;              // How wide is each band?
	CBrush brush;			// Brush to fill in the bar	

	
	CMemDC memDC(pDC);

	// First find out the largest color distance between the start and end colors.  This distance
	// will determine how many steps we use to carve up the client region and the size of each
	// gradient rect.
	int r, g, b;					// First distance, then starting value
	float rStep, gStep, bStep;		// Step size for each color
		
	BOOL  bSameColor = FALSE;		// Handle case if start color == end color

	// Get the color differences
	r = (GetRValue(m_clrEnd) - GetRValue(m_clrStart));
	g = (GetGValue(m_clrEnd) - GetGValue(m_clrStart));
	b =  (GetBValue(m_clrEnd) - GetBValue(m_clrStart));

	// Check to see if colors are same
	if((r == 0) && (g == 0) && (b == 0))
	{
		bSameColor = TRUE;
		//Added the three lines below to fix the drawing 
		//problem which used to occur when both the start 
		//and end colors are same.
		r = GetRValue(m_clrStart);
		g = GetGValue(m_clrStart);
		b = GetBValue(m_clrStart);
	}

	int nSteps;
	//Select max. possible value for nSteps if the colors are equal
	if(bSameColor && m_clrStart == 0)
		nSteps = 255;
	else 	// Make the number of steps equal to the greatest distance
		nSteps = max(abs(r), max(abs(g), abs(b)));	
	
	// Determine how large each band should be in order to cover the
	// client with nSteps bands (one for every color intensity level)
	if (bVertical)
		fStep = (float)rectClient.bottom / (float)nSteps;	
	else
		fStep = (float)rectClient.right / (float)nSteps;

	// Calculate the step size for each color
	rStep = r/(float)nSteps;
	gStep = g/(float)nSteps;
	bStep = b/(float)nSteps;

	// Reset the colors to the starting position
	r = GetRValue(m_clrStart);
	g = GetGValue(m_clrStart);
	b = GetBValue(m_clrStart);
	
	// Start filling bands
	for (int iOnBand = 0; iOnBand < nSteps; iOnBand++) 
	{
		// Fill the vertical control
		if (bVertical)
		{
			::SetRect(&rectFill,
						0,							// Upper left X
						(int)(iOnBand * fStep),		// Upper left Y
						rectClient.right+1,		// Lower right X
						(int)((iOnBand+1) * fStep));// Lower right Y
		
			// CDC::FillSolidRect is faster, but it does not handle 8-bit color depth
			VERIFY(brush.CreateSolidBrush(RGB(r+rStep*iOnBand, g + gStep*iOnBand, b + bStep *iOnBand)));
			memDC.FillRect(&rectFill,&brush);
			VERIFY(brush.DeleteObject());


			// If we are past the maximum for the current position we need to get out of the loop.
			// Before we leave, we repaint the remainder of the client area with the background color.
			if (rectFill.bottom > nMaxWidth)
			{
				::SetRect(&rectFill, 0, rectFill.bottom, rectClient.right, rectClient.bottom);
				VERIFY(brush.CreateSolidBrush(m_clrBkGround));
				memDC.FillRect(&rectFill, &brush);
				VERIFY(brush.DeleteObject());
				return;
			}
		}

		else // Fill the horizontal control
		{
			::SetRect(&rectFill,
						(int)(iOnBand * fStep),     // Upper left X
						 0,							// Upper left Y
						(int)((iOnBand+1) * fStep), // Lower right X
						rectClient.bottom+1);		// Lower right Y
		
			// CDC::FillSolidRect is faster, but it does not handle 8-bit color depth
			VERIFY(brush.CreateSolidBrush(RGB(r+rStep*iOnBand, g + gStep*iOnBand, b + bStep *iOnBand)));
			memDC.FillRect(&rectFill,&brush);
			VERIFY(brush.DeleteObject());


			// If we are past the maximum for the current position we need to get out of the loop.
			// Before we leave, we repaint the remainder of the client area with the background color.
			if (rectFill.right > nMaxWidth)
			{
				::SetRect(&rectFill, rectFill.right, 0, rectClient.right, rectClient.bottom);
				VERIFY(brush.CreateSolidBrush(m_clrBkGround));
				memDC.FillRect(&rectFill, &brush);
				VERIFY(brush.DeleteObject());
				return;
			}
		}

	}
}
Esempio n. 22
0
/******************************************************************************
 *		OleTranslateColor	[OLEAUT32.421]
 *
 * Convert an OLE_COLOR to a COLORREF.
 *
 * PARAMS
 *  clr       [I] Color to convert
 *  hpal      [I] Handle to a palette for the conversion
 *  pColorRef [O] Destination for converted color, or NULL to test if the conversion is ok
 *
 * RETURNS
 *  Success: S_OK. The conversion is ok, and pColorRef contains the converted color if non-NULL.
 *  Failure: E_INVALIDARG, if any argument is invalid.
 *
 * FIXME
 *  Document the conversion rules.
 */
HRESULT WINAPI OleTranslateColor(
  OLE_COLOR clr,
  HPALETTE  hpal,
  COLORREF* pColorRef)
{
  COLORREF colorref;
  BYTE b = HIBYTE(HIWORD(clr));

  TRACE("(%08x, %p, %p)\n", clr, hpal, pColorRef);

  /*
   * In case pColorRef is NULL, provide our own to simplify the code.
   */
  if (pColorRef == NULL)
    pColorRef = &colorref;

  switch (b)
  {
    case 0x00:
    {
      if (hpal != 0)
        *pColorRef =  PALETTERGB(GetRValue(clr),
                                 GetGValue(clr),
                                 GetBValue(clr));
      else
        *pColorRef = clr;

      break;
    }

    case 0x01:
    {
      if (hpal != 0)
      {
        PALETTEENTRY pe;
        /*
         * Validate the palette index.
         */
        if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
          return E_INVALIDARG;
      }

      *pColorRef = clr;

      break;
    }

    case 0x02:
      *pColorRef = clr;
      break;

    case 0x80:
    {
      int index = LOBYTE(LOWORD(clr));

      /*
       * Validate GetSysColor index.
       */
      if ((index < COLOR_SCROLLBAR) || (index > COLOR_MENUBAR))
        return E_INVALIDARG;

      *pColorRef =  GetSysColor(index);

      break;
    }

    default:
      return E_INVALIDARG;
  }

  return S_OK;
}
Esempio n. 23
0
long CMUSHclientDoc::BlendPixel(long Blend, long Base, short Mode, double Opacity) 
{
long rA = GetRValue (Blend),
     gA = GetGValue (Blend),
     bA = GetBValue (Blend);
long rB = GetRValue (Base),
     gB = GetGValue (Base),
     bB = GetBValue (Base);

long r, g, b;

  if (Opacity < 0.0 || Opacity > 1.0)
    return -2;

  // precompute cos table
  static unsigned char cos_table [256];
  static bool bTableComputed = false;

  if (!bTableComputed)
    {
    double pi_div255 = 3.1415926535898 / 255.0;
    long i;
    for (i = 0; i < 256; i++)
      {
      double a = 64.0 - cos ((double) i * pi_div255) * 64.0;
      cos_table [i] = (uint8) (a + 0.5);  // round
      }
    bTableComputed = true;
    } // table needs computing

  switch (Mode)
    {

    // normal modes
    case  1: Blend_It (Blend_Normal);     break;
    case  2: Blend_It (Blend_Average);    break;
    case  3: Blend_It (Blend_Interpolate);  break;

    case  4:  // dissolve - randomly choose pixels based on opacity
      {
       double rnd = genrand ();

        r = (rnd < Opacity) ? rA : rB;
        g = (rnd < Opacity) ? gA : gB;
        b = (rnd < Opacity) ? bA : bB;
      }
      break;


    // darkening modes
    case  5: Blend_It (Blend_Darken);     break;
    case  6: Blend_It (Blend_Multiply);   break;
    case  7: Blend_It (Blend_ColorBurn);  break;
    case  8: Blend_It (Blend_LinearBurn); break;
    case  9: Blend_It (Blend_InverseColorBurn);  break;
    case 10: Blend_It (Blend_Subtract);   break;
    
    // lightening modes
    case 11: Blend_It (Blend_Lighten);    break;
    case 12: Blend_It (Blend_Screen);     break;
    case 13: Blend_It (Blend_ColorDodge); break;
    case 14: Blend_It (Blend_LinearDodge);break;
    case 15: Blend_It (Blend_InverseColorDodge);  break;
    case 16: Blend_It (Blend_Add);        break;
      
    // soft/hard light etc.
    case 17: Blend_It (Blend_Overlay);    break;
    case 18: Blend_It (Blend_SoftLight);  break;
    case 19: Blend_It (Blend_HardLight);  break;
    case 20: Blend_It (Blend_VividLight); break;
    case 21: Blend_It (Blend_LinearLight);break;
    case 22: Blend_It (Blend_PinLight);   break;
    case 23: Blend_It (Blend_HardMix);    break;

    // difference modes
    case 24: Blend_It (Blend_Difference); break;
    case 25: Blend_It (Blend_Exclusion);  break;

    // glow modes
    case 26: Blend_It (Blend_Reflect);    break;
    case 27: Blend_It (Blend_Glow);       break;
    case 28: Blend_It (Blend_Freeze);     break;
    case 29: Blend_It (Blend_Heat);       break;
        
    case 30: Blend_It (Blend_Negation);   break;
    case 31: Blend_It (Blend_Phoenix);    break;
    case 32: Blend_It (Blend_Stamp);      break;

    // logical modes
    case 33: Blend_It (Blend_Xor);      break;
    case 34: Blend_It (Blend_And);      break;
    case 35: Blend_It (Blend_Or);       break;

    // the follow modes take one colour from the blend and retain 2 from the base
    case 36: Colour_Op (rA, gB, bB); break;  // red  
    case 37: Colour_Op (rB, gA, bB); break;  // green
    case 38: Colour_Op (rB, gB, bA); break;  // blue 

    // the follow modes take two colours from the blend and retain 1 from the base
    case 39: Colour_Op (rA, gA, bB); break;  // yellow 
    case 40: Colour_Op (rB, gA, bA); break;  // cyan    
    case 41: Colour_Op (rA, gB, bA); break;  // magenta    

    // limit green
    case 42: Colour_Op (rA, (gA > rA) ? rA : gA, bA); break;  // green limited by red    
    case 43: Colour_Op (rA, (gA > bA) ? bA : gA, bA); break;  // green limited by blue    
    case 44: Colour_Op (rA, (gA > ((rA + bA) / 2)) ? ((rA + bA) / 2) : gA, bA); break;  // green limited by average of red and blue    

    // limit blue
    case 45: Colour_Op (rA, gA, (bA > rA) ? rA : bA); break;  // blue limited by red    
    case 46: Colour_Op (rA, gA, (bA > gA) ? gA : bA); break;  // blue limited by green    
    case 47: Colour_Op (rA, gA, (bA > ((rA + gA) / 2)) ? ((rA + gA) / 2) : bA); break; // blue limited by average of red and green    

    // limit red
    case 48: Colour_Op ((rA > gA) ? gA : rA, gA, bA); break;  // red limited by green    
    case 49: Colour_Op ((rA > bA) ? bA : rA, gA, bA); break;  // red limited by blue    
    case 50: Colour_Op ((rA > ((gA + bA) / 2)) ? ((gA + bA) / 2) : rA, gA, bA); break;  // red limited by average of green and blue    

    // select single colour
    case 51: Colour_Op (rA, 0, 0); break;  // red only       (looks red)
    case 52: Colour_Op (0, gA, 0); break;  // green only     (looks green)
    case 53: Colour_Op (0, 0, bA); break;  // blue only      (looks blue)

    // discard single colour
    case 54: Colour_Op (0, gA, bA); break;  // discard red    (looks cyan)
    case 55: Colour_Op (rA, 0, bA); break;  // discard green  (looks magenta)
    case 56: Colour_Op (rA, gA, 0); break;  // discard blue   (looks yellow)

    // one colour to all channels  (ie. it looks grey)
    case 57: Colour_Op (rA, rA, rA); break;  // all red   
    case 58: Colour_Op (gA, gA, gA); break;  // all green   
    case 59: Colour_Op (bA, bA, bA); break;  // all blue   

    case 60:           // Hue mode
      {
          CColor cA, cB;    // A = blend, B = base

          cA.SetRGB (rA, gA, bA);
          cB.SetRGB (rB, gB, bB);

          cB.SetHue (cA.GetHue ());  // hue of blend image, others from base image
          r = Simple_Opacity (rB, cB.GetRed (), Opacity); 
          g = Simple_Opacity (gB, cB.GetGreen (), Opacity); 
          b = Simple_Opacity (bB, cB.GetBlue (), Opacity); 
       }
      break;

    case 61:           // Saturation mode
        {
          CColor cA, cB;    // A = blend, B = base

          cA.SetRGB (rA, gA, bA);
          cB.SetRGB (rB, gB, bB);

          cB.SetSaturation (cA.GetSaturation ());  // saturation of blend image, others from base image
          r = Simple_Opacity (rB, cB.GetRed (), Opacity); 
          g = Simple_Opacity (gB, cB.GetGreen (), Opacity); 
          b = Simple_Opacity (bB, cB.GetBlue (), Opacity); 
       }
      break;

    case 62:           // Colour mode
      {
          CColor cA, cB;    // A = blend, B = base

          cA.SetRGB (rA, gA, bA);
          cB.SetRGB (rB, gB, bB);

          cB.SetHue (cA.GetHue ());  // hue of blend image, 
          cB.SetSaturation (cA.GetSaturation ());  // saturation of blend image, luminance from base image
          r = Simple_Opacity (rB, cB.GetRed (), Opacity); 
          g = Simple_Opacity (gB, cB.GetGreen (), Opacity); 
          b = Simple_Opacity (bB, cB.GetBlue (), Opacity); 
       }
      break;


    case 63:           // Luminance mode
      {
          CColor cA, cB;    // A = blend, B = base

          cA.SetRGB (rA, gA, bA);
          cB.SetRGB (rB, gB, bB);

          cB.SetLuminance (cA.GetLuminance ());  // luminance from blend image, others from base image

          r = Simple_Opacity (rB, cB.GetRed (), Opacity); 
          g = Simple_Opacity (gB, cB.GetGreen (), Opacity); 
          b = Simple_Opacity (bB, cB.GetBlue (), Opacity); 

       }
      break;

    case 64:           // HSL (hue to red, saturation to green, luminance to blue)
        {
          CColor cA, cB;    // A = blend, B = base
          cA.SetRGB (rA, gA, bA);

          r = Simple_Opacity (rB, cB.GetRed (), Opacity); 
          g = Simple_Opacity (gB, cB.GetGreen (), Opacity); 
          b = Simple_Opacity (bB, cB.GetBlue (), Opacity); 

         }
      break;

     default: return -1;

     } // end of switch


	return RGB (CLAMP (r), CLAMP (g), CLAMP (b));
} // end of CMUSHclientDoc::BlendPixel
Esempio n. 24
0
void CColourPopup::DrawCell(CDC* pDC, int nIndex)
{
    // For the Custom Text area
    if (m_strCustomText.GetLength() && nIndex == CUSTOM_BOX_VALUE)
    {
        // The extent of the actual text button
        CRect TextButtonRect = m_CustomTextRect;
        TextButtonRect.top += 2*m_nMargin;

        // Fill background
        pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));

        // Draw horizontal line
        pDC->FillSolidRect(m_CustomTextRect.left+2*m_nMargin, m_CustomTextRect.top,
                           m_CustomTextRect.Width()-4*m_nMargin, 1, ::GetSysColor(COLOR_3DSHADOW));
        pDC->FillSolidRect(m_CustomTextRect.left+2*m_nMargin, m_CustomTextRect.top+1,
                           m_CustomTextRect.Width()-4*m_nMargin, 1, ::GetSysColor(COLOR_3DHILIGHT));

        TextButtonRect.DeflateRect(1,1);

        // fill background
        if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
            pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DLIGHT));
        else
            pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));

        // Draw button
        if (m_nCurrentSel == nIndex) 
            pDC->DrawEdge(TextButtonRect, BDR_RAISEDINNER, BF_RECT);
        else if (m_nChosenColourSel == nIndex)
            pDC->DrawEdge(TextButtonRect, BDR_SUNKENOUTER, BF_RECT);

        // Draw custom text
        CFont *pOldFont = (CFont*) pDC->SelectObject(&m_Font);
        pDC->SetBkMode(TRANSPARENT);
        pDC->DrawText(m_strCustomText, TextButtonRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        pDC->SelectObject(pOldFont);

        return;
    }        

    // For the Default Text area
    if (m_strDefaultText.GetLength() && nIndex == DEFAULT_BOX_VALUE)
    {
        // Fill background
        pDC->FillSolidRect(m_DefaultTextRect, ::GetSysColor(COLOR_3DFACE));

        // The extent of the actual text button
        CRect TextButtonRect = m_DefaultTextRect;
        TextButtonRect.DeflateRect(1,1);

        // fill background
        if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
            pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DLIGHT));
        else
            pDC->FillSolidRect(TextButtonRect, ::GetSysColor(COLOR_3DFACE));

        // Draw thin line around text
        CRect LineRect = TextButtonRect;
        LineRect.DeflateRect(2*m_nMargin,2*m_nMargin);
        CPen pen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW));
        CPen* pOldPen = pDC->SelectObject(&pen);
        pDC->SelectStockObject(NULL_BRUSH);
        pDC->Rectangle(LineRect);
        pDC->SelectObject(pOldPen);

        // Draw button
        if (m_nCurrentSel == nIndex) 
            pDC->DrawEdge(TextButtonRect, BDR_RAISEDINNER, BF_RECT);
        else if (m_nChosenColourSel == nIndex)
            pDC->DrawEdge(TextButtonRect, BDR_SUNKENOUTER, BF_RECT);

        // Draw custom text
        CFont *pOldFont = (CFont*) pDC->SelectObject(&m_Font);
        pDC->SetBkMode(TRANSPARENT);
        pDC->DrawText(m_strDefaultText, TextButtonRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        pDC->SelectObject(pOldFont);

        return;
    }        

    CRect rect;
    if (!GetCellRect(nIndex, rect)) return;

    // Select and realize the palette
    CPalette* pOldPalette = NULL;
    if (pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
    {
        pOldPalette = pDC->SelectPalette(&m_Palette, FALSE);
        pDC->RealizePalette();
    }

    // fill background
    if (m_nChosenColourSel == nIndex && m_nCurrentSel != nIndex)
        pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DHILIGHT));
    else
        pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DFACE));

    // Draw button
    if (m_nCurrentSel == nIndex) 
        pDC->DrawEdge(rect, BDR_RAISEDINNER, BF_RECT);
    else if (m_nChosenColourSel == nIndex)
        pDC->DrawEdge(rect, BDR_SUNKENOUTER, BF_RECT);

    CBrush brush(PALETTERGB(GetRValue(GetColour(nIndex)), 
                            GetGValue(GetColour(nIndex)), 
                            GetBValue(GetColour(nIndex)) ));
    CPen   pen;
    pen.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW));

    CBrush* pOldBrush = (CBrush*) pDC->SelectObject(&brush);
    CPen*   pOldPen   = (CPen*)   pDC->SelectObject(&pen);

    // Draw the cell colour
    rect.DeflateRect(m_nMargin+1, m_nMargin+1);
    pDC->Rectangle(rect);

    // restore DC and cleanup
    pDC->SelectObject(pOldBrush);
    pDC->SelectObject(pOldPen);
    brush.DeleteObject();
    pen.DeleteObject();

    if (pOldPalette && pDC->GetDeviceCaps(RASTERCAPS) & RC_PALETTE)
        pDC->SelectPalette(pOldPalette, FALSE);
}
Esempio n. 25
0
void MeterM1::DrawMeterBackground(CDC *pDC, CRect &rect)
{
	int nInnerRadius = m_nRadiusFrame*8/10;	// 内圆弧半径

	m_nCenterRadius = m_nRadiusFrame/20;	// 中心园半径大小

	int nFrame = m_nRadiusFrame/18;			// 边框厚度

	double dstepTickDeg = (360.0+m_nStartAngleDeg-m_nEndAngleDeg)/(m_nTicks*m_nSubTicks);	// 刻度步进角度

	int nSubTickR = nInnerRadius+(m_nRadiusFrame-2*nFrame-nInnerRadius)/2;

	double dDeg = (m_nStartAngleDeg+360.0-m_nEndAngleDeg)/(TABNUM*PT_NUM);
	 

	CRect rectPanel,rectInnerPanel;
	CPen penDraw, *pPenOld;
	CFont *pFontOld;
	CBrush brushFill, *pBrushOld;
	POINT ptStart, ptEnd, ptInnerStart, ptInnerEnd;	
	CPoint pointInner[BOUNDARY_POINTS], ptGroup1[PT_NUM*TABNUM+1], ptGroup2[PT_NUM*TABNUM+1];
	CPoint ptRgn[PT_NUM*2+2];
	CPoint pttemp;
	CString strtemp;
	double dRadPerDeg;
	double dTickAngleRad;
	double dTemp;
	int nRef = 0;
	int nTickAngle;	
	int nHeight;	// 字体大小
	double dtempangle;
	
	// 计算起始角终止角弧度
	dRadPerDeg = 4.0*atan(1.0)/180.0;
	m_dLeftAngleRad = (m_nStartAngleDeg-180.0)*dRadPerDeg;
	m_dRightAngleRad = (m_nEndAngleDeg-360.0)*dRadPerDeg;
	
	// 计算圆弧起始终止点及区域
	ptStart.x = m_ptMeterCenter.x-(int)(m_nRadiusFrame*cos(m_dLeftAngleRad));
	ptStart.y = m_ptMeterCenter.y+(int)(m_nRadiusFrame*sin(m_dLeftAngleRad));
	ptEnd.x = m_ptMeterCenter.x+(int)(m_nRadiusFrame*cos(-m_dRightAngleRad));
	ptEnd.y = m_ptMeterCenter.y+(int)(m_nRadiusFrame*sin(-m_dRightAngleRad));
	
	rectPanel.SetRect(m_ptMeterCenter.x-m_nRadiusFrame, m_ptMeterCenter.y-m_nRadiusFrame,
						m_ptMeterCenter.x+m_nRadiusFrame, m_ptMeterCenter.y+m_nRadiusFrame);
	// 获取点的位置
	for(int i=0; i<=PT_NUM*TABNUM; i++)
	{
		ptGroup1[i].x = m_ptMeterCenter.x + (int)((m_nRadiusFrame-nFrame)*cos((m_nStartAngleDeg-i*dDeg)*dRadPerDeg));
		ptGroup1[i].y = m_ptMeterCenter.y - (int)((m_nRadiusFrame-nFrame)*sin((m_nStartAngleDeg-i*dDeg)*dRadPerDeg));
		ptGroup2[i].x = m_ptMeterCenter.x + (int)(m_nRadiusFrame*8*cos((m_nStartAngleDeg-i*dDeg)*dRadPerDeg)/10);
		ptGroup2[i].y = m_ptMeterCenter.y - (int)(m_nRadiusFrame*8*sin((m_nStartAngleDeg-i*dDeg)*dRadPerDeg)/10);
	}

	// 获取系统颜色;
	m_colorWindow    = GetSysColor(COLOR_WINDOW);
	m_colorButton    = GetSysColor(COLOR_BTNFACE);
	m_colorShadow    = GetSysColor(COLOR_BTNSHADOW);
	m_colorHighlight = GetSysColor(COLOR_BTNHIGHLIGHT);
	m_colorText		= GetSysColor(COLOR_BTNTEXT);
	// 临时使用的颜色
	COLORREF colorCaption, cEdge, cMiddle;
	cMiddle = RGB(255, 255, 255);
	cEdge = RGB(96, 96, 255);

	// 用按钮色绘制背景
	brushFill.DeleteObject();
	brushFill.CreateSolidBrush(m_colorButton);
	pBrushOld = pDC->SelectObject(&brushFill);
	pDC->Rectangle(rect);
	pDC->SelectObject(pBrushOld);

	// 绘制圆盘边框

	for(int iOnBand=nFrame; iOnBand>0; iOnBand--)
	{
		penDraw.DeleteObject();
		colorCaption = RGB((GetRValue(cEdge)-GetRValue(cMiddle))*((float)iOnBand)/nFrame+GetRValue(cMiddle),
			(GetGValue(cEdge)-GetGValue(cMiddle))*((float)iOnBand)/nFrame+GetGValue(cMiddle),
			(GetBValue(cEdge)-GetBValue(cMiddle))*((float)iOnBand)/nFrame+GetBValue(cMiddle));
		penDraw.CreatePen(PS_SOLID, iOnBand*2, colorCaption);
		pPenOld = pDC->SelectObject(&penDraw);
		pDC->Arc(&rectPanel, ptEnd, ptStart);
		pDC->SelectObject(pPenOld);	
	}
	// 绘制内圈
	ptInnerStart.x = m_ptMeterCenter.x-(int)(nInnerRadius*cos(m_dLeftAngleRad));
	ptInnerStart.y = m_ptMeterCenter.y+(int)(nInnerRadius*sin(m_dLeftAngleRad));
	ptInnerEnd.x = m_ptMeterCenter.x+(int)(nInnerRadius*cos(-m_dRightAngleRad));
	ptInnerEnd.y = m_ptMeterCenter.y+(int)(nInnerRadius*sin(-m_dRightAngleRad));
	
	rectInnerPanel.SetRect(m_ptMeterCenter.x-nInnerRadius, m_ptMeterCenter.y-nInnerRadius,
						m_ptMeterCenter.x+nInnerRadius ,m_ptMeterCenter.y+nInnerRadius);

	penDraw.DeleteObject();
	penDraw.CreatePen(PS_SOLID, 1, RGB(255,255,0));
	pPenOld = pDC->SelectObject(&penDraw);
	pDC->Arc(&rectInnerPanel, ptInnerEnd, ptInnerStart);
	pDC->SelectObject(pPenOld);	
	
	if(m_bColorTick)
	{
		
		// 绘制色彩刻度
		for(int i=0; i<TABNUM; i++)
		{
			//确定区域
			for(int j=0; j<=PT_NUM; j++)
			{
				ptRgn[j] = ptGroup1[i*PT_NUM+j];
				ptRgn[2*PT_NUM+1-j] = ptGroup2[i*PT_NUM+j];
			}
			brushFill.DeleteObject();
			brushFill.CreateSolidBrush(m_colorTable[i]);
			pBrushOld = pDC->SelectObject(&brushFill);
			penDraw.DeleteObject();
			penDraw.CreatePen(PS_SOLID, 1, m_colorTable[i]);
			pPenOld = pDC->SelectObject(&penDraw);
			pDC->Polygon(ptRgn, 2*PT_NUM+2);
			pDC->SelectObject(pBrushOld);
			pDC->SelectObject(pPenOld);
		}
		
	}

	// 计算刻度点,避免不能整除引起较大误差*100
	for(nTickAngle=m_nStartAngleDeg*100; nTickAngle>=(m_nEndAngleDeg-360)*100; nTickAngle-=(int)(dstepTickDeg*100))
	{
		// 转换成弧度
		dTickAngleRad = (double)nTickAngle/100*dRadPerDeg;	
		// 确定外圈坐标
		// 确定x坐标
		dTemp = m_ptMeterCenter.x + (m_nRadiusFrame-2*nFrame)*cos(dTickAngleRad);
		m_pointBoundary[nRef].x = ROUND(dTemp);
		// 确定y坐标
		dTemp = m_ptMeterCenter.y - (m_nRadiusFrame-2*nFrame)*sin(dTickAngleRad);
		m_pointBoundary[nRef].y = ROUND(dTemp);
		
		// 确定刻度点(主刻度和子刻度)
		//主刻度及文本标注点
		if(nRef%m_nSubTicks == 0)
		{
			dTemp = m_ptMeterCenter.x + nInnerRadius*cos(dTickAngleRad);
			pointInner[nRef].x = ROUND(dTemp);
			dTemp = m_ptMeterCenter.y - nInnerRadius*sin(dTickAngleRad);
			pointInner[nRef].y = ROUND(dTemp);
		}
		// 子刻度
		else
		{
			dTemp = m_ptMeterCenter.x + nSubTickR*cos(dTickAngleRad);
			pointInner[nRef].x = ROUND(dTemp);
			dTemp = m_ptMeterCenter.y - nSubTickR*sin(dTickAngleRad);
			pointInner[nRef].y = ROUND(dTemp);
		}
		nRef++ ;
	}
	// 多边形区域
	m_rgnBoundary.DeleteObject() ;
	m_rgnBoundary.CreatePolygonRgn(m_pointBoundary, nRef, ALTERNATE);
	
	m_rectValue.top = m_ptMeterCenter.y + m_nRadiusFrame/5;
	m_rectValue.bottom = m_ptMeterCenter.y + m_nRadiusFrame/2;
	m_rectValue.left = m_ptMeterCenter.x - m_nRadiusFrame/2;
	m_rectValue.right = m_ptMeterCenter.x + m_nRadiusFrame/2;

	// 绘制刻度
	penDraw.DeleteObject();
	penDraw.CreatePen(PS_SOLID, 1, RGB(0,0,0));
	pPenOld = pDC->SelectObject(&penDraw);
	for(int i=0; i<nRef; i++)
	{
		pDC->MoveTo(m_pointBoundary[i]);
		pDC->LineTo(pointInner[i]);
	}
	pDC->SelectObject(pPenOld);	

	// 刻度标号
	// 确定字体大小
	nHeight = m_nRadiusFrame/6;
	m_font.CreateFont(nHeight, 0, 0, 0, 400, 
							FALSE, FALSE, 0, ANSI_CHARSET,
							OUT_DEFAULT_PRECIS, 
							CLIP_DEFAULT_PRECIS,
							DEFAULT_QUALITY, 
							DEFAULT_PITCH|FF_SWISS, _T("Arial"));/////////////////////////////yingmou

	pFontOld = pDC->SelectObject(&m_font);
	pDC->SetBkMode(TRANSPARENT);
	for(int i=0; i<=m_nTicks; i++)
	{	
		dtempangle = m_nStartAngleDeg-i*m_nSubTicks*dstepTickDeg;
		strtemp.Format(_T("%.*lf"), m_nScaleDecimals, (m_dMinValue+(m_dMaxValue-m_dMinValue)*i/m_nTicks));;////////////////////////////////////////////////yingmou

		if(dtempangle>190)
		{
			pDC->SetTextAlign(TA_BOTTOM|TA_LEFT);
			pDC->TextOut(pointInner[m_nSubTicks*i].x, pointInner[m_nSubTicks*i].y+nHeight/2, strtemp);
		}
		
		else if(dtempangle>170)
		{
			pDC->SetTextAlign(TA_BASELINE|TA_LEFT);
			pDC->TextOut(pointInner[m_nSubTicks*i].x, pointInner[m_nSubTicks*i].y+nHeight/3, strtemp);
		}
		else if(dtempangle>135)
		{
			pDC->SetTextAlign(TA_BASELINE|TA_LEFT);
			pDC->TextOut(pointInner[m_nSubTicks*i].x, pointInner[m_nSubTicks*i].y+nHeight/2, strtemp);
		}
		else if(dtempangle>100)
		{
			pDC->SetTextAlign(TA_TOP|TA_LEFT);
			pDC->TextOut(pointInner[m_nSubTicks*i].x-nHeight/4, pointInner[m_nSubTicks*i].y-nHeight/8, strtemp);
		}

		else if(dtempangle>80)
		{
			pDC->SetTextAlign(TA_TOP|TA_CENTER);
			pDC->TextOut(pointInner[m_nSubTicks*i].x, pointInner[m_nSubTicks*i].y, strtemp);
		}
		else if(dtempangle>45)
		{
			pDC->SetTextAlign(TA_BOTTOM|TA_RIGHT);
			pDC->TextOut(pointInner[m_nSubTicks*i].x+nHeight/3, pointInner[m_nSubTicks*i].y+nHeight, strtemp);
		}
		else if(dtempangle>10)
		{
			pDC->SetTextAlign(TA_RIGHT|TA_BASELINE);
			pDC->TextOut(pointInner[m_nSubTicks*i].x, pointInner[m_nSubTicks*i].y+nHeight/2, strtemp);
		}
		else if(dtempangle>-10)
		{
			pDC->SetTextAlign(TA_RIGHT|TA_BASELINE);
			pDC->TextOut(pointInner[m_nSubTicks*i].x, pointInner[m_nSubTicks*i].y+nHeight/3, strtemp);
		}
		else 
		{
			pDC->SetTextAlign(TA_RIGHT|TA_BOTTOM);
			pDC->TextOut(pointInner[m_nSubTicks*i].x, pointInner[m_nSubTicks*i].y+nHeight/2, strtemp);
		}
	}
	pDC->SelectObject(pFontOld);

}
Esempio n. 26
0
void GraphicsInterface::DisplayStatus(wstring wstrText, int display_time)
{
	GraphicsEngineOptions geo;
	RECT rcScreen;
	CMonitors cm;
	POINT pt = { 0, 0 };
	Color cNull = Color(0, 0, 0, 0);
	Color cTemp;
	Color cOutline;
	Color cDropShadow;
	REAL rTemp;

	if (!m_ssSettings.bVisualFeedback)
		return;

	if (m_ssSettings.bNoDisplayWhenActive && m_ITCom->IsActiveWindow())
		return;

	EnterCriticalSection(&_csCreateDisplay);
	_nDisplayType = 1;

	// Configure
	geo.nDisplayAlpha = m_ssSettings.nOSDAlpha;
	geo.bDisplayTopMost = m_ssSettings.bOSDTopMost;
	geo.nMaxWidth = m_ssSettings.nOSDMaxWidth;
	geo.nArtScaleMode = m_ssSettings.nArtMode == 3 ? ART_SCALEMODEHEIGHT : ART_SCALEMODESIZE;
	geo.saAlign = (Gdiplus::StringAlignment)m_ssSettings.nOSDTextJustify;
	geo.bForceToWidth = m_ssSettings.bOSDForceWidth;
	for (const auto& ge : _ges)
	{
		ge->SetOptions(geo);
		// Begin render process
		ge->BeginRender(5);
	}

		// Set background and borders
		rTemp = (REAL)m_ssSettings.nOSDBorderSize;
	cOutline = Color(GetRValue(m_ssSettings.lOSDBorderColor), GetGValue(m_ssSettings.lOSDBorderColor), GetBValue(m_ssSettings.lOSDBorderColor));
	cTemp = Color(GetRValue(m_ssSettings.lOSDBkColorRef), GetGValue(m_ssSettings.lOSDBkColorRef), GetBValue(m_ssSettings.lOSDBkColorRef));
	cDropShadow = Color(GetRValue(m_ssSettings.lDropShadowColor), GetGValue(m_ssSettings.lDropShadowColor), GetBValue(m_ssSettings.lDropShadowColor));
	for (const auto& ge : _ges)
	{
		ge->SetDisplayBorder(m_ssSettings.bOSDOutlineMode ? cNull : cOutline, rTemp);
		ge->SetDisplayBackground(m_ssSettings.bOSDOutlineMode ? cNull : cTemp);
	}

		// Cache text height for shapes
		REAL text_height = _ges.at(0)->GetTextHeight(m_ssSettings.wcFontFace, (float)m_ssSettings.nOSDFontPoint, m_ssSettings.nOSDFontStyle);

	// Break string into lines, add to display
	wchar_t *lpToken = NULL;
	wchar_t *lpContext = NULL;
	wchar_t *lpRating = NULL;
	wchar_t *lpVolume = NULL;
	wchar_t *lpBeforeRating = NULL;
	cTemp = Color(GetRValue(m_ssSettings.lOSDColorRef), GetGValue(m_ssSettings.lOSDColorRef), GetBValue(m_ssSettings.lOSDColorRef));
	Color cShapeFill = Color(GetRValue(m_ssSettings.lRatingShapeFill), GetGValue(m_ssSettings.lRatingShapeFill), GetBValue(m_ssSettings.lRatingShapeFill));
	Color cShapeOutline = Color(GetRValue(m_ssSettings.lRatingShapeOutline), GetGValue(m_ssSettings.lRatingShapeOutline), GetBValue(m_ssSettings.lRatingShapeOutline));
	lpToken = wcstok_s(const_cast<wchar_t*>(wstrText.c_str()), L"\n", &lpContext);
	while (NULL != lpToken && m_ssSettings.nDisplayLayout != 4)
	{
		for (const auto& ge : _ges)
		{
			ge->BeginLine();
		}
			// check for %rating% in string, replace with img rating
			lpRating = wcsstr(lpToken, L"%rating%");
		lpVolume = wcsstr(lpToken, L"%volume%");
		if (NULL != lpVolume)
		{
			// Break up line
			lpBeforeRating = new wchar_t[lpVolume - lpToken + 1];
			wcsncpy_s(lpBeforeRating, lpVolume - lpToken + 1, lpToken, lpVolume - lpToken);

			// Add text before rating
			for (const auto& ge : _ges)
			{
				ge->AddString(lpBeforeRating, false, m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint,
					cTemp, m_ssSettings.wcFontFace, m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f,
					m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f, cDropShadow);
			}

				// Add rating
				unsigned int lVolume = m_ITCom->GetVolumeLevel();

			RectF rfShape = RectF(0, 0, text_height*10.0f, text_height*1.5f);
			for (const auto& ge : _ges)
			{
				ge->AddShape(ShapeVolume, FillCustom, rfShape, false, cShapeOutline, 3.0, cShapeFill, lVolume);
				// Add text after rating
				ge->AddString(lpVolume + 8, false, m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint,
					cTemp, m_ssSettings.wcFontFace, m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f,
					m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f, cDropShadow);
			}

				delete[] lpBeforeRating;
		}
		else if (NULL != lpRating)
		{
			// Break up line
			lpBeforeRating = new wchar_t[lpRating - lpToken + 1];
			wcsncpy_s(lpBeforeRating, lpRating - lpToken + 1, lpToken, lpRating - lpToken);

			// Add text before rating
			for (const auto& ge : _ges)
			{
				ge->AddString(lpBeforeRating, false, m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint,
					cTemp, m_ssSettings.wcFontFace, m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f,
					m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f, cDropShadow);
			}

				// Add rating
				long lRating = m_ITCom->GetTrackRating();
			long lWhole = (lRating - (lRating % 20)) / 20;
			lRating = lRating - lWhole * 20;
			long lHalf = (lRating - (lRating % 10)) / 10;
			long lEmpty = 5 - lWhole - lHalf;

			RectF rfShape = RectF(0, 0, text_height, text_height);
			for (int i = 0; i < lWhole; i++)
			{
				for (const auto& ge : _ges)
				{
					if (m_ssSettings.nRatingType == 1)
						ge->AddImage(m_ssSettings.wcRatingFullPath);
					else
						ge->AddShape((ShapeType)m_ssSettings.nRatingShapeType, FillAll, rfShape, false, cShapeOutline, 3.0, cShapeFill);
				}
			}
			for (int i = 0; i < lHalf; i++)
			{
				for (const auto& ge : _ges)
				{
					if (m_ssSettings.nRatingType == 1)
						ge->AddImage(m_ssSettings.wcRatingHalfPath);
					else
						ge->AddShape((ShapeType)m_ssSettings.nRatingShapeType, (ShapeStyle)(m_ssSettings.nRatingShapeStyle + 2), rfShape, false, cShapeOutline, 3.0, cShapeFill);
				}
			}
			for (int i = 0; i < lEmpty; i++)
			{
				for (const auto& ge : _ges)
				{
					if (m_ssSettings.nRatingType == 1)
						ge->AddImage(m_ssSettings.wcRatingEmptyPath);
					else
						ge->AddShape((ShapeType)m_ssSettings.nRatingShapeType, FillNone, rfShape, false, cShapeOutline, 3.0, cShapeFill);
				}
			}

			// Add text after rating
			for (const auto& ge : _ges)
			{
				ge->AddString(lpRating + 8, false, m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint,
					cTemp, m_ssSettings.wcFontFace, m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f,
					m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f, cDropShadow);
			}

				delete[] lpBeforeRating;
		}
		else
		{
			for (const auto& ge : _ges)
			{
				ge->AddString(lpToken, false, m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint,
					cTemp, m_ssSettings.wcFontFace, m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f,
					m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f, cDropShadow);
			}
		}

		for (const auto& ge : _ges)
		{
			ge->EndLine();
		}

			lpToken = wcstok_s(NULL, L"\n", &lpContext);
	}

	// Position display
	if (!cm.GetMonitorRect(m_ssSettings.nOSDMonitor, rcScreen))
		SystemParametersInfo(SPI_GETWORKAREA, 0, &rcScreen, 0);

	pt.x = rcScreen.left + (LONG)ceilf((m_ssSettings.nOSDHoriz / 100.0f) * (rcScreen.right - rcScreen.left));
	pt.y = rcScreen.top + (LONG)ceilf((m_ssSettings.nOSDVert / 100.0f) * (rcScreen.bottom - rcScreen.top));

	// Show display, start timer
	if (m_ssSettings.bOSDAllMonitors)
	{
		int monitor = 1;

		for (const auto& ge : _ges)
		{
			// Position display
			cm.GetMonitorRect(monitor, rcScreen);

			pt.x = rcScreen.left + (LONG)ceilf((m_ssSettings.nOSDHoriz / 100.0f) * (rcScreen.right - rcScreen.left));
			pt.y = rcScreen.top + (LONG)ceilf((m_ssSettings.nOSDVert / 100.0f) * (rcScreen.bottom - rcScreen.top));

			ge->EndRender(pt, rcScreen);

			++monitor;
		}
	}
	else
	{
		for (const auto& ge : _ges)
		{
			ge->EndRender(pt, rcScreen);
		}
	}

	// Display should be shown for xx seconds, then hidden
	if (NULL != _hDisplayTimer)
		DeleteTimerQueueTimer(_hTimerQueue, _hDisplayTimer, INVALID_HANDLE_VALUE);
	_hDisplayTimer = NULL;
	CreateTimerQueueTimer(&_hDisplayTimer, _hTimerQueue, DisplayTimerCallback, (PVOID)this, display_time, 0, WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE);

	DisplayShow();

	LeaveCriticalSection(&_csCreateDisplay);

	return;
}
Esempio n. 27
0
HIMAGELIST
SdkCreateGrayImageList(
	IN HIMAGELIST himlNormal
	)
{
	int Count, i;
	int Width, Height;
	HIMAGELIST himlGray;
	HDC hdcDesktop;
	HDC hdcMem;
	RECT rc;
	COLORREF crMask;
	HPALETTE hpal;
	UINT index;
	HGDIOBJ hbm;
	HGDIOBJ hbmOld;
	COLORREF rgb;
	BYTE gray;
	HWND hWnd;
	int x, y;

	Count = ImageList_GetImageCount(himlNormal);
	if (Count == 0) {
		return NULL;
	}

	ImageList_GetIconSize(himlNormal, &Width, &Height);
	himlGray = ImageList_Create(Width, Height, ILC_COLOR24 | ILC_MASK, Count, 0);

	hdcDesktop = GetDC(NULL);
	hdcMem = CreateCompatibleDC(NULL);
	
	rc.top = rc.left = 0;
	rc.bottom = Height;
	rc.right = Width;
	crMask = RGB(200, 199, 200);

	if (GetDeviceCaps(hdcDesktop, BITSPIXEL) < 24) {
		hpal = (HPALETTE)GetCurrentObject(hdcDesktop, OBJ_PAL);
		index = GetNearestPaletteIndex(hpal, crMask);
		if (index != CLR_INVALID) { 
			crMask = PALETTEINDEX(index);
		}
	}

	for (i = 0 ; i < Count; ++i) {

		hbm = CreateCompatibleBitmap(hdcDesktop, Width, Height);
		hbmOld = SelectObject(hdcMem, hbm);

		SdkFillSolidRect(hdcMem, crMask, &rc);

		ImageList_SetBkColor(himlNormal, crMask);
		ImageList_Draw(himlNormal, i, hdcMem, 0, 0, ILD_NORMAL);

		for (x = 0 ; x < Width; ++x) {
			for (y = 0; y < Height; ++y) {
				rgb = GetPixel(hdcMem, x, y);
				if (rgb != crMask) { 
					gray = (BYTE) (95 + (GetRValue(rgb) * 3 + GetGValue(rgb) * 6 + GetBValue(rgb)) / 20);
					SetPixel(hdcMem, x, y, RGB(gray, gray, gray));
				}
			}
		}

		hbm = SelectObject(hdcMem, hbmOld);
		ImageList_AddMasked(himlGray, (HBITMAP)hbm, crMask);
		DeleteObject(hbm);
	}

	DeleteDC(hdcMem);
	hWnd = WindowFromDC(hdcDesktop);
	ReleaseDC(hWnd, hdcDesktop);

	return himlGray; 
}
Esempio n. 28
0
void GraphicsInterface::DisplayInfo(wstring wstrText, bool bArtwork, wchar_t *wcArt, int display_time, bool bUpdateOnly)
{
	GraphicsEngineOptions geo;
	RECT rcScreen;
	CMonitors cm;
	POINT pt = { 0, 0 };
	Color cNull = Color(0, 0, 0, 0);
	Color cTemp;
	Color cOutline;
	Color cArtOutline;
	Color cDropShadow;
	REAL rTemp;

	if (!m_ssSettings.bVisualFeedback)
		return;

	if (m_ssSettings.bNoDisplayWhenActive && m_ITCom->IsActiveWindow())
		return;

	if (bUpdateOnly && (_nDisplayType == 1 || !IsDisplayVisible()))
		return;

	EnterCriticalSection(&_csCreateDisplay);
	_nDisplayType = 0;

	// Configure
	geo.nDisplayAlpha = m_ssSettings.nOSDAlpha;
	geo.bDisplayTopMost = m_ssSettings.bOSDTopMost;
	geo.nMaxWidth = m_ssSettings.nOSDMaxWidth;
	geo.nArtScaleMode = m_ssSettings.nArtMode == 3 ? ART_SCALEMODEHEIGHT : ART_SCALEMODESIZE;
	geo.saAlign = (Gdiplus::StringAlignment)m_ssSettings.nOSDTextJustify;
	geo.bForceToWidth = m_ssSettings.bOSDForceWidth;

	if (!bArtwork || NULL == wcArt || 0 == wcscmp(wcArt, L""))
	{
		for (const auto& ge : _ges)
		{
			ge->SetOptions(geo);
			ge->BeginRender(5);
		}
	}
	else
	{
		for (const auto& ge : _ges)
		{
			ge->SetOptions(geo);
			ge->BeginRender(m_ssSettings.nDisplayLayout);
		}
	}

	// Set background and borders
	rTemp = (REAL)m_ssSettings.nOSDBorderSize;
	cOutline = Color(GetRValue(m_ssSettings.lOSDBorderColor), GetGValue(m_ssSettings.lOSDBorderColor), GetBValue(m_ssSettings.lOSDBorderColor));
	cTemp = Color(GetRValue(m_ssSettings.lOSDBkColorRef), GetGValue(m_ssSettings.lOSDBkColorRef), GetBValue(m_ssSettings.lOSDBkColorRef));
	cDropShadow = Color(GetRValue(m_ssSettings.lDropShadowColor), GetGValue(m_ssSettings.lDropShadowColor), GetBValue(m_ssSettings.lDropShadowColor));
	cArtOutline = Color(GetRValue(m_ssSettings.lArtBorderColor), GetGValue(m_ssSettings.lArtBorderColor), GetBValue(m_ssSettings.lArtBorderColor));
	for (const auto& ge : _ges)
	{
		ge->SetDisplayBorder(m_ssSettings.bOSDOutlineMode ? cNull : cOutline, rTemp);
		ge->SetDisplayBackground(m_ssSettings.bOSDOutlineMode ? cNull : cTemp);
	}

		// Add album art if needed
		if (bArtwork && m_ssSettings.bShowArtwork)
		{
			for (const auto& ge : _ges)
			{
				ge->AddArt(wcArt, false, cArtOutline, 1.5f, (float)m_ssSettings.nArtConstSize, m_ssSettings.nArtMode == 3 ? IMG_SCALENONE : IMG_SCALEALL);
			}
		}

	// Cache text height for shapes
	static REAL text_height;
	if (!bUpdateOnly)
		text_height = _ges.at(0)->GetTextHeight(m_ssSettings.wcFontFace, (float)m_ssSettings.nOSDFontPoint, m_ssSettings.nOSDFontStyle);

	// Break string into lines, add to display
	wchar_t *lpToken = NULL;
	wchar_t *lpContext = NULL;
	std::wstring line;
	size_t current_position = 0;
	size_t next_rating = 0;
	size_t next_format = 0;
	int old_font_style = m_ssSettings.nOSDFontStyle;
	cTemp = Color(GetRValue(m_ssSettings.lOSDColorRef), GetGValue(m_ssSettings.lOSDColorRef), GetBValue(m_ssSettings.lOSDColorRef));
	Color cShapeFill = Color(GetRValue(m_ssSettings.lRatingShapeFill), GetGValue(m_ssSettings.lRatingShapeFill), GetBValue(m_ssSettings.lRatingShapeFill));
	Color cShapeOutline = Color(GetRValue(m_ssSettings.lRatingShapeOutline), GetGValue(m_ssSettings.lRatingShapeOutline), GetBValue(m_ssSettings.lRatingShapeOutline));
	lpToken = wcstok_s(const_cast<wchar_t*>(wstrText.c_str()), L"\n", &lpContext);

	while (NULL != lpToken && m_ssSettings.nDisplayLayout != 4)
	{
		for (const auto& ge : _ges)
		{
			ge->BeginLine();
		}

			line = lpToken;
		current_position = 0;
		do
		{
			next_rating = line.find(L"%rating%", current_position);
			next_format = line.find(L"<", current_position);

			if ((next_rating == std::wstring::npos && next_format != std::wstring::npos) ||
				(next_format != std::wstring::npos && next_rating != std::wstring::npos &&
					next_format < next_rating))
			{
				// format
				if ((next_format - current_position) > 0)
				{
					for (const auto& ge : _ges)
					{
						ge->AddString(line.substr(current_position, next_format - current_position).c_str(), false,
							m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint, cTemp, m_ssSettings.wcFontFace,
							m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f, m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f,
							cDropShadow);
					}
				}
				if (line.compare(next_format, 3, L"<b>") == 0)
				{
					m_ssSettings.nOSDFontStyle |= FontStyleBold;
					current_position = next_format + 3;
				}
				else if (line.compare(next_format, 3, L"<i>") == 0)
				{
					m_ssSettings.nOSDFontStyle |= FontStyleItalic;
					current_position = next_format + 3;
				}
				else if (line.compare(next_format, 4, L"</b>") == 0)
				{
					m_ssSettings.nOSDFontStyle &= ~FontStyleBold;
					current_position = next_format + 4;
				}
				else if (line.compare(next_format, 4, L"</i>") == 0)
				{
					m_ssSettings.nOSDFontStyle &= ~FontStyleItalic;
					current_position = next_format + 4;
				}
				else
				{
					for (const auto& ge : _ges)
					{
						ge->AddString(line.substr(next_format, 1).c_str(), false,
							m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint, cTemp, m_ssSettings.wcFontFace,
							m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f, m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f,
							cDropShadow);
					}
					current_position = next_format + 1;
				}
			}
			else if ((next_format == std::wstring::npos && next_rating != std::wstring::npos) ||
				(next_format != std::wstring::npos && next_rating != std::wstring::npos &&
					next_rating < next_format))
			{
				// rating
				if ((next_rating - current_position) > 0)
				{
					for (const auto& ge : _ges)
					{
						ge->AddString(line.substr(current_position, next_rating - current_position).c_str(), false,
							m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint, cTemp, m_ssSettings.wcFontFace,
							m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f, m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f,
							cDropShadow);
					}
				}

				// Add rating
				long lRating = m_ITCom->GetTrackRating();
				long lWhole = (lRating - (lRating % 20)) / 20;
				lRating = lRating - lWhole * 20;
				long lHalf = (lRating - (lRating % 10)) / 10;
				long lEmpty = 5 - lWhole - lHalf;

				RectF rfShape = RectF(0, 0, text_height, text_height);
				for (int i = 0; i < lWhole; i++)
				{
					for (const auto& ge : _ges)
					{
						if (m_ssSettings.nRatingType == 1)
							ge->AddImage(m_ssSettings.wcRatingFullPath);
						else
							ge->AddShape((ShapeType)m_ssSettings.nRatingShapeType, FillAll, rfShape, false, cShapeOutline, 3.0, cShapeFill);
					}
				}
				for (int i = 0; i < lHalf; i++)
				{
					for (const auto& ge : _ges)
					{
						if (m_ssSettings.nRatingType == 1)
							ge->AddImage(m_ssSettings.wcRatingHalfPath);
						else
							ge->AddShape((ShapeType)m_ssSettings.nRatingShapeType, (ShapeStyle)(m_ssSettings.nRatingShapeStyle + 2), rfShape, false, cShapeOutline, 3.0, cShapeFill);
					}
				}
				for (int i = 0; i < lEmpty; i++)
				{
					for (const auto& ge : _ges)
					{
						if (m_ssSettings.nRatingType == 1)
							ge->AddImage(m_ssSettings.wcRatingEmptyPath);
						else
							ge->AddShape((ShapeType)m_ssSettings.nRatingShapeType, FillNone, rfShape, false, cShapeOutline, 3.0, cShapeFill);
					}
				}

				current_position = next_rating + 8;
			}
			else
			{
				// no special processing needed
				if (line.substr(current_position, std::wstring::npos).length() > 0)
				{
					for (const auto& ge : _ges)
					{
						ge->AddString(line.substr(current_position, std::wstring::npos).c_str(), false,
							m_ssSettings.nOSDFontStyle, (float)m_ssSettings.nOSDFontPoint, cTemp, m_ssSettings.wcFontFace,
							m_ssSettings.bOSDOutlineMode ? cOutline : cNull, 1.5f, m_ssSettings.bUseDropShadow ? m_ssSettings.fDropShadowOffset : 0.0f,
							cDropShadow);
					}
				}
			}
		} while (next_format != std::wstring::npos || next_rating != std::wstring::npos);

		for (const auto& ge : _ges)
		{
			ge->EndLine();
		}

		lpToken = wcstok_s(NULL, L"\n", &lpContext);
	}

	// Restore font style
	m_ssSettings.nOSDFontStyle = old_font_style;

	// Show display, start timer
	if (_bmInfo)
	{
		delete _bmInfo;
		_bmInfo = NULL;
	}

	if (m_ssSettings.bOSDAllMonitors)
	{
		bool has_track_pos = (NULL != wcsstr(m_ssSettings.wcOSDFormat, L"%track_position%"));
		int monitor = 1;

		for (const auto& ge : _ges)
		{
			// Position display
			cm.GetMonitorRect(monitor, rcScreen);

			pt.x = rcScreen.left + (LONG)ceilf((m_ssSettings.nOSDHoriz / 100.0f) * (rcScreen.right - rcScreen.left));
			pt.y = rcScreen.top + (LONG)ceilf((m_ssSettings.nOSDVert / 100.0f) * (rcScreen.bottom - rcScreen.top));

			if (has_track_pos)
				ge->EndRender(pt, rcScreen);
			else
				ge->EndRender(pt, rcScreen, m_ssSettings.bOSDAlwaysUp, &_bmInfo);

			++monitor;
		}
	}
	else
	{
		// Position display
		if (!cm.GetMonitorRect(m_ssSettings.nOSDMonitor, rcScreen))
			SystemParametersInfo(SPI_GETWORKAREA, 0, &rcScreen, 0);

		pt.x = rcScreen.left + (LONG)ceilf((m_ssSettings.nOSDHoriz / 100.0f) * (rcScreen.right - rcScreen.left));
		pt.y = rcScreen.top + (LONG)ceilf((m_ssSettings.nOSDVert / 100.0f) * (rcScreen.bottom - rcScreen.top));

		if (NULL != wcsstr(m_ssSettings.wcOSDFormat, L"%track_position%"))
		{
			for (const auto& ge : _ges)
			{
				ge->EndRender(pt, rcScreen);
			}
		}
		else
		{
			for (const auto& ge : _ges)
			{
				ge->EndRender(pt, rcScreen, m_ssSettings.bOSDAlwaysUp, &_bmInfo);
			}
		}
	}

	// Display should be shown for xx seconds, then hidden
	if (!bUpdateOnly)
	{
		if (!m_ssSettings.bOSDAlwaysUp)
		{
			if (NULL != _hDisplayTimer)
				DeleteTimerQueueTimer(_hTimerQueue, _hDisplayTimer, INVALID_HANDLE_VALUE);
			_hDisplayTimer = NULL;
			CreateTimerQueueTimer(&_hDisplayTimer, _hTimerQueue, DisplayTimerCallback, (PVOID)this, display_time, 0, WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE);
		}


		DisplayShow();
	}

	LeaveCriticalSection(&_csCreateDisplay);

	return;
}
Esempio n. 29
0
void CChartGradient::DrawGradient(CDC* pDC, const CRect& GradientRect, COLORREF Color1, 
								  COLORREF Color2, EGradientType GradientType)
{
#if _MFC_VER > 0x0600
	if ( (GradientType == gtHorizontal) || (GradientType == gtVertical) )
	{
		TRIVERTEX vertex[2] ;
		vertex[0].x     = GradientRect.left;
		vertex[0].y     = GradientRect.top;
		vertex[0].Red   = ((COLOR16)GetRValue(Color1))<<8;
		vertex[0].Green = ((COLOR16)GetGValue(Color1))<<8;
		vertex[0].Blue  = ((COLOR16)GetBValue(Color1))<<8;
		vertex[0].Alpha = 0x0000;
		vertex[1].x     = GradientRect.right;
		vertex[1].y     = GradientRect.bottom; 
		vertex[1].Red   = ((COLOR16)GetRValue(Color2))<<8;
		vertex[1].Green = ((COLOR16)GetGValue(Color2))<<8;
		vertex[1].Blue  = ((COLOR16)GetBValue(Color2))<<8;
		vertex[1].Alpha = 0x0000;
		GRADIENT_RECT gRect;
		gRect.UpperLeft  = 0;
		gRect.LowerRight = 1;
		if (GradientType == gtHorizontal)
			pDC->GradientFill(vertex,2,&gRect,1,GRADIENT_FILL_RECT_H);
		else
			pDC->GradientFill(vertex,2,&gRect,1,GRADIENT_FILL_RECT_V);
	}
	else
	{
		for (int i=0;i<2; i++)
		{
			TRIVERTEX vertex[2] ;
			if (GradientType == gtHorizontalDouble)
			{
				vertex[0].x     = GradientRect.left + (GradientRect.Width()/2) * i;
				vertex[0].y     = GradientRect.top;
			}
			else
			{
				vertex[0].x     = GradientRect.left;
				vertex[0].y     = GradientRect.top + (GradientRect.Height()/2) * i; 
			}
			if (i==0)
			{
				vertex[0].Red   = ((COLOR16)GetRValue(Color1))<<8;
				vertex[0].Green = ((COLOR16)GetGValue(Color1))<<8;
				vertex[0].Blue  = ((COLOR16)GetBValue(Color1))<<8;
			}
			else
			{
				vertex[0].Red   = ((COLOR16)GetRValue(Color2))<<8;
				vertex[0].Green = ((COLOR16)GetGValue(Color2))<<8;
				vertex[0].Blue  = ((COLOR16)GetBValue(Color2))<<8;
			}
			vertex[0].Alpha = 0x0000;
			if (GradientType == gtHorizontalDouble)
			{
				vertex[1].x     = GradientRect.left + (GradientRect.Width()/2) * (i+1);
				vertex[1].y     = GradientRect.bottom; 
			}
			else
			{
				vertex[1].x     = GradientRect.right;
				vertex[1].y     = GradientRect.top + (GradientRect.Height()/2) * (i+1); 
			}
			if (i==0)
			{
				vertex[1].Red   = ((COLOR16)GetRValue(Color2))<<8;
				vertex[1].Green = ((COLOR16)GetGValue(Color2))<<8;
				vertex[1].Blue  = ((COLOR16)GetBValue(Color2))<<8;
			}
			else
			{
				vertex[1].Red   = ((COLOR16)GetRValue(Color1))<<8;
				vertex[1].Green = ((COLOR16)GetGValue(Color1))<<8;
				vertex[1].Blue  = ((COLOR16)GetBValue(Color1))<<8;
			}			
			vertex[1].Alpha = 0x0000;

			GRADIENT_RECT gRect;
			gRect.UpperLeft  = 0;
			gRect.LowerRight = 1;
			if (GradientType == gtHorizontalDouble)
				pDC->GradientFill(vertex,2,&gRect,1,GRADIENT_FILL_RECT_H);
			else
				pDC->GradientFill(vertex,2,&gRect,1,GRADIENT_FILL_RECT_V);
		}
	}
#else
	CBrush NewBrush(Color1);
	pDC->FillRect(GradientRect,&NewBrush);
	DeleteObject(NewBrush);
#endif

}
Esempio n. 30
0
OP_STATUS
SVGColor::GetStringRepresentation(TempBuffer* buffer) const
{
	if(m_color_type == SVGCOLOR_RGBCOLOR)
	{
		if (m_color & CSS_COLOR_KEYWORD_TYPE_named &&
			!(m_color & ~(CSS_COLOR_KEYWORD_TYPE_named |
						  CSS_COLOR_KEYWORD_TYPE_index)))
		{
			const uni_char* colorstr = NULL;
			if((m_color & CSS_COLOR_KEYWORD_TYPE_ui_color) == CSS_COLOR_KEYWORD_TYPE_ui_color)
			{
				colorstr = CSS_GetKeywordString((short)(m_color & CSS_COLOR_KEYWORD_TYPE_index));
			}
			else if(m_color & CSS_COLOR_KEYWORD_TYPE_x_color)
			{
				colorstr = HTM_Lex::GetColNameByIndex(m_color & CSS_COLOR_KEYWORD_TYPE_index);
			}
#ifdef _DEBUG
			else
			{
				OP_ASSERT(!"Unknown color type");
			}
#endif			
			if(colorstr)
			{
				return buffer->Append(colorstr);
			}
		}
		else
		{
			OpString8 a;
			if(OP_GET_A_VALUE(m_color) != 255)
			{
				RETURN_IF_ERROR(a.AppendFormat("rgba(%d,%d,%d,%d)",
					OP_GET_R_VALUE(m_color),
					OP_GET_G_VALUE(m_color),
					OP_GET_B_VALUE(m_color),
					OP_GET_A_VALUE(m_color)));
			}
			else
			{
				RETURN_IF_ERROR(a.AppendFormat("#%02x%02x%02x",
					GetRValue(m_color),
					GetGValue(m_color),
					GetBValue(m_color)));
			}
			return buffer->Append(a.CStr(), a.Length());
		}
	}
	else if(m_color_type == SVGCOLOR_CURRENT_COLOR)
	{
		return buffer->Append("currentColor");
	}
	else if(m_color_type == SVGCOLOR_RGBCOLOR_ICCCOLOR)
	{
		// FIXME: Generate this string
	}
	else if(m_color_type == SVGCOLOR_NONE)
	{
		return buffer->Append("none");
	}

	OP_ASSERT(!"Unknown or unsupported color type");
	return OpStatus::ERR;
}