skinmenu.cpp

WMI接口测试Demo程序

		mapColors[crSrc] = 1;
	}

	// 2. replace other mapped colors 
	int nColor = sizeof(colors) / sizeof(colorMapping);
	
	while (nColor--)
	{
		int nTemp;
		int nSrcColor = colors[nColor].nSrcColor;
		crSrc = GetSysColor(nSrcColor);
		
		if (mapColors.Lookup(crSrc, nTemp))
		{
//			TRACE("CSkinMenu::ReplaceSystemColors - %d already replaced\n", crSrc);
			continue;
		}

		int nDestColor = colors[nColor].nDestColor;
		crDest = GetColor(nDestColor);

		// if the dest color is COLORMENU let the user have first go
		if (crDest == COLORMENU && s_pRenderer && s_pRenderer->DrawMenuClientBkgnd(pDCDest, pRect, pClip))
		{
			// transparent blt
			CSkinBase::BitBlt(pDCDest, pRect->left, pRect->top, 
						pRect->right - pRect->left, 
						pRect->bottom - pRect->top, pDCSrc, 0, 0, SRCCOPY, crSrc);

			// swap dest and src
			SwapDCs(pDCSrc, pDCDest);
		}
		// else simple color replacement
		else if (ReplaceColor(pDCSrc, crSrc, pDCDest, crDest, pRect, pClip))
		{		
			// swap dest and src
			SwapDCs(pDCSrc, pDCDest);
		}
//		else
//			TRACE("CSkinMenu::ReplaceSystemColors - GetSysColor(%d) == CSkinBase::GetColor(%d)\n", nSrcColor, nDestColor);
		
		mapColors[crSrc] = 1;
	}

	return pDCSrc;
}

BOOL CSkinMenu::ReplaceColor(CDC* pDCSrc, COLORREF crSrc, CDC* pDCDest, COLORREF crDest, LPRECT pRect, LPRECT pClip)
{
	if (crSrc == crDest)
		return FALSE;
	
	// else
	if (pClip)
	{
		pDCDest->FillSolidRect(pClip, crDest);
		CSkinBase::BitBlt(pDCDest, pClip->left, pClip->top, pClip->right - pClip->left, 
						pClip->bottom - pClip->top, pDCSrc, pClip->left, pClip->top, SRCCOPY, crSrc);
	}
	else
	{
		pDCDest->FillSolidRect(pRect, crDest);
		CSkinBase::BitBlt(pDCDest, pRect->left, pRect->top, pRect->right - pRect->left, 
						pRect->bottom - pRect->top, pDCSrc, pRect->left, pRect->top, SRCCOPY, crSrc);
	}

	return TRUE;
}

void CSkinMenu::OnPrintClient(CDC* pDC, DWORD dwFlags)
{
	CRect rClient;
	GetClientRect(rClient);

	CRect rClip(rClient);
//	pDC->GetClipBox(rClip);

	// create standard back buffer and another dc on which 
	// to layer the background and foreground
	CDC dcMem, dcMem2;
	dcMem.CreateCompatibleDC(NULL);
	dcMem2.CreateCompatibleDC(NULL);
	
	// use screen dc for creating bitmaps because
	// menu dc's seem not to be standard.
	CDC* pDCScrn = CWnd::GetDesktopWindow()->GetDC();
	
	CBitmap bmMem, bmMem2;
	bmMem.CreateCompatibleBitmap(pDCScrn, rClient.right, rClient.bottom);
	bmMem2.CreateCompatibleBitmap(pDCScrn, rClient.right, rClient.bottom);

	// release screen dc asap
	CWnd::GetDesktopWindow()->ReleaseDC(pDCScrn);
	
	// prepare dc's
	dcMem.SetBkMode(TRANSPARENT);
	dcMem.SetBkColor(GetSysColor(COLOR_MENU));

	CBitmap* pOldBM = dcMem.SelectObject(&bmMem);
	CFont* pOldFont = dcMem.SelectObject(GetFont(SBFONT_MENU));
	CBitmap* pOldBM2 = dcMem2.SelectObject(&bmMem2);

	// trim clip rgn
	if (rClip.top)
		dcMem.ExcludeClipRect(0, 0, rClient.right, rClip.top);

	if (rClip.bottom < rClient.bottom)
		dcMem.ExcludeClipRect(0, rClip.bottom, rClient.right, rClient.bottom);

	// draw background
//	dcMem.FillSolidRect(rClient, GetSysColor(COLOR_MENU));
	dcMem.FillSolidRect(rClip, GetSysColor(COLOR_MENU));

	// default draw
	CSubclassWnd::WindowProc(*this, WM_PRINTCLIENT, (WPARAM)(HDC)dcMem, (LPARAM)dwFlags);
	
	// replace the system colors with skin colors
	CDC* pDCSrc = ReplaceSystemColors(&dcMem, &dcMem2, rClient, rClip);
	
	// blt the lot to pDC
//	pDC->BitBlt(0, 0, rClient.right, rClient.bottom, pDCSrc, 0, 0, SRCCOPY);
	pDC->BitBlt(rClip.left, rClip.top, rClip.Width(), rClip.Height(), 
				pDCSrc, rClip.left, rClip.top, SRCCOPY);
	
	// cleanup
	dcMem.SelectObject(pOldBM);
	dcMem.SelectObject(pOldFont);
	dcMem.DeleteDC();
	bmMem.DeleteObject();
	
	dcMem2.SelectObject(pOldBM2);
	dcMem2.DeleteDC();
	bmMem2.DeleteObject();
}

void CSkinMenu::OnPaint(CDC* pDC)
{
	// construct a back buffer for the default draw
	CRect rClient;
	GetClientRect(rClient);
	
	CBitmap bmMem;
	bmMem.CreateCompatibleBitmap(pDC, rClient.right, rClient.bottom);
	
	CDC dcMem;
	dcMem.CreateCompatibleDC(NULL);
	
	dcMem.SetBkMode(TRANSPARENT);
	dcMem.SetBkColor(GetSysColor(COLOR_MENU));
	CBitmap* pOldBM = dcMem.SelectObject(&bmMem);
	CFont* pOldFont = dcMem.SelectObject(GetFont(SBFONT_MENU));
	
	// draw background
	dcMem.FillSolidRect(rClient, GetSysColor(COLOR_MENU));
	
	// default draw
	CWnd* pWnd = *this;
	CSubclassWnd::WindowProc(pWnd, WM_PAINT, (WPARAM)(HDC)dcMem, 0);
	
	// create another dc on which to layer the background and foreground
	CDC dcMem2;
	dcMem2.CreateCompatibleDC(NULL);
	
	CBitmap bmMem2;
	bmMem2.CreateCompatibleBitmap(pDC, rClient.right, rClient.bottom);
	CBitmap* pOldBM2 = dcMem2.SelectObject(&bmMem2);
	
	// replace the system colors with skin colors
	CDC* pDCSrc = ReplaceSystemColors(&dcMem, &dcMem2, rClient, NULL);
	
	// blt the lot to pDC
	pDC->BitBlt(0, 0, rClient.right, rClient.bottom, pDCSrc, 0, 0, SRCCOPY);
	
	// cleanup
	dcMem.SelectObject(pOldBM);
	dcMem.SelectObject(pOldFont);
	dcMem.DeleteDC();
	bmMem.DeleteObject();
	
	dcMem2.SelectObject(pOldBM2);
	dcMem2.DeleteDC();
	bmMem2.DeleteObject();
}

void CSkinMenu::OnNcPaint(CDC* pDC)
{
	int nOS = CSkinBase::GetOS();

	BOOL bIRender = !(nOS == SBOS_95 || nOS == SBOS_NT4);

	CRect rWindow, rClient;
	GetDrawRect(rWindow, rClient);

	CRect rClip;
	pDC->GetClipBox(rClip);

//	TRACE ("CSkinMenu::OnNcPaint(clip box = {%d x %d})\n", rClip.Width(), rClip.Height());

	// back buffer
	CBitmap bmMem;
	bmMem.CreateCompatibleBitmap(pDC, rWindow.right, rWindow.bottom);
	
	CDC dcMem;
	dcMem.CreateCompatibleDC(NULL);
	
	CBitmap* pOldBM = dcMem.SelectObject(&bmMem);
	
	COLORREF crColorMenu = GetColor(COLOR_MENU);

	// draw sidebar
	CRect rSidebar(rWindow);
	rSidebar.DeflateRect(3, 3);
	rSidebar.right = rSidebar.left + m_nSidebarWidth;
		
	if (Sidebar() && (!s_pRenderer || !s_pRenderer->DrawMenuSidebar(&dcMem, rSidebar)))
	{
		dcMem.FillSolidRect(rSidebar, CSkinBase::VaryColor(GetColor(COLOR_3DSHADOW), 0.9f));
	}

	// then clip sidebar out
	dcMem.ExcludeClipRect(rSidebar);

	// draw nc bkgnd
	// note: do this ourselves under win95 to ensure continuity with client bkgnd
	if (!bIRender || !s_pRenderer || !s_pRenderer->DrawMenuNonClientBkgnd(&dcMem, rWindow))
	{
		dcMem.FillSolidRect(rWindow, crColorMenu);
	}

	// draw nc border
	if (!bIRender || !s_pRenderer || !s_pRenderer->DrawMenuBorder(&dcMem, rWindow))
	{
		COLORREF crShadow = GetColor(COLOR_3DSHADOW);

		if (Flat())
			dcMem.Draw3dRect(rWindow, crShadow, crShadow);
		else
			dcMem.Draw3dRect(rWindow, GetColor(COLOR_3DHIGHLIGHT), crShadow);
	}

	// blt to screen
	int nSaveDC = pDC->SaveDC(); // must restore dc to original state

	pDC->ExcludeClipRect(rClient);
	pDC->BitBlt(0, 0, rWindow.right, rWindow.bottom, &dcMem, 0, 0, SRCCOPY);

	pDC->RestoreDC(nSaveDC);

	// cleanup
	dcMem.SelectObject(pOldBM);
}

void CSkinMenu::GetDrawRect(LPRECT pWindow, LPRECT pClient)
{
	CRect rWindow;
	GetWindowRect(rWindow);
	
	if (pClient)
	{
		GetClientRect(pClient);
		GetHookedWnd()->ClientToScreen(pClient);
		::OffsetRect(pClient, -rWindow.left, -rWindow.top);
	}
	
	if (pWindow)
	{
		rWindow.OffsetRect(-rWindow.TopLeft());
		*pWindow = rWindow;
	}
}

COLORREF CSkinMenu::GetColor(int nColor)
{
	return m_pGlobals ? m_pGlobals->GetColor(nColor) : CSkinGlobals::GetColorSt(nColor);
}

CFont* CSkinMenu::GetFont(int nFont)
{
	return m_pGlobals ? m_pGlobals->GetFont(nFont) : CSkinGlobals::GetFontSt(nFont);
}

void CSkinMenu::SetContextWnd(HWND hWnd) 
{ 
	if (hWnd && ::IsWindow(hWnd))
		m_hContextWnd = hWnd;
	else
		m_hContextWnd = NULL; 
}

void CSkinMenu::SetMenu(HMENU hMenu, CSkinMenu* pParentMenu) 
{ 
	if (m_hMenu && hMenu) // already set
		return;
	
	// else
	if (hMenu && ::IsMenu(hMenu)) 
		m_hMenu = hMenu;
	else
		m_hMenu = NULL; 

	TRACE("CSkinMenu::SetMenu(hwnd = %08x, hmenu = %08x)\n", m_hWndHooked, hMenu);

	m_pParentMenu = pParentMenu;
}

void CSkinMenu::GetInvalidRect(int nCurSel, int nPrevSel, LPRECT lpRect)
{
	ASSERT (lpRect);

	if (!m_hMenu || nCurSel == REDRAWALL || nPrevSel == REDRAWALL)
		GetClientRect(lpRect);

	else if (m_hMenu)
	{
		::SetRectEmpty(lpRect);

		if (nCurSel >= 0 || nPrevSel >= 0)
		{
			if (nCurSel >= 0)
			{
				GetMenuItemRect(NULL, m_hMenu, nCurSel, lpRect);
			}
					
			if (nPrevSel >= 0)
			{
				CRect rTemp;
			
				GetMenuItemRect(NULL, m_hMenu, nPrevSel, rTemp);
				::UnionRect(lpRect, lpRect, rTemp);
			}

			// convert to client coords
			GetHookedWnd()->ScreenToClient(lpRect);
		}
	}
}

int CSkinMenu::GetCurSel()
{
	ASSERT (m_hMenu);
	int nItem = GetMenuItemCount(m_hMenu);
	
	while (nItem--)
	{
		if (GetMenuState(m_hMenu, nItem, MF_BYPOSITION) & MF_HILITE)
			return nItem;
	}

	return -1; // nothing selected
}