// ==========================================================================
//					Class Implementation : COX*Skin
// ==========================================================================
// This software along with its related components, documentation and files ("The Libraries")
// is © 1994-2007 The Code Project (1612916 Ontario Limited) and use of The Libraries is
// governed by a software license agreement ("Agreement").  Copies of the Agreement are
// available at The Code Project (www.codeproject.com), as part of the package you downloaded
// to obtain this file, or directly from our office.  For a copy of the license governing
// this software, you may contact us at legalaffairs@codeproject.com, or by calling 416-849-8900.
// Version: 9.3

#include "stdafx.h"
#include "OXSkins.h"
#include "OXCoolToolBar.h"
#include "OXMenuBar.h"

#include "OXSizeDockBar.h"
#include "OXSzMiniDockFrmWnd.h"
#include "OXFrameWndDock.h"
#include "OXTabClientWnd.h"
#include "XStatus4.h"
#include "OXSplitterRect.h"
#include "OXShortcutBar.h"

BOOL IsThemed()
{
	BOOL ret = FALSE;
	OSVERSIONINFO ovi = {0};
	ovi.dwOSVersionInfoSize = sizeof ovi;
	GetVersionEx(&ovi);
	if(ovi.dwMajorVersion==5 && ovi.dwMinorVersion==1)
	{
		//Windows XP detected
		typedef BOOL WINAPI ISAPPTHEMED();
		typedef BOOL WINAPI ISTHEMEACTIVE();
		ISAPPTHEMED* pISAPPTHEMED = NULL;
		ISTHEMEACTIVE* pISTHEMEACTIVE = NULL;
		HMODULE hMod = LoadLibrary(_T("uxtheme.dll"));
		if(hMod)
		{
			pISAPPTHEMED = reinterpret_cast<ISAPPTHEMED*>(GetProcAddress(hMod,"IsAppThemed"));
			pISTHEMEACTIVE = reinterpret_cast<ISTHEMEACTIVE*>(GetProcAddress(hMod,"IsThemeActive"));
			if(pISAPPTHEMED && pISTHEMEACTIVE)
			{
				if(pISAPPTHEMED() && pISTHEMEACTIVE())				
				{				
					typedef HRESULT CALLBACK DLLGETVERSION(DLLVERSIONINFO*);
					DLLGETVERSION* pDLLGETVERSION = NULL;

					HMODULE hModComCtl = LoadLibrary(_T("comctl32.dll"));
					if(hModComCtl)
					{
						pDLLGETVERSION = reinterpret_cast<DLLGETVERSION*>(
							GetProcAddress(hModComCtl,"DllGetVersion"));
						if(pDLLGETVERSION)
						{
							DLLVERSIONINFO dvi = {0};
							dvi.cbSize = sizeof dvi;
							if(pDLLGETVERSION(&dvi) == NOERROR )
							{
								ret = dvi.dwMajorVersion >= 6;
							}
						}
						FreeLibrary(hModComCtl);
					}
				}
			}
			FreeLibrary(hMod);
		}
	}	
	return ret;
}

// COXDockbarSkin
//


// COXDockbarSkinClassic
//

COXDockbarSkinClassic::COXDockbarSkinClassic()
{
	m_fontCaption.CreatePointFont(100, _T("Arial"));
	m_fontCaptionSolid.CreatePointFont(80, _T("Arial"));

	// Init the control bar constants
	m_ControlBarConstants.iButtonGap = 2;
}

COXDockbarSkinClassic::~COXDockbarSkinClassic()
{
}

void COXDockbarSkinClassic::DrawBackground(CDC* pDC, COXSizeDockBar* pSizeDockBar)
{
	CRect rectClient;
	pSizeDockBar->GetClientRect(rectClient);
	pDC->FillSolidRect(rectClient, ::GetSysColor(COLOR_3DFACE));
}

void COXDockbarSkinClassic::DrawGripper(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsGripper() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		return;
	}

	BOOL bHorz=(pSizeControlBar->m_dwStyle&CBRS_ORIENT_HORZ)==0;

	CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CRect gripper=pSizeControlBar->m_rectGripper;
	gripper.OffsetRect(-rectWindow.left, -rectWindow.top);

	if(pSizeControlBar->IsSolidGripper())
	{
		CBrush brush((pSizeControlBar->IsActive() ? ::GetSysColor(COLOR_ACTIVECAPTION) : 
			::GetSysColor(COLOR_INACTIVECAPTION)));
		pDC->FillRect(gripper,&brush);
	}
	else
	{
		gripper.DeflateRect(2,2);
	}

	CString sBarTitle;
	pSizeControlBar->GetWindowText(sBarTitle);
	CRect rectText=CRect(0,0,0,0);

	//draw text
	if(pSizeControlBar->IsCaption() && !sBarTitle.IsEmpty())
	{
		rectText=gripper;
		if(!bHorz)
		{
			rectText.bottom-=ID_TEXT_OFFSET;
		}
		else
		{
			rectText.left+=ID_TEXT_OFFSET;
		}

		COLORREF oldColor;
		if(pSizeControlBar->IsSolidGripper())
		{
			oldColor=pDC->SetTextColor((pSizeControlBar->IsActive() ? 
				::GetSysColor(COLOR_CAPTIONTEXT) : 
				::GetSysColor(COLOR_INACTIVECAPTIONTEXT)));
		}
		else
		{
			oldColor=pDC->SetTextColor((pSizeControlBar->IsActive() ? 
				::GetSysColor(COLOR_ACTIVECAPTION) : 
				::GetSysColor(COLOR_INACTIVECAPTION)));
		}

		CFont* pOldFont=NULL;
		CFont fontVert;
		if(!bHorz)
		{
			// setup font for vertically oriented mode
			LOGFONT lf;
			if (pSizeControlBar->IsSolidGripper())
				VERIFY(m_fontCaptionSolid.GetLogFont(&lf));
			else
				VERIFY(m_fontCaption.GetLogFont(&lf));
			lf.lfEscapement=900;
			lf.lfOrientation=900;
			VERIFY(fontVert.CreateFontIndirect(&lf));
			pOldFont=pDC->SelectObject(&fontVert);
		}
		else
		{
			if (pSizeControlBar->IsSolidGripper())
				pOldFont=pDC->SelectObject(&m_fontCaptionSolid);
			else
				pOldFont=pDC->SelectObject(&m_fontCaption);
		}

		CRect rectHelper=rectText;
		if(!bHorz)
		{
			// adjust rectangle to display vertical text
			rectText.top=rectHelper.left;
			rectText.bottom=rectHelper.right;
			rectText.left=rectHelper.top;
			rectText.right=rectHelper.bottom;
		}

		// calculate the rect to display text in
		UINT nFormat=DT_LEFT|DT_SINGLELINE;
		pDC->DrawText(sBarTitle,&rectText,nFormat|DT_CALCRECT);
		if(!bHorz)
		{
			if(rectText.Width()>rectHelper.Height())
				rectText.right=rectText.left+rectHelper.Height();
			rectHelper=rectText;

			rectText.top=rectHelper.left;
			rectText.bottom=rectHelper.right;
			rectText.left=rectHelper.top;
			rectText.right=rectHelper.bottom;
			rectHelper=rectText;
		}
		else
		{
			if(rectText.Width()>rectHelper.Width())
				rectText.right=rectText.left+rectHelper.Width();
			rectHelper=rectText;
		}

		// adjust coordinates
		if(!bHorz)
		{
			rectText.left+=(gripper.Width()-rectHelper.Width())/2+
				(gripper.Width()-rectHelper.Width())%2;
			rectText.right=rectText.left+rectHelper.Width();
		}
		else
		{
			rectText.top+=(gripper.Height()-rectHelper.Height())/2+
				(gripper.Height()-rectHelper.Height())%2;
			rectText.bottom=rectText.top+rectHelper.Height();
		}

		if(!bHorz)
		{
			rectText.bottom=gripper.bottom-ID_TEXT_OFFSET;
			rectText.top=rectText.bottom-rectHelper.Height();
		}
		else
		{
			rectText.left=rectText.left;
			rectText.right=rectText.left+rectHelper.Width();
		}

		rectHelper=rectText;
		if(!bHorz)
		{
			rectHelper.bottom+=rectText.Width();
			rectHelper.right+=rectText.Height();
		}

		int nOldBkMode=0;
		if(pSizeControlBar->IsSolidGripper())
		{
			nOldBkMode=pDC->SetBkMode(TRANSPARENT);
		}
		// draw text
		pDC->DrawText(sBarTitle,&rectHelper,
			DT_BOTTOM|DT_LEFT|DT_SINGLELINE|DT_END_ELLIPSIS);
		if(pSizeControlBar->IsSolidGripper())
		{
			pDC->SetBkMode(nOldBkMode);
		}

		pDC->SetTextColor(oldColor);
		if(pOldFont!=NULL)
		{
			pDC->SelectObject(pOldFont);
		}
	}


	if(!pSizeControlBar->IsSolidGripper())
	{
		// paint the gripper
		if(!bHorz) 
		{
			if(!rectText.IsRectEmpty())
			{
				gripper.bottom=rectText.top-ID_TEXTGRIPPER_MARGIN;
			}
			
			// gripper at left
			if(gripper.bottom>gripper.top && gripper.Height()>=ID_GRIPPER_MINSIZE)
			{
				gripper.right = gripper.left + 3;
				pDC->Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
					::GetSysColor(COLOR_BTNSHADOW));
				gripper.OffsetRect(4, 0);
				pDC->Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
					::GetSysColor(COLOR_BTNSHADOW));
			}
		}
		else 
		{
			if(!rectText.IsRectEmpty())
			{
				gripper.left=rectText.right+ID_TEXTGRIPPER_MARGIN;
			}

			// gripper at top
			if(gripper.right>gripper.left && gripper.Width()>=ID_GRIPPER_MINSIZE)
			{
				gripper.bottom = gripper.top + 3;
				pDC->Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
					::GetSysColor(COLOR_BTNSHADOW));
				gripper.OffsetRect(0, 4);
				pDC->Draw3dRect(gripper, ::GetSysColor(COLOR_BTNHIGHLIGHT),
					::GetSysColor(COLOR_BTNSHADOW));
			}
		}
	}
}

void COXDockbarSkinClassic::DrawCloseButton(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsCloseBtn() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
		return;

	// draw close button
    CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CRect rcButton=pSizeControlBar->m_rectCloseBtn;
	rcButton.OffsetRect(-rectWindow.left, -rectWindow.top);

	// Draw to a memory dc to avoid flashing
	CDC dc;
	dc.CreateCompatibleDC(pDC);
	CBitmap bmpMem;
	CRect rectMem(rcButton);
	rectMem.OffsetRect(-rectMem.left, -rectMem.top);
	bmpMem.CreateCompatibleBitmap(pDC, rectMem.Width(), rectMem.Height());
	CBitmap* pOldBmp = dc.SelectObject(&bmpMem);

	dc.DrawFrameControl(CRect(0, 0, rcButton.Width(), rcButton.Height()), DFC_CAPTION,DFCS_CAPTIONCLOSE|
		(pSizeControlBar->m_pressedBtn==COXSizeControlBar::CLOSEBTN ? DFCS_PUSHED : 0));
	pDC->BitBlt(rcButton.left, rcButton.top, rcButton.Width(), rcButton.Height(), &dc, 0, 0, SRCCOPY);
	dc.SelectObject(pOldBmp);
}

void COXDockbarSkinClassic::DrawResizeButton(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsResizeBtn() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
		return;

	// draw close button
    CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CRect rcButton=pSizeControlBar->m_rectResizeBtn;
	rcButton.OffsetRect(-rectWindow.left, -rectWindow.top);

	// Draw to a memory dc to avoid flashing
	CDC dc;
	dc.CreateCompatibleDC(pDC);
	CBitmap bmpMem;
	CRect rectMem(rcButton);
	rectMem.OffsetRect(-rectMem.left, -rectMem.top);
	bmpMem.CreateCompatibleBitmap(pDC, rectMem.Width(), rectMem.Height());
	CBitmap* pOldBmp = dc.SelectObject(&bmpMem);

	dc.DrawFrameControl(CRect(0, 0, rcButton.Width(), rcButton.Height()),DFC_CAPTION,
		(pSizeControlBar->m_bMaximized ? DFCS_CAPTIONMIN : DFCS_CAPTIONMAX)|
		(pSizeControlBar->m_pressedBtn==COXSizeControlBar::RESIZEBTN ? DFCS_PUSHED : 0)|
		(pSizeControlBar->CanResize() ? 0 : DFCS_INACTIVE));
	pDC->BitBlt(rcButton.left, rcButton.top, rcButton.Width(), rcButton.Height(), &dc, 0, 0, SRCCOPY);
	dc.SelectObject(pOldBmp);
}

void COXDockbarSkinClassic::DrawNonClientArea(CDC* pDC, LPCRECT lpRect, COXSizeControlBar* pSizeControlBar)
{
	CRect rect(lpRect);
	pSizeControlBar->DrawBorders(pDC, rect);
	pDC->FillSolidRect(lpRect, ::GetSysColor(COLOR_BTNFACE));
}

void COXDockbarSkinClassic::DrawSplitter(CDC* pDC, COXSplitterRect* pSplitterRect, COXSizeDockBar* /*pSizeDockBar*/)
{
    CRect rect=pSplitterRect->m_rect;
    switch(pSplitterRect->m_type)
	{
    case SPLITTER_VERT:
		{
			rect.left++;
			pDC->FillSolidRect(rect.left, rect.top, 1, rect.Height(), 
				::GetSysColor(COLOR_BTNFACE));
			rect.left++;
			pDC->FillSolidRect(rect.left, rect.top, 1, rect.Height(), 
				::GetSysColor(COLOR_BTNHILIGHT));
			
			rect.right--;
			pDC->FillSolidRect(rect.right, rect.top, 1, rect.Height(), 
				::GetSysColor(COLOR_WINDOWFRAME));
			rect.right--;
			pDC->FillSolidRect(rect.right, rect.top, 1, rect.Height(), 
				::GetSysColor(COLOR_BTNSHADOW));
		}
		break;
	
    case SPLITTER_HORZ:
		{
			rect.top++;
			pDC->FillSolidRect(rect.left, rect.top, rect.Width(), 1, 
				::GetSysColor(COLOR_BTNFACE));
			rect.top++;
			pDC->FillSolidRect(rect.left, rect.top, rect.Width(), 1, 
				::GetSysColor(COLOR_BTNHILIGHT));
			
			rect.bottom--;
			pDC->FillSolidRect(rect.left, rect.bottom, rect.Width(), 1,
				::GetSysColor(COLOR_WINDOWFRAME));
			rect.bottom--;
			pDC->FillSolidRect(rect.left, rect.bottom, rect.Width(), 1, 
				::GetSysColor(COLOR_BTNSHADOW));

		}
        break;
		
	default:
        ASSERT(FALSE);
        break;
	}
}

COLORREF COXDockbarSkinClassic::GetClientBorderColor()
{
	return ::GetSysColor(COLOR_WINDOWFRAME);
}

void COXDockbarSkinClassic::OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS* lpncsp, COXSizeControlBar* pSizeControlBar)
{
	CRect rect=lpncsp->rgrc[0];
	rect.DeflateRect(ID_CONTAINER_GAP, ID_CONTAINER_GAP);

	if(pSizeControlBar->IsGripper() && !(pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		if(pSizeControlBar->m_dwStyle&CBRS_ORIENT_HORZ) 
		{
			rect.DeflateRect(ID_CONTAINER_GAP,0,0,0);
			rect.left+=ID_BUTTON_SIDE;
			if(rect.left>rect.right)
			{
				rect.left=rect.right;
			}
		} 
		else 
		{
			rect.DeflateRect(0,ID_CONTAINER_GAP,0,0);
			rect.top+=ID_BUTTON_SIDE;
			if(rect.top>rect.bottom)
			{
				rect.top=rect.bottom;
			}
		}
		pSizeControlBar->m_bDelayRecalcLayout=TRUE;
	}

	lpncsp->rgrc[0]=rect;
}

void COXDockbarSkinClassic::RecalcLayout(COXSizeControlBar* pSizeControlBar)
{
	CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	rectWindow.DeflateRect(ID_CONTAINER_GAP, ID_CONTAINER_GAP);
	pSizeControlBar->m_rectGripper=rectWindow;
    
	if(pSizeControlBar->IsGripper() && !(pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		if(pSizeControlBar->m_dwStyle&CBRS_ORIENT_HORZ) 
		{
			pSizeControlBar->m_rectGripper.right=pSizeControlBar->m_rectGripper.left+ID_BUTTON_SIDE;
			
			if(pSizeControlBar->IsCloseBtn())
			{
				pSizeControlBar->m_rectCloseBtn=pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectCloseBtn.bottom=pSizeControlBar->m_rectCloseBtn.top+ID_BUTTON_SIDE;
				pSizeControlBar->m_rectGripper.top+=ID_BUTTON_SIDE+GetControlBarConstants().iButtonGap;
			}

			if(pSizeControlBar->IsResizeBtn())
			{
				pSizeControlBar->m_rectResizeBtn=pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectResizeBtn.bottom=pSizeControlBar->m_rectResizeBtn.top+ID_BUTTON_SIDE;
				pSizeControlBar->m_rectGripper.top+=ID_BUTTON_SIDE+GetControlBarConstants().iButtonGap;
			}
		} 
		else 
		{
			pSizeControlBar->m_rectGripper.bottom=pSizeControlBar->m_rectGripper.top+ID_BUTTON_SIDE;
			
			if(pSizeControlBar->IsCloseBtn())
			{
				pSizeControlBar->m_rectCloseBtn=pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectCloseBtn.left=pSizeControlBar->m_rectCloseBtn.right-ID_BUTTON_SIDE;
				pSizeControlBar->m_rectGripper.right-=ID_BUTTON_SIDE+GetControlBarConstants().iButtonGap;
			}

			if(pSizeControlBar->IsResizeBtn())
			{
				pSizeControlBar->m_rectResizeBtn=pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectResizeBtn.left=pSizeControlBar->m_rectResizeBtn.right-ID_BUTTON_SIDE;
				pSizeControlBar->m_rectGripper.right-=ID_BUTTON_SIDE+GetControlBarConstants().iButtonGap;
			}
		}
	}

	pSizeControlBar->m_bDelayRecalcLayout=FALSE;
}


// COXDockbarSkinXP
//

COXDockbarSkinXP::COXDockbarSkinXP(COXSkinXP* pSkinXP)
{
	m_pSkinXP = pSkinXP;
	m_fontCaption.CreatePointFont(85, _T("Tahoma BOLD"));

	// Init the control bar constants
	m_ControlBarConstants.iButtonGap = 3;
}

COXDockbarSkinXP::~COXDockbarSkinXP()
{
}

void COXDockbarSkinXP::DrawBackground(CDC* pDC, COXSizeDockBar* pSizeDockBar)
{
	CRect rectClient;
	pSizeDockBar->GetClientRect(rectClient);
	pDC->FillSolidRect(rectClient, ::GetSysColor(COLOR_3DFACE));
}

void COXDockbarSkinXP::DrawGripper(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsGripper() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		return;
	}

	BOOL bHorz=(pSizeControlBar->m_dwStyle&CBRS_ORIENT_HORZ)==0;

	CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CRect gripper=pSizeControlBar->m_rectGripper;

	// If this is a solid griper extend it to include the buttons
	if (pSizeControlBar->IsSolidGripper())
	{
		gripper.UnionRect(gripper, pSizeControlBar->m_rectCloseBtn);
		gripper.UnionRect(gripper, pSizeControlBar->m_rectResizeBtn);
	}
	gripper.InflateRect(3, 3);	
	gripper.OffsetRect(-rectWindow.left, -rectWindow.top);

	if(pSizeControlBar->IsSolidGripper())
	{
		CBrush brush(::GetSysColor(COLOR_INACTIVECAPTION));
		CRect rectCaption(gripper);
		if (bHorz)
			rectCaption.DeflateRect(1, 2, 1, 1);
		else
			rectCaption.DeflateRect(2, 2, 1, 1);
		pDC->FillRect(rectCaption, &brush);
	}
	else
	{
		if (bHorz)
			gripper.DeflateRect(4, 2);
		else
			gripper.DeflateRect(2, 0);
	}

	CString sBarTitle;
	pSizeControlBar->GetWindowText(sBarTitle);
	CRect rectText=CRect(0,0,0,0);

	//draw text
	if(pSizeControlBar->IsCaption() && !sBarTitle.IsEmpty())
	{
		rectText=gripper;

		if (pSizeControlBar->IsSolidGripper())
		{
			if(!bHorz)
			{
				rectText.bottom-=4;
			}
			else
			{
				rectText.left+=4;
			}
		}

		COLORREF oldColor;
		if(pSizeControlBar->IsSolidGripper())
		{
			oldColor=pDC->SetTextColor(::GetSysColor(COLOR_CAPTIONTEXT));
		}
		else
		{
			oldColor=pDC->SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
		}

		CFont* pOldFont=NULL;
		CFont fontVert;
		if(!bHorz)
		{
			// setup font for vertically oriented mode
			LOGFONT lf;
			VERIFY(m_fontCaption.GetLogFont(&lf));
			lf.lfEscapement=900;
			lf.lfOrientation=900;
			VERIFY(fontVert.CreateFontIndirect(&lf));
			pOldFont=pDC->SelectObject(&fontVert);
		}
		else
		{
			pOldFont=pDC->SelectObject(&m_fontCaption);
		}

		CRect rectHelper=rectText;
		if(!bHorz)
		{
			// adjust rectangle to display vertical text
			rectText.top=rectHelper.left;
			rectText.bottom=rectHelper.right;
			rectText.left=rectHelper.top;
			rectText.right=rectHelper.bottom;
		}

		// calculate the rect to display text in
		UINT nFormat=DT_LEFT|DT_SINGLELINE;
		pDC->DrawText(sBarTitle,&rectText,nFormat|DT_CALCRECT);
		if(!bHorz)
		{
			if(rectText.Width()>rectHelper.Height())
				rectText.right=rectText.left+rectHelper.Height();
			rectHelper=rectText;

			rectText.top=rectHelper.left;
			rectText.bottom=rectHelper.right;
			rectText.left=rectHelper.top;
			rectText.right=rectHelper.bottom;
			rectHelper=rectText;
		}
		else
		{
			if(rectText.Width()>rectHelper.Width())
				rectText.right=rectText.left+rectHelper.Width();
			rectHelper=rectText;
		}

		// adjust coordinates
		if(!bHorz)
		{
			rectText.left+=(gripper.Width()-rectHelper.Width())/2+
				(gripper.Width()-rectHelper.Width())%2;
			rectText.right=rectText.left+rectHelper.Width();
		}
		else
		{
			rectText.top+=(gripper.Height()-rectHelper.Height())/2+
				(gripper.Height()-rectHelper.Height())%2;
			rectText.bottom=rectText.top+rectHelper.Height();
		}

		if(!bHorz)
		{
			rectText.bottom=gripper.bottom-ID_TEXT_OFFSET;
			rectText.top=rectText.bottom-rectHelper.Height();
		}
		else
		{
			rectText.left=rectText.left;
			rectText.right=rectText.left+rectHelper.Width();
		}

		rectHelper=rectText;
		if(!bHorz)
		{
			rectHelper.bottom+=rectText.Width();
			rectHelper.right+=rectText.Height();
		}

		int nOldBkMode=0;
		if(pSizeControlBar->IsSolidGripper())
		{
			nOldBkMode=pDC->SetBkMode(TRANSPARENT);
		}
		// draw text
		pDC->DrawText(sBarTitle,&rectHelper,
			DT_BOTTOM|DT_LEFT|DT_SINGLELINE|DT_END_ELLIPSIS);
		if(pSizeControlBar->IsSolidGripper())
		{
			pDC->SetBkMode(nOldBkMode);
		}

		pDC->SetTextColor(oldColor);
		if(pOldFont!=NULL)
		{
			pDC->SelectObject(pOldFont);
		}
	}


	if(!pSizeControlBar->IsSolidGripper())
	{
		// paint the gripper

		CPen pen;
		pen.CreatePen(PS_SOLID, 1, m_pSkinXP->GetGripperColor());
		CPen* pOldPen = pDC->SelectObject(&pen);

		if(!bHorz) 
		{
			if(!rectText.IsRectEmpty())
			{
				gripper.bottom=rectText.top-ID_TEXTGRIPPER_MARGIN;
			}
			
			// gripper at left
			if(gripper.bottom>gripper.top && gripper.Height()>=ID_GRIPPER_MINSIZE)
			{
				gripper.left += 3;
				gripper.bottom -= 1;
				for (int i = 0; i < 4; i++)
				{
					pDC->MoveTo(gripper.left + i * 2, gripper.top);
					pDC->LineTo(gripper.left + i * 2, gripper.bottom);
				}
			}
		}
		else 
		{
			if(!rectText.IsRectEmpty())
			{
				gripper.left=rectText.right+ID_TEXTGRIPPER_MARGIN;
			}

			// gripper at top
			if(gripper.right>gripper.left && gripper.Width()>=ID_GRIPPER_MINSIZE)
			{
				gripper.top += 3;
				gripper.right -= 1;
				for (int i = 0; i < 4; i++)
				{
					pDC->MoveTo(gripper.left, gripper.top + i * 2);
					pDC->LineTo(gripper.right, gripper.top + i * 2);
				}
			}
		}

		pDC->SelectObject(pOldPen);
	}
}

void COXDockbarSkinXP::DrawCloseButton(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsCloseBtn() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
		return;

	// Determine the button rectangle
    CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CRect rect = pSizeControlBar->m_rectCloseBtn;
	rect.OffsetRect(-rectWindow.left, -rectWindow.top);
	rect.InflateRect(1, 1, 2, 2);

	if (pSizeControlBar->IsSolidGripper())
		m_pSkinXP->DrawFrameButton(pDC, rect, DFCS_CAPTIONCLOSE, FALSE, TRUE,
			::GetSysColor(COLOR_INACTIVECAPTION), pSizeControlBar);
	else
		m_pSkinXP->DrawFrameButton(pDC, rect, DFCS_CAPTIONCLOSE, FALSE, FALSE,
			::GetSysColor(COLOR_3DFACE), pSizeControlBar);
}

void COXDockbarSkinXP::DrawResizeButton(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsCloseBtn() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
		return;

	// Determine the button rectangle
    CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CRect rect = pSizeControlBar->m_rectResizeBtn;
	rect.OffsetRect(-rectWindow.left, -rectWindow.top);
	rect.InflateRect(1, 1, 2, 2);

	// Determine the flags
	UINT nState = pSizeControlBar->m_bMaximized ? DFCS_CAPTIONMIN : DFCS_CAPTIONMAX;
	BOOL bDisabled = !pSizeControlBar->CanResize();

	if (pSizeControlBar->IsSolidGripper())
		m_pSkinXP->DrawFrameButton(pDC, rect, nState, bDisabled, TRUE,
			::GetSysColor(COLOR_INACTIVECAPTION), pSizeControlBar);
	else
		m_pSkinXP->DrawFrameButton(pDC, rect, nState, bDisabled, FALSE,
			::GetSysColor(COLOR_3DFACE), pSizeControlBar);
}

void COXDockbarSkinXP::DrawNonClientArea(CDC* pDC, LPCRECT lpRect, COXSizeControlBar* /*pSizeControlBar*/)
{
	pDC->FillSolidRect(lpRect, ::GetSysColor(COLOR_3DFACE));
}

void COXDockbarSkinXP::DrawSplitter(CDC* pDC, COXSplitterRect* pSplitterRect, COXSizeDockBar* /*pSizeDockBar*/)
{
    CRect rect(pSplitterRect->m_rect);

	if (rect.bottom > 8000)
		rect.bottom = 8000;

	pDC->FillSolidRect(rect, ::GetSysColor(COLOR_3DFACE));
	
	if (pSplitterRect->m_type == SPLITTER_VERT)
	{
		rect.left = pSplitterRect->m_rect.CenterPoint().x;
		rect.right = rect.left + 1;
	}
	else
	{
		rect.top = pSplitterRect->m_rect.CenterPoint().y;
		rect.bottom = rect.top + 1;
	}

	pDC->FillSolidRect(rect, m_pSkinXP->GetSeparatorColor());
}

COLORREF COXDockbarSkinXP::GetClientBorderColor()
{
	return m_pSkinXP->GetBorderColor();
}

void COXDockbarSkinXP::OnNcPaintSizeDockBar(COXSizeDockBar* pSizeDockBar)
{
	CWindowDC dc(pSizeDockBar);
	CRect rectWindow;
	pSizeDockBar->GetWindowRect(rectWindow);
	CPoint ptOffset = rectWindow.TopLeft();
	rectWindow.OffsetRect(-ptOffset.x, -ptOffset.y);

	// Get the client rectangle in window coordionates
	CRect rectClient;
	pSizeDockBar->GetClientRect(rectClient);
	pSizeDockBar->ClientToScreen(rectClient);
	rectClient.OffsetRect(-ptOffset.x, -ptOffset.y);
	dc.ExcludeClipRect(rectClient);

	dc.FillSolidRect(rectWindow, m_pSkinXP->GetDockbarBackgroundColor());
}

void COXDockbarSkinXP::OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS* lpncsp, COXSizeControlBar* pSizeControlBar)
{
	CRect rect=lpncsp->rgrc[0];
	rect.DeflateRect(ID_CONTAINER_GAP, ID_CONTAINER_GAP);

	if(pSizeControlBar->IsGripper() && !(pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		if(pSizeControlBar->m_dwStyle&CBRS_ORIENT_HORZ) 
		{
			rect.DeflateRect(ID_CONTAINER_GAP,0,0,0);
			rect.left+=ID_BUTTON_SIDE;
			if(rect.left>rect.right)
			{
				rect.left=rect.right;
			}
		} 
		else 
		{
			rect.DeflateRect(0,ID_CONTAINER_GAP,0,0);
			rect.top+=ID_BUTTON_SIDE;
			if(rect.top>rect.bottom)
			{
				rect.top=rect.bottom;
			}
		}
		pSizeControlBar->m_bDelayRecalcLayout=TRUE;
	}

	lpncsp->rgrc[0]=rect;
}

void COXDockbarSkinXP::RecalcLayout(COXSizeControlBar* pSizeControlBar)
{
	CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	rectWindow.DeflateRect(ID_CONTAINER_GAP, ID_CONTAINER_GAP);
	pSizeControlBar->m_rectGripper=rectWindow;
    
	if(pSizeControlBar->IsGripper() && !(pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		if(pSizeControlBar->m_dwStyle&CBRS_ORIENT_HORZ) 
		{
			pSizeControlBar->m_rectGripper.right=pSizeControlBar->m_rectGripper.left+ID_BUTTON_SIDE;
			
			if(pSizeControlBar->IsCloseBtn())
			{
				pSizeControlBar->m_rectCloseBtn=pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectCloseBtn.bottom=pSizeControlBar->m_rectCloseBtn.top+ID_BUTTON_SIDE;
				pSizeControlBar->m_rectGripper.top+=ID_BUTTON_SIDE+GetControlBarConstants().iButtonGap;
			}

			if(pSizeControlBar->IsResizeBtn())
			{
				pSizeControlBar->m_rectResizeBtn=pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectResizeBtn.bottom=pSizeControlBar->m_rectResizeBtn.top+ID_BUTTON_SIDE;
				pSizeControlBar->m_rectGripper.top+=ID_BUTTON_SIDE+GetControlBarConstants().iButtonGap;
			}
		} 
		else 
		{
			pSizeControlBar->m_rectGripper.bottom=pSizeControlBar->m_rectGripper.top+ID_BUTTON_SIDE;
			
			if(pSizeControlBar->IsCloseBtn())
			{
				pSizeControlBar->m_rectCloseBtn=pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectCloseBtn.left=pSizeControlBar->m_rectCloseBtn.right-ID_BUTTON_SIDE;
				pSizeControlBar->m_rectGripper.right-=ID_BUTTON_SIDE+GetControlBarConstants().iButtonGap;
			}

			if(pSizeControlBar->IsResizeBtn())
			{
				pSizeControlBar->m_rectResizeBtn=pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectResizeBtn.left=pSizeControlBar->m_rectResizeBtn.right-ID_BUTTON_SIDE;
				pSizeControlBar->m_rectGripper.right-=ID_BUTTON_SIDE+GetControlBarConstants().iButtonGap;
			}
		}
	}

	pSizeControlBar->m_bDelayRecalcLayout=FALSE;
}

// COXDockbarSkin2003
//

COXDockbarSkin2003::COXDockbarSkin2003(COXSkin2003* pSkin2003) :
	COXDockbarSkinXP(pSkin2003)
{
}

COXDockbarSkin2003::~COXDockbarSkin2003()
{
}

void COXDockbarSkin2003::DrawBackground(CDC* pDC, COXSizeDockBar* pSizeDockBar)
{
	CRect rectClient;
	pSizeDockBar->GetClientRect(rectClient);

	int iWidth = ::GetSystemMetrics(SM_CXSCREEN);
	if (iWidth < rectClient.Width())
		iWidth = rectClient.Width();
	
	rectClient.right = rectClient.left + iWidth;

	CRect rectSolid(rectClient);
	rectClient.right = rectClient.CenterPoint().x;
	rectSolid.left = rectClient.right;

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	pSkin2003->GradientFill(pDC, rectClient,
		pSkin2003->GetDockbarLeftColor(),
		pSkin2003->GetDockbarRightColor(),
		GRADIENT_FILL_RECT_H);
	pDC->FillSolidRect(rectSolid, pSkin2003->GetDockbarRightColor());
}

void COXDockbarSkin2003::OnNcCalcSize(BOOL /*bCalcValidRects*/, NCCALCSIZE_PARAMS* lpncsp, COXSizeControlBar* pSizeControlBar)
{
	CRect rect=lpncsp->rgrc[0];
	rect.DeflateRect(ID_CONTAINER_GAP, ID_CONTAINER_GAP);

	if(pSizeControlBar->IsGripper() && !(pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		if(pSizeControlBar->m_dwStyle&CBRS_ORIENT_HORZ) 
		{
			rect.DeflateRect(ID_O11_GRIPPER + ID_BUTTON_SIDE,0,0,0);
			if(rect.left>rect.right)
			{
				rect.left=rect.right;
			}
		} 
		else 
		{
			rect.DeflateRect(0,ID_O11_GRIPPER + ID_BUTTON_SIDE,0,0);
			if(rect.top>rect.bottom)
			{
				rect.top=rect.bottom;
			}
		}
		pSizeControlBar->m_bDelayRecalcLayout=TRUE;
	}

	lpncsp->rgrc[0]=rect;
}

void COXDockbarSkin2003::DrawNonClientArea(CDC* pDC, LPCRECT lpRect, COXSizeControlBar* /*pSizeControlBar*/)
{
	pDC->FillSolidRect(lpRect, m_pSkinXP->GetDockbarBackgroundColor());
}

void COXDockbarSkin2003::DrawGripper(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsGripper() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		return;
	}

    CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CPoint ptOffset(-rectWindow.left, -rectWindow.top);
	rectWindow.OffsetRect(ptOffset);

	CRect rectGripper;
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	if (pSizeControlBar->m_dwStyle & CBRS_ORIENT_HORZ)
	{
		rectGripper = pSizeControlBar->m_rectGripper;
		rectGripper.OffsetRect(ptOffset);

		if (::GetVersion() >= 0x80000000)
			// Adoid a problem with the ::GradientFill() API in Win98 and ME
			pSkin2003->GradientFillManual(pDC, rectGripper,
				pSkin2003->GetControlBarLightColor(),
				pSkin2003->GetControlBarDarkColor(),
				GRADIENT_FILL_RECT_H);
		else
			pSkin2003->GradientFill(pDC, rectGripper,
				pSkin2003->GetControlBarLightColor(),
				pSkin2003->GetControlBarDarkColor(),
				GRADIENT_FILL_RECT_H);

		// If this is not the leftmost griper gover the top portion of it
		CRect rectThis;
		pSizeControlBar->GetWindowRect(rectThis);
		pSizeControlBar->m_pDockBar->ScreenToClient(&rectThis);
		if (rectThis.left > 0)
		{
			CRect rectSolid(rectGripper);
			rectSolid.right = rectSolid.left + 2;
			pDC->FillSolidRect(rectSolid, pSkin2003->GetDockbarBackgroundColor());
		}

		// Draw the stripes
		CRect rectStripes(rectGripper);
		rectStripes.DeflateRect(5, 5);
		rectStripes.top = rectStripes.bottom - 2;
		pSkin2003->DrawGripperStripes(pDC, rectStripes, FALSE);

		// Draw the text

		// Setup a font for vertically oriented mode
		LOGFONT lf;
		VERIFY(m_fontCaption.GetLogFont(&lf));
		lf.lfEscapement = 900;
		lf.lfOrientation = 900;
		CFont fontVert;
		VERIFY(fontVert.CreateFontIndirect(&lf));
		CFont* pOldFont = pDC->SelectObject(&fontVert);

		CString strBarTitle;
		pSizeControlBar->GetWindowText(strBarTitle);
		CRect rectText(rectGripper);

		rectText.left = 6;
		rectText.top = 0;
		rectText.right = rectGripper.Height();
		rectText.bottom = rectGripper.bottom + 2;

		// Crop the text if there are buttons
		CRect rectButton(0, 0, 0, 0);
		if (pSizeControlBar->IsResizeBtn())
			rectButton = pSizeControlBar->m_rectResizeBtn;
		else if (pSizeControlBar->IsCloseBtn())
			rectButton = pSizeControlBar->m_rectCloseBtn;
		if (!rectButton.IsRectEmpty())
		{
			rectButton.OffsetRect(ptOffset);
			rectText.top = rectButton.bottom + 1;
		}

		int iOldBkMode = pDC->SetBkMode(TRANSPARENT);
		pDC->DrawText(strBarTitle, &rectText,
			DT_LEFT|DT_BOTTOM|DT_SINGLELINE|DT_END_ELLIPSIS);
		pDC->SetBkMode(iOldBkMode);
		pDC->SelectObject(pOldFont);
	}
	else // vertical
	{
		rectGripper = pSizeControlBar->m_rectGripper;
		rectGripper.OffsetRect(ptOffset);

		if (::GetVersion() >= 0x80000000)
			// Adoid a problem with the ::GradientFill() API in Win98 and ME
			pSkin2003->GradientFillManual(pDC, rectGripper,
				pSkin2003->GetControlBarLightColor(),
				pSkin2003->GetControlBarDarkColor(),
				GRADIENT_FILL_RECT_V);
		else
			pSkin2003->GradientFill(pDC, rectGripper,
				pSkin2003->GetControlBarLightColor(),
				pSkin2003->GetControlBarDarkColor(),
				GRADIENT_FILL_RECT_V);

		// If this is not the topmost griper gover the top portion of it
		CRect rectThis;
		pSizeControlBar->GetWindowRect(rectThis);
		pSizeControlBar->m_pDockBar->ScreenToClient(&rectThis);
		if (rectThis.top > 0)
		{
			CRect rectSolid(rectGripper);
			rectSolid.bottom = rectSolid.top + 2;
			pDC->FillSolidRect(rectSolid, pSkin2003->GetDockbarBackgroundColor());
		}

		// Draw the stripes
		CRect rectStripes(rectGripper);
		rectStripes.DeflateRect(3, 6);
		rectStripes.right = rectStripes.left + 2;
		pSkin2003->DrawGripperStripes(pDC, rectStripes, TRUE);

		// Draw the text
		CFont* pOldFont = pDC->SelectObject(&m_fontCaption);
		CString strBarTitle;
		pSizeControlBar->GetWindowText(strBarTitle);
		CRect rectText(rectGripper);
		rectText.OffsetRect(13, 2);

		// Crop the text if there are buttons
		CRect rectButton(0, 0, 0, 0);
		if (pSizeControlBar->IsResizeBtn())
			rectButton = pSizeControlBar->m_rectResizeBtn;
		else if (pSizeControlBar->IsCloseBtn())
			rectButton = pSizeControlBar->m_rectCloseBtn;
		if (!rectButton.IsRectEmpty())
		{
			rectButton.OffsetRect(ptOffset);
			rectText.right = rectButton.left - 1;			
		}

		int iOldBkMode = pDC->SetBkMode(TRANSPARENT);
		pDC->DrawText(strBarTitle, &rectText,
			DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS);
		pDC->SetBkMode(iOldBkMode);
		pDC->SelectObject(pOldFont);
	}
}

void COXDockbarSkin2003::DrawSplitter(CDC* pDC, COXSplitterRect* pSplitterRect, COXSizeDockBar* pSizeDockBar)
{
    CRect rect(pSplitterRect->m_rect);

	CRect rectDockBar;
	pSizeDockBar->GetClientRect(rectDockBar);

	if (rect.bottom > 8000)
		rect.bottom = 8000;

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	pDC->FillSolidRect(rect, pSkin2003->GetDockbarBackgroundColor());

	if (pSplitterRect->m_type == SPLITTER_VERT)
	{
		rect.left = pSplitterRect->m_rect.CenterPoint().x;
		rect.right = rect.left + 1;
	}
	else
	{
		rect.top = pSplitterRect->m_rect.CenterPoint().y;
		rect.bottom = rect.top + 1;
	}

	pDC->FillSolidRect(rect, pSkin2003->GetSplitterLineColor());

}

void COXDockbarSkin2003::DrawCloseButton(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsCloseBtn() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
		return;

	// Determine the button rectangle
    CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CRect rect = pSizeControlBar->m_rectCloseBtn;
	rect.OffsetRect(-rectWindow.left, -rectWindow.top);
	rect.InflateRect(1, 1, 2, 2);

	m_pSkinXP->DrawFrameButton(pDC, rect, DFCS_CAPTIONCLOSE, FALSE, FALSE,
		::GetSysColor(COLOR_3DFACE), pSizeControlBar);
}

void COXDockbarSkin2003::DrawResizeButton(CDC* pDC, COXSizeControlBar* pSizeControlBar)
{
    if(!pSizeControlBar->IsCloseBtn() || (pSizeControlBar->m_dwStyle & CBRS_FLOATING))
		return;

	// Determine the button rectangle
    CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	CRect rect = pSizeControlBar->m_rectResizeBtn;
	rect.OffsetRect(-rectWindow.left, -rectWindow.top);
	rect.InflateRect(1, 1, 2, 2);

	// Determine the flags
	UINT nState = pSizeControlBar->m_bMaximized ? DFCS_CAPTIONMIN : DFCS_CAPTIONMAX;
	BOOL bDisabled = !pSizeControlBar->CanResize();

	m_pSkinXP->DrawFrameButton(pDC, rect, nState, bDisabled, FALSE,
		::GetSysColor(COLOR_3DFACE), pSizeControlBar);
}

void COXDockbarSkin2003::RecalcLayout(COXSizeControlBar* pSizeControlBar)
{
	CRect rectWindow;
	pSizeControlBar->GetWindowRect(rectWindow);
	pSizeControlBar->ScreenToClient(rectWindow);
	pSizeControlBar->m_rectGripper = rectWindow;

	if(pSizeControlBar->IsGripper() && !(pSizeControlBar->m_dwStyle & CBRS_FLOATING))
	{
		if (pSizeControlBar->m_dwStyle & CBRS_ORIENT_HORZ) 
		{
			pSizeControlBar->m_rectGripper.DeflateRect(0, 2);

			pSizeControlBar->m_rectGripper.right = 
				pSizeControlBar->m_rectGripper.left + ID_O11_GRIPPER + ID_BUTTON_SIDE;
			
			if(pSizeControlBar->IsCloseBtn())
			{
				pSizeControlBar->m_rectCloseBtn = pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectCloseBtn.bottom = pSizeControlBar->m_rectCloseBtn.top + pSizeControlBar->m_rectCloseBtn.Width();
				pSizeControlBar->m_rectCloseBtn.DeflateRect(7, 7, 6, 6);
			}

			if(pSizeControlBar->IsResizeBtn())
			{
				pSizeControlBar->m_rectResizeBtn = pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectResizeBtn.bottom = pSizeControlBar->m_rectResizeBtn.top + pSizeControlBar->m_rectResizeBtn.Width();
				pSizeControlBar->m_rectResizeBtn.DeflateRect(7, 7, 6, 6);
				if (pSizeControlBar->IsCloseBtn())
					pSizeControlBar->m_rectResizeBtn.OffsetRect(0, pSizeControlBar->m_rectResizeBtn.Width() + 3);
			}
		} 
		else // vertical
		{
			pSizeControlBar->m_rectGripper.DeflateRect(2, 0);

			pSizeControlBar->m_rectGripper.bottom = 
				pSizeControlBar->m_rectGripper.top + ID_O11_GRIPPER + ID_BUTTON_SIDE;

			if (pSizeControlBar->IsCloseBtn())
			{
				pSizeControlBar->m_rectCloseBtn = pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectCloseBtn.left = pSizeControlBar->m_rectCloseBtn.right - pSizeControlBar->m_rectCloseBtn.Height();
				pSizeControlBar->m_rectCloseBtn.DeflateRect(7, 7, 6, 6);
			}

			if (pSizeControlBar->IsResizeBtn())
			{
				pSizeControlBar->m_rectResizeBtn = pSizeControlBar->m_rectGripper;
				pSizeControlBar->m_rectResizeBtn.left = pSizeControlBar->m_rectResizeBtn.right - pSizeControlBar->m_rectResizeBtn.Height();
				pSizeControlBar->m_rectResizeBtn.DeflateRect(7, 7, 6, 6);
				if (pSizeControlBar->IsCloseBtn())
					pSizeControlBar->m_rectResizeBtn.OffsetRect(-pSizeControlBar->m_rectResizeBtn.Width() - 3, 0);
			}
		}
	}

	pSizeControlBar->m_bDelayRecalcLayout=FALSE;
}

void COXDockbarSkin2003::OnNcPaintSizeDockBar(COXSizeDockBar* pSizeDockBar)
{
	CWindowDC dc(pSizeDockBar);
	CRect rectWindow;
	pSizeDockBar->GetWindowRect(rectWindow);
	CPoint ptOffset = rectWindow.TopLeft();
	rectWindow.OffsetRect(-ptOffset.x, -ptOffset.y);

	// Get the client rectangle in window coordionates
	CRect rectClient;
	pSizeDockBar->GetClientRect(rectClient);
	pSizeDockBar->ClientToScreen(rectClient);
	rectClient.OffsetRect(-ptOffset.x, -ptOffset.y);
	dc.ExcludeClipRect(rectClient);

	CRect rectMain;
	pSizeDockBar->GetParentFrame()->GetWindowRect(rectMain);

	// Get the dockbar screen rectangle
	CRect rectDockbar;
	pSizeDockBar->GetWindowRect(rectDockbar);

	int iWidth = ::GetSystemMetrics(SM_CXSCREEN);
	if (iWidth < rectMain.Width())
		iWidth = rectMain.Width();

	CRect rectGradient;
	rectGradient.left = rectMain.left - rectDockbar.left;
	rectGradient.right = rectGradient.left + iWidth;
	rectGradient.top = 0;
	rectGradient.bottom = rectDockbar.Height();

	if (pSizeDockBar->GetFirstDockedSizeControlBar(NULL) != NULL)
	{
		dc.FillSolidRect(rectGradient, m_pSkinXP->GetDockbarBackgroundColor());
	}
	else
	{
		CRect rectSolid(rectGradient);
		rectGradient.right = rectGradient.CenterPoint().x;
		rectSolid.left = rectGradient.right;

		COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
		pSkin2003->GradientFill(&dc, rectGradient,
			pSkin2003->GetDockbarLeftColor(),
			pSkin2003->GetDockbarRightColor(),
			GRADIENT_FILL_RECT_H);
		dc.FillSolidRect(rectSolid, pSkin2003->GetDockbarRightColor());
	}
}


// COXStatusbarSkin
//


// COXStatusbarSkinClassic
//

void COXStatusbarSkinClassic::OnPaintStatusbar( COXStatusBar* pStatusBar )
{
	pStatusBar->Default();

	CClientDC DC(pStatusBar);
	pStatusBar->UpdateAllPanes(FALSE, TRUE);

	// Draw the text for each pane, and the window resize gripper
	DrawStatusBarPanes(&DC, pStatusBar );
	DrawFlatPanes(&DC, pStatusBar);

	for (int i=0; i < pStatusBar->GetCount(); i++)
	{
		AFX_STATUSPANE* pSBP=pStatusBar->_GetPanePtr(i);
		ASSERT(pSBP!=NULL);

		if (!(pSBP->nStyle & SBPS_DISABLED))
		{
			COXStatusBar::CBmpInfo* info=(COXStatusBar::CBmpInfo*)pStatusBar->m_PaneBmp[i];
			if(info != NULL)
				// This pane is a pane with a bitmap, so draw the bitmap
				pStatusBar->DrawStatusBmp(&DC, i, pSBP->nStyle);
		}
	}
}

// COXStatusbarSkinXP
//

COXStatusbarSkinXP::COXStatusbarSkinXP(COXSkinXP* pSkinXP)
{
	m_pSkinXP = pSkinXP;
}

COXStatusbarSkinXP::~COXStatusbarSkinXP()
{
}

void COXStatusbarSkinXP::OnPaintStatusbar( COXStatusBar* pStatusBar )
{
	CPaintDC DC(pStatusBar);
	pStatusBar->UpdateAllPanes(FALSE, TRUE);

	// Draw the text for each pane, and the window resize gripper
	DrawStatusBarPanes(&DC, pStatusBar);
	DrawFlatPanes(&DC, pStatusBar);
	DrawGripper(&DC, pStatusBar);

	for (int i=0; i < pStatusBar->GetCount(); i++)
	{
		AFX_STATUSPANE* pSBP=pStatusBar->_GetPanePtr(i);
		ASSERT(pSBP!=NULL);

		if (!(pSBP->nStyle & SBPS_DISABLED))
		{
			COXStatusBar::CBmpInfo* info=(COXStatusBar::CBmpInfo*)pStatusBar->m_PaneBmp[i];
			if(info != NULL)
				// This pane is a pane with a bitmap, so draw the bitmap
				pStatusBar->DrawStatusBmp(&DC, i, pSBP->nStyle);
		}
	}
}

void COXStatusbarSkinXP::DrawStatusBarPanes(CDC* pDC, COXStatusBar* pStatusBar)
{
	// Draw the background of the entire status bar
	CRect rectClient;
	pStatusBar->GetClientRect(rectClient);
	pDC->FillSolidRect(rectClient, GetSysColor(COLOR_BTNFACE));

	DRAWITEMSTRUCT drawItemStruct;
	CRect rcItem;
	int cxWidth;
	UINT nID, nStyle;
	BYTE keyState[256];
	::GetKeyboardState( keyState );

	drawItemStruct.hDC = pDC->GetSafeHdc();

    for (int nIndex = 0; nIndex < pStatusBar->m_nCount; nIndex++)
    {
		pStatusBar->GetItemRect( nIndex, rcItem );
		pStatusBar->GetPaneInfo( nIndex, nID, nStyle, cxWidth );
		
		if (nIndex == pStatusBar->m_nCount - 1)
			rcItem.right = rcItem.left + cxWidth + 6;

		// prepare the background for each item on the statusbar
		switch( nID )
		{
		case ID_INDICATOR_CAPS:
			DrawPaneText( pDC, rcItem, pStatusBar, nIndex, keyState[VK_CAPITAL] & 1 );
			break;
		case ID_INDICATOR_NUM:
			DrawPaneText( pDC, rcItem, pStatusBar, nIndex, keyState[VK_NUMLOCK] & 1 );
			break;
		case ID_INDICATOR_SCRL:
			DrawPaneText( pDC, rcItem, pStatusBar, nIndex, keyState[VK_SCROLL] & 1 );
			break;
		default:
			// draw custom panes
			drawItemStruct.itemID = nIndex;
			drawItemStruct.rcItem = rcItem;
			pStatusBar->DrawItem( &drawItemStruct );
		}
	}
}

void COXStatusbarSkinXP::DrawPaneText( CDC *pDc, CRect rPane, COXStatusBar* pStatusBar, int nIndex, BOOL enabled )
{
	CFont *oldFont = pDc->SelectObject( pStatusBar->GetFont());

	if ( enabled == TRUE )
		pDc->SetTextColor( GetSysColor( COLOR_BTNTEXT ));
	else
		pDc->SetTextColor(m_pSkinXP->GetDisabledTextColor());

	pDc->SetBkMode( TRANSPARENT );
	pDc->DrawText( pStatusBar->GetPaneText( nIndex ), rPane, DT_CENTER|DT_VCENTER|DT_SINGLELINE );

	pDc->SelectObject( oldFont );
}

void COXStatusbarSkinXP::DrawFlatPanes(CDC* pDC, COXStatusBar* pStatusBar)
{
	CRect rcItem;
	CBrush brush;
	brush.CreateSolidBrush(m_pSkinXP->GetStatusPaneColor());
    for (int i = 0; i < pStatusBar->m_nCount; i++)
    {
		pStatusBar->GetItemRect(i, rcItem);
		if (i == pStatusBar->m_nCount - 1)
		{
			int cxWidth;
			UINT nID, nStyle;
			pStatusBar->GetPaneInfo(i, nID, nStyle, cxWidth );
			rcItem.right = rcItem.left + cxWidth + 6;
		}
		pDC->FrameRect(rcItem, &brush);
	}
}

void COXStatusbarSkinXP::DrawGripper(CDC* pDC, COXStatusBar* pStatusBar)
{
	CFrameWnd* pParentFrame = pStatusBar->GetParentFrame();
	if (pParentFrame != NULL && (pParentFrame->GetStyle() & WS_THICKFRAME) == 0)
		return; // we don't need a gripper since the thick frame style is not set
	
	if (pParentFrame != NULL && (pParentFrame->GetStyle() & WS_MAXIMIZE) != 0)
		return; // we don't need a gripper since the frame is maximized

	CRect rClient;
	pStatusBar->GetClientRect( rClient );
	int nSize = rClient.Height()%2 ? rClient.Height() - 1 : rClient.Height();
	// calculate the gripper area
	rClient.left = rClient.right - nSize;

	pDC->FillSolidRect(rClient, GetSysColor(COLOR_BTNFACE));

	// create the gray pen
	CPen grayPen( PS_SOLID, 1, GetSysColor( COLOR_3DSHADOW ));
	CPen *oldPen = NULL;
	
	for ( int nIndex = 0; nIndex < nSize; nIndex += 3 )
	{
		oldPen = pDC->SelectObject( &grayPen );
		pDC->MoveTo( rClient.right - nIndex, rClient.bottom );
		pDC->LineTo( rClient.right, rClient.bottom - nIndex );

		nIndex ++;
		pDC->SelectObject( oldPen );
		(CPen*)pDC->SelectObject( ::GetStockObject( WHITE_PEN ));
		pDC->MoveTo( rClient.right - nIndex, rClient.bottom );
		pDC->LineTo( rClient.right, rClient.bottom - nIndex );

		oldPen = NULL;
	}
}

// COXStatusbarSkin2003
//

COXStatusbarSkin2003::COXStatusbarSkin2003(COXSkin2003* pSkin2003) :
	COXStatusbarSkinXP(pSkin2003)
{
}

COXStatusbarSkin2003::~COXStatusbarSkin2003()
{
}

void COXStatusbarSkin2003::DrawGradientBackground(CDC* pDC, LPCRECT lpRect)
{
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	CRect rectTop(lpRect);
	rectTop.bottom = rectTop.top + 3;
	pSkin2003->GradientFill(pDC, rectTop,
		pSkin2003->GetStatusbarTopColor(),
		pSkin2003->GetStatusbarMiddleColor(),
		GRADIENT_FILL_RECT_V);

	CRect rectBottom(lpRect);
	rectBottom.top = rectBottom.bottom - 5;
	pSkin2003->GradientFill(pDC, rectBottom,
		pSkin2003->GetStatusbarMiddleColor(),
		pSkin2003->GetStatusbarBottomColor(),
		GRADIENT_FILL_RECT_V);

	CRect rectMiddle(lpRect);
	rectMiddle.top = rectTop.bottom;
	rectMiddle.bottom = rectBottom.top;
	pDC->FillSolidRect(rectMiddle, pSkin2003->GetStatusbarMiddleColor());
}

void COXStatusbarSkin2003::DrawStatusBarPanes(CDC* pDC, COXStatusBar* pStatusBar)
{
	// Draw the background of the entire status bar
	CRect rectClient;
	pStatusBar->GetClientRect(rectClient);

	DrawGradientBackground(pDC, rectClient);

	DRAWITEMSTRUCT drawItemStruct;
	CRect rcItem;
	int cxWidth;
	UINT nID, nStyle;
	BYTE keyState[256];
	::GetKeyboardState( keyState );

	drawItemStruct.hDC = pDC->GetSafeHdc();

    for (int nIndex = 0; nIndex < pStatusBar->m_nCount; nIndex++)
    {
		pStatusBar->GetItemRect( nIndex, rcItem );
		pStatusBar->GetPaneInfo( nIndex, nID, nStyle, cxWidth );
		
		if (nIndex == pStatusBar->m_nCount - 1)
			rcItem.right = rcItem.left + cxWidth + 6;

		// prepare the background for each item on the statusbar
		switch( nID )
		{
		case ID_INDICATOR_CAPS:
			DrawPaneText( pDC, rcItem, pStatusBar, nIndex, keyState[VK_CAPITAL] & 1 );
			break;
		case ID_INDICATOR_NUM:
			DrawPaneText( pDC, rcItem, pStatusBar, nIndex, keyState[VK_NUMLOCK] & 1 );
			break;
		case ID_INDICATOR_SCRL:
			DrawPaneText( pDC, rcItem, pStatusBar, nIndex, keyState[VK_SCROLL] & 1 );
			break;
		default:
			// draw custom panes
			drawItemStruct.itemID = nIndex;
			drawItemStruct.rcItem = rcItem;
			pStatusBar->DrawItem( &drawItemStruct );
		}
	}
}

void COXStatusbarSkin2003::DrawGripper(CDC* pDC, COXStatusBar* pStatusBar)
{
	CFrameWnd* pParentFrame = pStatusBar->GetParentFrame();
	if (pParentFrame != NULL && (pParentFrame->GetStyle() & WS_THICKFRAME) == 0)
		return; // we don't need a gripper since the thick frame style is not set
	
	if (pParentFrame != NULL && (pParentFrame->GetStyle() & WS_MAXIMIZE) != 0)
		return; // we don't need a gripper since the frame is maximized

	CRect rClient;
	pStatusBar->GetClientRect( rClient );
	int nSize = rClient.Height()%2 ? rClient.Height() - 1 : rClient.Height();
	// calculate the gripper area
	rClient.left = rClient.right - nSize;

	CRect rectBackground(rClient);
	rectBackground.left += 3;
	DrawGradientBackground(pDC, rectBackground);

	// Draw the gripper
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			// Do not draw the top half
			if (i + j < 2)
				continue;

			CRect rectDot;
			rectDot.left = rClient.left + 7 + i * 4;
			rectDot.top = rClient.top + 7 + j * 4;
			rectDot.right = rectDot.left + 2;
			rectDot.bottom = rectDot.top + 2;

			pDC->FillSolidRect(rectDot,  pSkin2003->GetGripperStripesShadowColor());
			rectDot.OffsetRect(-1, -1);
			pDC->FillSolidRect(rectDot, pSkin2003->GetGripperColor());
		}
	}
}

void COXStatusbarSkin2003::DrawFlatPanes(CDC* pDC, COXStatusBar* pStatusBar)
{
	CRect rcItem;
    for (int i = 0; i < pStatusBar->m_nCount; i++)
    {
		pStatusBar->GetItemRect(i, rcItem);
		if (i == pStatusBar->m_nCount - 1)
		{
			int cxWidth;
			UINT nID, nStyle;
			pStatusBar->GetPaneInfo(i, nID, nStyle, cxWidth );
			rcItem.right = rcItem.left + cxWidth + 6;
		}

		rcItem.left = rcItem.right++;
		rcItem.DeflateRect(0, 2, 0, 2);
		pDC->FillSolidRect(rcItem,  m_pSkinXP->GetSeparatorColor());
		rcItem.OffsetRect(1, 1);
		pDC->FillSolidRect(rcItem,  RGB(255, 255, 255)); // This color is always white
	}
}

// COXFrameSkin
//


// COXFrameSkinClassic
//


// COXFrameSkinXP
//

COXFrameSkinXP::COXFrameSkinXP(COXSkinXP* pSkinXP)
{
	m_pSkinXP = pSkinXP;
}

void COXFrameSkinXP::DrawViewBorder(CView* pView)
{
	CWindowDC dc(pView);
	CRect rectWindow;
	pView->GetWindowRect(rectWindow);
	CPoint ptOffset = rectWindow.TopLeft();
	rectWindow.OffsetRect(-ptOffset.x, -ptOffset.y);

	CBrush brush;
	brush.CreateSolidBrush(m_pSkinXP->GetBorderColor());
	dc.FrameRect(rectWindow, &brush);
}

void COXFrameSkinXP::OnNcCalcSizeView(LPARAM lParam, CView* /*pView*/)
{
	NCCALCSIZE_PARAMS* lpncsp = (NCCALCSIZE_PARAMS*) lParam;
	lpncsp->rgrc[0].left -= 1;
	lpncsp->rgrc[0].top -= 1;
	lpncsp->rgrc[0].right += 1;
	lpncsp->rgrc[0].bottom += 1;
}

// COXFrameSkin2003
//

COXFrameSkin2003::COXFrameSkin2003(COXSkin2003* pSkin2003) :
	COXFrameSkinXP(pSkin2003)
{
}

COLORREF COXFrameSkin2003::GetBackgroundColor()
{
	return m_pSkinXP->GetDockbarBackgroundColor();
}

COLORREF COXFrameSkin2003::GetBorderColor()
{
	return m_pSkinXP->GetBorderColor();
}

// COXTabSkin
//


// COXTabSkinClassic
//

void COXTabSkinClassic::OnPaintTabCtrl(CTabCtrl* pTabCtrl)
{
	COXSkinnedTabCtrl* pSkinnedTab = DYNAMIC_DOWNCAST(COXSkinnedTabCtrl, pTabCtrl);
	if (pSkinnedTab != NULL)
		pSkinnedTab->Default(); 

// Code to handle vertical orientation in XP themed mode

	if( IsThemed() && (pTabCtrl->GetStyle()&TCS_VERTICAL) )
	{
		int nTabCount = pTabCtrl->GetItemCount();
		int nSel = pTabCtrl->GetCurSel();
	
		DRAWITEMSTRUCT dis;
		dis.CtlType = ODT_TAB;
		dis.CtlID = pTabCtrl->GetDlgCtrlID();
		dis.hwndItem = pTabCtrl->GetSafeHwnd();
		dis.hDC = GetDC(dis.hwndItem);
		dis.itemAction = ODA_DRAWENTIRE;

		for ( int nIndex = 0; nIndex < nTabCount; nIndex++ )
		{			
			if (nIndex != nSel)
				dis.itemState = ODS_SELECTED;
			else
				dis.itemState = 0;
			
			dis.itemID = nIndex;
			
			pTabCtrl->GetItemRect(nIndex, &dis.rcItem);	

			RECT r2 = dis.rcItem;
			int ht = r2.bottom - r2.top;

			TCHAR buf[255];
			TCITEM tabItem;
			tabItem.mask = TCIF_TEXT|TCIF_IMAGE;
			tabItem.pszText = buf;
			tabItem.cchTextMax = sizeof( buf );
			pTabCtrl->GetItem( nIndex, &tabItem );
			CString tempStr( tabItem.pszText );
			
			if ((tabItem.mask & TCIF_IMAGE) && tabItem.iImage >= 0)
			{
				CImageList* pImage = pTabCtrl->GetImageList();
				if ( pImage != NULL )
				{					
					IMAGEINFO iInfo;
					pImage->GetImageInfo( tabItem.iImage, &iInfo );						
					
					if( pTabCtrl->GetStyle()&TCS_BOTTOM )
						ht -= 10;
					else
						ht -= iInfo.rcImage.bottom - iInfo.rcImage.top + 10;
															
				}
			}

			r2.top += ht;
			r2.bottom += ht;

			NONCLIENTMETRICS nclim;
			nclim.cbSize=sizeof(NONCLIENTMETRICS);
			::SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
				sizeof(NONCLIENTMETRICS),&nclim,0);
			LOGFONT lf = nclim.lfMenuFont;			
			lf.lfEscapement = 900;			 
			HFONT hf = CreateFontIndirect(&lf);

			HFONT oldf = (HFONT)SelectObject(dis.hDC,(HGDIOBJ)hf);
			SetBkMode(dis.hDC, TRANSPARENT);
			DrawText(dis.hDC,tempStr,-1,&r2,DT_NOCLIP);
			SelectObject(dis.hDC,(HGDIOBJ)oldf);
			DeleteObject(hf);			
		}
		
		ReleaseDC(dis.hwndItem,dis.hDC);
	}

// End of custom code to handle XP themed mode and vertical orientation

};

void COXTabSkinClassic::DrawMDITabBorder(CDC* pDC, LPCRECT lpRect, COXTabWorkspace* /*pTabWorkspace*/)
{
	pDC->Draw3dRect(lpRect, ::GetSysColor(COLOR_BTNSHADOW), ::GetSysColor(COLOR_BTNHILIGHT));
}

// COXTabSkinXP
//

// predefined margin size
#define TAB_MARGIN 3

COXTabSkinXP::COXTabSkinXP(COXSkinXP* pSkinXP)
{
	m_pSkinXP = pSkinXP;

	m_sepPen.CreatePen( PS_SOLID, 1, ::GetSysColor(COLOR_3DSHADOW) );
	NONCLIENTMETRICS nclim;
	nclim.cbSize=sizeof(NONCLIENTMETRICS);
	::SystemParametersInfo(SPI_GETNONCLIENTMETRICS,
							sizeof(NONCLIENTMETRICS),
							&nclim,0);
	m_tabFont.CreateFontIndirect(&nclim.lfMenuFont);

	m_btnFill.CreateSolidBrush( m_pSkinXP->GetInactiveTabTextColor() );
	m_btnLine.CreatePen( PS_SOLID, 1, m_pSkinXP->GetInactiveTabTextColor() );
}

void COXTabSkinXP::DrawMDITabBorder(CDC* pDC, LPCRECT lpRect, COXTabWorkspace* /*pTabWorkspace*/)
{
	pDC->Draw3dRect(lpRect, m_pSkinXP->GetBorderColor(),m_pSkinXP->GetBorderColor());
}

void COXTabSkinXP::OnNcPaintTabClient(COXTabClientWnd* pTabClient)
{
	pTabClient->Default();
	
	CWindowDC dc(pTabClient);
	CRect rectWindow;
	pTabClient->GetWindowRect(rectWindow);
	CPoint ptOffset = rectWindow.TopLeft();
	rectWindow.OffsetRect(-ptOffset.x, -ptOffset.y);

	// Get the client rectangle in window coordionates
	CRect rectClient;
	pTabClient->GetClientRect(rectClient);
	pTabClient->ClientToScreen(rectClient);
	rectClient.OffsetRect(-ptOffset.x, -ptOffset.y);
	dc.ExcludeClipRect(rectClient);

	// Draw the border
	CBrush brBorder;
	brBorder.CreateSolidBrush(::GetSysColor(COLOR_3DFACE));
	dc.FrameRect(rectWindow, &brBorder);
	CBrush brBackground;
	brBackground.CreateSolidBrush(::GetSysColor(COLOR_3DDKSHADOW));
	rectWindow.DeflateRect(1, 1);
	dc.FrameRect(rectWindow, &brBackground);
}

void COXTabSkinXP::OnPaintTabCtrl(CTabCtrl* pTabCtrl)
{
	CPaintDC dc(pTabCtrl); // device context for painting
	// retrieve the client area size info
	CRect clientRect;
	pTabCtrl->GetClientRect(&clientRect);
	// create and initialize memory DC to draw on
	CDC memDc, itemMemDc;
	CBitmap bmpMem, bmpItemMem, *pOldItemMemBmp, *pOldMemBmp;
	bmpMem.CreateCompatibleBitmap( &dc, clientRect.right, clientRect.bottom );
	bmpItemMem.CreateCompatibleBitmap( &dc, clientRect.Width(), clientRect.Height());
	// create memory DC fot the entire tab control
	memDc.CreateCompatibleDC( &dc );
	pOldMemBmp = memDc.SelectObject( &bmpMem );
	// create memory DC for each item to draw on
	itemMemDc.CreateCompatibleDC( &dc );
	pOldItemMemBmp = itemMemDc.SelectObject( &bmpItemMem );

	// check if we have already subclassed the up-down control
	COXSkinnedSpinCtrl* pUpDown = GetSpinCtrl(pTabCtrl);
	if (pUpDown != NULL && pUpDown->GetSafeHwnd() == NULL )
	{
		// we have not, check if it was created by looping through all client windows
		int intnRet;
		CRect upDnRect;
		CWnd* pWnd = pTabCtrl->GetWindow(GW_CHILD);

		while(pWnd)
		{
			TCHAR buf[] = _T("msctls_updown32");
			intnRet= ::GetClassName(pWnd->m_hWnd,buf,sizeof(buf)/sizeof(buf[0]));
			if( _tcscmp(buf, _T("msctls_updown32")) != 0 )
			{
				pWnd=pWnd->GetWindow(GW_HWNDNEXT);
			}
			else
			{ 
				//The msctls_updown32 control isfound.
				//
				//Subclass common msctls_updown32 control
				pUpDown->SubclassWindow(pWnd->m_hWnd);

				pWnd=0;
			}
		}
	}

	// draw background of the entire control
	DrawBackground(&memDc, clientRect, pTabCtrl);
	
	// Draw the tab work area
	CRect rPage( clientRect );
	pTabCtrl->AdjustRect(FALSE, rPage);

	// Draw a border around the child window
	CRect rectChild;
	COX3DTabViewContainer* p3DTVC = DYNAMIC_DOWNCAST(COX3DTabViewContainer, pTabCtrl);
	if (p3DTVC != NULL)
	{
		rectChild = p3DTVC->m_rectPage;
		rectChild.InflateRect(1, 1);
	}
	else
	{
		rectChild = rPage;
		rectChild.bottom -= 1;
	}

	CBrush brushBorder;
	brushBorder.CreateSolidBrush(::GetSysColor(COLOR_3DSHADOW));
	memDc.FrameRect(rectChild, &brushBorder);
	
	// draw the solid line above the work area
	if ( pTabCtrl->GetRowCount() <= 1 )
	{
		if ( pTabCtrl->GetStyle()&TCS_BOTTOM )
		{
			// draw background for the button area
			memDc.FillSolidRect( clientRect.left, rPage.bottom + TAB_MARGIN,
							  clientRect.right, clientRect.bottom,
							  m_pSkinXP->GetTabButtonsBackgroundColor());
			// draw a separator line
			memDc.SelectObject( ::GetStockObject( BLACK_PEN ));
			memDc.MoveTo( clientRect.left, rPage.bottom + TAB_MARGIN - 1 );
			memDc.LineTo( clientRect.right, rPage.bottom + TAB_MARGIN - 1 );
		}
		else
		{
			// draw background for the button area
			memDc.FillSolidRect( clientRect.left, clientRect.top,
							  clientRect.right, rPage.top - TAB_MARGIN,
							  m_pSkinXP->GetTabButtonsBackgroundColor());
			// draw a separator line
			memDc.SelectObject( ::GetStockObject( WHITE_PEN ));
			memDc.MoveTo( clientRect.left, rPage.top - TAB_MARGIN );
			memDc.LineTo( clientRect.right, rPage.top - TAB_MARGIN );
		}
	}

	// also paint the tabs
	int nTabCount = pTabCtrl->GetItemCount();
	int nSel = pTabCtrl->GetCurSel();

	// the tab control does not contain any items
	if ( nTabCount == 0 )
	{
		memDc.SelectObject( pOldMemBmp );
		itemMemDc.SelectObject( pOldItemMemBmp );
		return;
	}

	// Draw individual tab items
	DRAWITEMSTRUCT dis;
	dis.CtlType = ODT_TAB;
	dis.CtlID = pTabCtrl->GetDlgCtrlID();
	dis.hwndItem = pTabCtrl->GetSafeHwnd();
	dis.hDC = itemMemDc.GetSafeHdc();
	dis.itemAction = ODA_DRAWENTIRE;

	for ( int nIndex = 0; nIndex < nTabCount; nIndex++ )
	{
		// initialize the draw item structure for each of the tabs
		if (nIndex != nSel)
		{
			dis.itemID = nIndex;
			dis.itemState = 0;
			pTabCtrl->GetItemRect(nIndex, &dis.rcItem);
			DrawItem(&dis, pTabCtrl);
			DrawItemBorder(&dis, pTabCtrl);

			if ( AdjustItemRect( nIndex, &dis.rcItem, pTabCtrl ))
			{
				int width = dis.rcItem.right - dis.rcItem.left;
				int height = dis.rcItem.bottom - dis.rcItem.top;
				//Copy drawing from memory device context to the screen
				memDc.BitBlt( dis.rcItem.left,dis.rcItem.top,width,
					height,&itemMemDc,dis.rcItem.left,dis.rcItem.top,SRCCOPY);
			}
		}
	}

	// draw the selected item
	dis.itemID = nSel;
	dis.itemState = ODS_SELECTED;
	pTabCtrl->GetItemRect(nSel, &dis.rcItem);
	DrawItem(&dis, pTabCtrl);
	DrawItemBorder(&dis, pTabCtrl);

	if ( AdjustItemRect( nSel, &dis.rcItem, pTabCtrl ))
	{
		int width = dis.rcItem.right - dis.rcItem.left;
		int height = dis.rcItem.bottom - dis.rcItem.top;
		//Copy drawing from memory device context to the screen
		memDc.BitBlt( dis.rcItem.left,dis.rcItem.top,width,
			height,&itemMemDc,dis.rcItem.left,dis.rcItem.top,SRCCOPY);
	}

	//Copy drawing from memory device context to the screen
	dc.BitBlt( clientRect.left, clientRect.top, clientRect.Width(),
			   clientRect.Height(), &memDc,
			   clientRect.left, clientRect.top, SRCCOPY);

	// a final clean up
	memDc.SelectObject( pOldMemBmp );
	itemMemDc.SelectObject( pOldItemMemBmp );

	// make sure that the spin control is also redrawn
	if (pUpDown != NULL && pUpDown->GetSafeHwnd() != NULL )
		if ( pUpDown->IsWindowVisible())
			pUpDown->Invalidate();
}

void COXTabSkinXP::DrawBackground(CDC* pDC, LPCRECT lpRect, CTabCtrl* /*pTabCtrl*/)
{
	pDC->FillSolidRect(lpRect, ::GetSysColor(COLOR_3DFACE));
}

void COXTabSkinXP::AdjustChildItemRect(LPRECT pRectChild, int iInflateValue, CTabCtrl* pTabCtrl)
{
	// Determine which side the tabs are on

	const int iMinMargin = 8;

	CRect rectClient;
	pTabCtrl->GetClientRect(rectClient);
	if (rectClient.IsRectEmpty())
		return;
	CRect rectItem(rectClient);
	pTabCtrl->AdjustRect(FALSE, rectItem);

	CRect rectMargins;
	rectMargins.left = rectItem.left - rectClient.left;
	rectMargins.top = rectItem.top - rectClient.top;
	rectMargins.right = rectClient.right - rectItem.right;
	rectMargins.bottom =  rectClient.bottom - rectItem.bottom;

	// Check each of the 4 sides and if we do not have buttons inflate it
	if (rectMargins.left < iMinMargin)
		pRectChild->left -= iInflateValue;
	if (rectMargins.top < iMinMargin)
		pRectChild->top -= iInflateValue;
	if (rectMargins.right < iMinMargin)
		pRectChild->right += iInflateValue;
	if (rectMargins.bottom < iMinMargin)
		pRectChild->bottom += iInflateValue;
}

void COXTabSkinXP::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct, CTabCtrl* pTabCtrl)
{
	CDC dc;
	dc.Attach( lpDrawItemStruct->hDC );
	CRect rcItem = lpDrawItemStruct->rcItem;

	if ( lpDrawItemStruct->itemState == ODS_SELECTED )
	{
		dc.FillSolidRect(&rcItem, ::GetSysColor(COLOR_3DFACE));
		dc.SetTextColor(::GetSysColor(COLOR_BTNTEXT));
	}
	else
	{
		dc.FillSolidRect(&rcItem, m_pSkinXP->GetTabButtonsBackgroundColor());
		dc.SetTextColor(m_pSkinXP->GetInactiveTabTextColor());
	}

	TCHAR buf[255];
	TCITEM tabItem;
	//Get text of item.
	tabItem.mask = TCIF_TEXT|TCIF_IMAGE;
	tabItem.pszText = buf;
	tabItem.cchTextMax = sizeof( buf );
	pTabCtrl->GetItem( lpDrawItemStruct->itemID, &tabItem );
	CString tempStr( tabItem.pszText );

	rcItem.top += 3;

	// draw the icon
	if ((tabItem.mask & TCIF_IMAGE) && tabItem.iImage >= 0)
	{
		CImageList* pImage = pTabCtrl->GetImageList();
		if ( pImage != NULL )
		{
			// get information about the icon to draw
			IMAGEINFO iInfo;
			pImage->GetImageInfo( tabItem.iImage, &iInfo );
			// calculate the statring point for the image to be drawn, try to vertically center
			CPoint ptStart( rcItem.left + 3, rcItem.top - 1 );

			pImage->Draw( &dc, tabItem.iImage, ptStart, ILD_TRANSPARENT );

			// reduce the rectangle by the size of the image
			rcItem.left += ( iInfo.rcImage.right - iInfo.rcImage.left ) + 3;
		}
	}

	// draw the tab's text
	CFont *pOldFont = dc.SelectObject( &m_tabFont );
	dc.DrawText( tempStr, &rcItem, DT_CENTER );
	dc.SelectObject( pOldFont );
	rcItem.top -= 3;

	// draw focus rectangle
	if ( lpDrawItemStruct->itemState == ODS_SELECTED &&
		 ( pTabCtrl->GetStyle()&TCS_FOCUSNEVER) == 0 )
	{
		CRect rect( rcItem );
		rect.DeflateRect( 2, 2 );
		dc.DrawFocusRect( rect );
	}

	dc.Detach();
}

void COXTabSkinXP::DrawItemBorder(LPDRAWITEMSTRUCT lpDrawItemStruct, CTabCtrl* pTabCtrl)
{
	CDC dc;
	dc.Attach( lpDrawItemStruct->hDC );

	if ( pTabCtrl->GetStyle()&TCS_BOTTOM )
	{
		if ( lpDrawItemStruct->itemState == ODS_SELECTED )
		{
			// draw the white line (on the left)
			dc.SelectObject( GetStockObject( WHITE_PEN ));
			dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
			dc.LineTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
			dc.SelectObject( GetStockObject( BLACK_PEN ));
			// draw the bottom
			dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.bottom - 1 );
			// draw the black outline on right
			dc.MoveTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.top );
			dc.LineTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.bottom - 1 );
		}
		else// draw the inactive button
		{
			if ( IsNextButtonSelected(lpDrawItemStruct->itemID, pTabCtrl) == FALSE )
			{	// draw the separators between the bottons
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.top + 3 );
				dc.LineTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.bottom - 3 );
				dc.SelectObject( pOldBrush );
			}

			// determine the position of this button in relation to the child window
			// it is important to know if the button is in the bottom or top and in which
			// row of tabs
			CRect rPage;
			pTabCtrl->GetClientRect( rPage );
			pTabCtrl->AdjustRect( FALSE, rPage );

			int nPosDifference = lpDrawItemStruct->rcItem.top - rPage.bottom;
			// Question 1, is the tab on top or bottom
			if ( nPosDifference > TAB_MARGIN )
			{	// the tab is on top, in a row other than the immediate below the client area
				// draw the separator line at the top of the item
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.top );
				dc.SelectObject( pOldBrush );
			}
			else if ( nPosDifference >= 0 )
			{	// the tab is on top
				// draw the black line at the top
				dc.SelectObject( GetStockObject( BLACK_PEN ));
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.top );
			}
			else
			{	// the tab is on the of the window
				// draw the separator line at the bottom of the item
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.SelectObject( pOldBrush );
			}
		}
	}
	else
	{
		if ( lpDrawItemStruct->itemState == ODS_SELECTED )
		{
			// draw the white line (on the left)
			dc.SelectObject( GetStockObject( WHITE_PEN ));
			dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
			dc.LineTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
			// draw the top
			dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.top );
			// draw the black outline on right
			dc.SelectObject( GetStockObject( BLACK_PEN ));
			dc.MoveTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.top + 1 );
			dc.LineTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.bottom - 1 );
		}
		else// draw the inactive button
		{
			if ( IsNextButtonSelected(lpDrawItemStruct->itemID, pTabCtrl) == FALSE )
			{
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.top + 3 );
				dc.LineTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.bottom - 3 );
				dc.SelectObject( pOldBrush );
			}

			// determine the position of this button in relation to the child window
			// it is important to know if the button is in the bottom or top and in which
			// row of tabs
			CRect rPage;
			pTabCtrl->GetClientRect( rPage );
			pTabCtrl->AdjustRect( FALSE, rPage );

			int nPosDifference = rPage.top - lpDrawItemStruct->rcItem.top;
			// Question 1, is the tab on top or bottom
			if ( nPosDifference > ( lpDrawItemStruct->rcItem.bottom - lpDrawItemStruct->rcItem.top + TAB_MARGIN ))
			{	// the tab is on top, in a row other than the immediate above the client area
				// draw the white line at the bottom
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.SelectObject( pOldBrush );
			}
			else if ( nPosDifference > 0 )
			{	// the tab is on top
				// draw the white line at the bottom
				dc.SelectObject( GetStockObject( WHITE_PEN ));
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.bottom - 1 );
			}
			else
			{	// the tab is on the bottom
				// draw the separator line above
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.top );
				dc.SelectObject( pOldBrush );
			}
		}
	}

	dc.Detach();
}

// COXTabSkin2003
//

COXTabSkin2003::COXTabSkin2003(COXSkin2003* pSkin2003) :
	COXTabSkinXP(pSkin2003)
{

}

COXTabSkin2003::~COXTabSkin2003()
{
}

void COXTabSkin2003::DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct, CTabCtrl* pTabCtrl)
{
	CDC dc;
	dc.Attach( lpDrawItemStruct->hDC );
	CRect rcItem = lpDrawItemStruct->rcItem;

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	if (lpDrawItemStruct->itemState == ODS_SELECTED)
	{
		if (pTabCtrl->GetStyle() & TCS_BOTTOM)
			pSkin2003->GradientFill(&dc, rcItem,
				pSkin2003->GetTabItemDarkColor(),
				pSkin2003->GetTabItemLightColor(),
				GRADIENT_FILL_RECT_V);
		else
			pSkin2003->GradientFill(&dc, rcItem,
				 pSkin2003->GetTabItemLightColor(),
				 pSkin2003->GetTabItemDarkColor(),
				GRADIENT_FILL_RECT_V);

		dc.SetTextColor(::GetSysColor(COLOR_BTNTEXT));
	}
	else
	{
		if (pTabCtrl->GetStyle() & TCS_BOTTOM)
			pSkin2003->GradientFill(&dc, rcItem,
				pSkin2003->GetTabBackgroundLightColor(),
				pSkin2003->GetTabBackgroundDarkColor(),
				GRADIENT_FILL_RECT_V);
		else
			pSkin2003->GradientFill(&dc, rcItem,
				pSkin2003->GetTabBackgroundDarkColor(),
				pSkin2003->GetTabBackgroundLightColor(),
				GRADIENT_FILL_RECT_V);

		dc.SetTextColor(m_pSkinXP->GetInactiveTabTextColor());
	}

	TCHAR buf[255];
	TCITEM tabItem;
	//Get text of item.
	tabItem.mask = TCIF_TEXT|TCIF_IMAGE;
	tabItem.pszText = buf;
	tabItem.cchTextMax = sizeof( buf );
	pTabCtrl->GetItem( lpDrawItemStruct->itemID, &tabItem );
	CString tempStr( tabItem.pszText );

	rcItem.top += 3;

	// draw the icon
	if ((tabItem.mask & TCIF_IMAGE) && tabItem.iImage >= 0)
	{
		CImageList* pImage = pTabCtrl->GetImageList();
		if ( pImage != NULL )
		{
			// get information about the icon to draw
			IMAGEINFO iInfo;
			pImage->GetImageInfo( tabItem.iImage, &iInfo );
			// calculate the statring point for the image to be drawn, try to vertically center
			CPoint ptStart( rcItem.left + 3, rcItem.top - 1 );

			pImage->Draw( &dc, tabItem.iImage, ptStart, ILD_TRANSPARENT );

			// reduce the rectangle by the size of the image
			rcItem.left += ( iInfo.rcImage.right - iInfo.rcImage.left ) + 3;
		}
	}

	// draw the tab's text
	CFont *pOldFont = dc.SelectObject( &m_tabFont );
	int iOldMode = dc.SetBkMode(TRANSPARENT);
	dc.DrawText( tempStr, &rcItem, DT_CENTER );
	dc.SetBkMode(iOldMode);
	dc.SelectObject( pOldFont );
	rcItem.top -= 3;

	// draw focus rectangle
	if ( lpDrawItemStruct->itemState == ODS_SELECTED &&
		 ( pTabCtrl->GetStyle()&TCS_FOCUSNEVER) == 0 )
	{
		CRect rect( rcItem );
		rect.DeflateRect( 2, 2 );
		dc.DrawFocusRect( rect );
	}

	dc.Detach();
}

void COXTabSkin2003::DrawBackground(CDC* pDC, LPCRECT lpRect, CTabCtrl* /*pTabCtrl*/)
{
	pDC->FillSolidRect(lpRect, m_pSkinXP->GetDockbarBackgroundColor());
}

void COXTabSkin2003::OnPaintTabCtrl(CTabCtrl* pTabCtrl)
{
	CPaintDC dc(pTabCtrl); // device context for painting
	// retrieve the client area size info
	CRect clientRect;
	pTabCtrl->GetClientRect(&clientRect);
	// create and initialize memory DC to draw on
	CDC memDc, itemMemDc;
	CBitmap bmpMem, bmpItemMem, *pOldItemMemBmp, *pOldMemBmp;
	bmpMem.CreateCompatibleBitmap( &dc, clientRect.right, clientRect.bottom );
	bmpItemMem.CreateCompatibleBitmap( &dc, clientRect.Width(), clientRect.Height());
	// create memory DC fot the entire tab control
	memDc.CreateCompatibleDC( &dc );
	pOldMemBmp = memDc.SelectObject( &bmpMem );
	// create memory DC for each item to draw on
	itemMemDc.CreateCompatibleDC( &dc );
	pOldItemMemBmp = itemMemDc.SelectObject( &bmpItemMem );

	// check if we have alredy subclassed the up-down control
	COXSkinnedSpinCtrl* pUpDown = GetSpinCtrl(pTabCtrl);
	if (pUpDown != NULL && pUpDown->GetSafeHwnd() == NULL )
	{
		// we have not, check if it was created by looping through all client windows
		int intnRet;
		CRect upDnRect;
		CWnd* pWnd = pTabCtrl->GetWindow(GW_CHILD);

		while(pWnd)
		{
			TCHAR buf[] = _T("msctls_updown32");
			intnRet= ::GetClassName(pWnd->m_hWnd,buf,sizeof(buf)/sizeof(buf[0]));
			if( _tcscmp(buf, _T("msctls_updown32")) != 0 )
			{
				pWnd=pWnd->GetWindow(GW_HWNDNEXT);
			}
			else
			{ 
				//The msctls_updown32 control isfound.
				//
				//Subclass common msctls_updown32 control
				pUpDown->SubclassWindow(pWnd->m_hWnd);

				pWnd=0;
			}
		}
	}

	// draw background of the entire control
	DrawBackground(&memDc, clientRect, pTabCtrl);
	
	// Draw the tab work area
	CRect rPage( clientRect );
	pTabCtrl->AdjustRect(FALSE, rPage);

	// Draw a border around the child window
	CRect rectChild;
	COX3DTabViewContainer* p3DTVC = DYNAMIC_DOWNCAST(COX3DTabViewContainer, pTabCtrl);
	if (p3DTVC != NULL)
	{
		rectChild = p3DTVC->m_rectPage;
		rectChild.InflateRect(1, 1);
	}
	else
	{
		rectChild = rPage;
		rectChild.bottom -= 1;
	}

	CBrush brushBorder;
	brushBorder.CreateSolidBrush(::GetSysColor(COLOR_3DSHADOW));
	memDc.FrameRect(rectChild, &brushBorder);
	
	// draw the solid line above the work area
	if ( pTabCtrl->GetRowCount() <= 1 )
	{
		COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
		if ( pTabCtrl->GetStyle()&TCS_BOTTOM )
		{
			// draw background for the button area
			pSkin2003->GradientFill(&memDc, CRect(clientRect.left, rPage.bottom + TAB_MARGIN,
							  clientRect.right, clientRect.bottom),
				pSkin2003->GetTabBackgroundLightColor(),
				pSkin2003->GetTabBackgroundDarkColor(),
				GRADIENT_FILL_RECT_V);

			// draw a separator line
			memDc.SelectObject( ::GetStockObject( BLACK_PEN ));
			memDc.MoveTo( clientRect.left, rPage.bottom + TAB_MARGIN - 1 );
			memDc.LineTo( clientRect.right, rPage.bottom + TAB_MARGIN - 1 );
		}
		else
		{
			// draw background for the button area
			pSkin2003->GradientFill(&memDc, CRect(clientRect.left, clientRect.top,
							  clientRect.right, rPage.top - TAB_MARGIN),
				pSkin2003->GetTabBackgroundDarkColor(),
				pSkin2003->GetTabBackgroundLightColor(),
				GRADIENT_FILL_RECT_V);

			// draw a separator line
			memDc.SelectObject( ::GetStockObject( WHITE_PEN ));
			memDc.MoveTo( clientRect.left, rPage.top - TAB_MARGIN );
			memDc.LineTo( clientRect.right, rPage.top - TAB_MARGIN );
		}
	}

	// also paint the tabs
	int nTabCount = pTabCtrl->GetItemCount();
	int nSel = pTabCtrl->GetCurSel();

	// the tab control does not contain any items
	if ( nTabCount == 0 )
	{
		memDc.SelectObject( pOldMemBmp );
		itemMemDc.SelectObject( pOldItemMemBmp );
		return;
	}

	// Draw individual tab items
	DRAWITEMSTRUCT dis;
	dis.CtlType = ODT_TAB;
	dis.CtlID = pTabCtrl->GetDlgCtrlID();
	dis.hwndItem = pTabCtrl->GetSafeHwnd();
	dis.hDC = itemMemDc.GetSafeHdc();
	dis.itemAction = ODA_DRAWENTIRE;

	for ( int nIndex = 0; nIndex < nTabCount; nIndex++ )
	{
		// initialize the draw item structure for each of the tabs
		if (nIndex != nSel)
		{
			dis.itemID = nIndex;
			dis.itemState = 0;
			pTabCtrl->GetItemRect(nIndex, &dis.rcItem);
			DrawItem(&dis, pTabCtrl);
			DrawItemBorder(&dis, pTabCtrl);

			if ( AdjustItemRect( nIndex, &dis.rcItem, pTabCtrl ))
			{
				int width = dis.rcItem.right - dis.rcItem.left;
				int height = dis.rcItem.bottom - dis.rcItem.top;
				//Copy drawing from memory device context to the screen
				memDc.BitBlt( dis.rcItem.left,dis.rcItem.top,width,
					height,&itemMemDc,dis.rcItem.left,dis.rcItem.top,SRCCOPY);
			}
		}
	}

	// draw the selected item
	dis.itemID = nSel;
	dis.itemState = ODS_SELECTED;
	pTabCtrl->GetItemRect(nSel, &dis.rcItem);
	DrawItem(&dis, pTabCtrl);
	DrawItemBorder(&dis, pTabCtrl);

	if ( AdjustItemRect( nSel, &dis.rcItem, pTabCtrl ))
	{
		int width = dis.rcItem.right - dis.rcItem.left;
		int height = dis.rcItem.bottom - dis.rcItem.top;
		//Copy drawing from memory device context to the screen
		memDc.BitBlt( dis.rcItem.left,dis.rcItem.top,width,
			height,&itemMemDc,dis.rcItem.left,dis.rcItem.top,SRCCOPY);
	}

	//Copy drawing from memory device context to the screen
	dc.BitBlt( clientRect.left, clientRect.top, clientRect.Width(),
			   clientRect.Height(), &memDc,
			   clientRect.left, clientRect.top, SRCCOPY);

	// a final clean up
	memDc.SelectObject( pOldMemBmp );
	itemMemDc.SelectObject( pOldItemMemBmp );

	// make sure that the spin control is also redrawn
	if (pUpDown != NULL && pUpDown->GetSafeHwnd() != NULL )
		if ( pUpDown->IsWindowVisible())
			pUpDown->Invalidate();
}

void COXTabSkin2003::DrawItemBorder(LPDRAWITEMSTRUCT lpDrawItemStruct, CTabCtrl* pTabCtrl)
{
	CDC dc;
	dc.Attach( lpDrawItemStruct->hDC );

	if ( pTabCtrl->GetStyle()&TCS_BOTTOM )
	{
		if ( lpDrawItemStruct->itemState == ODS_SELECTED )
		{
			// draw the white line (on the left)
			dc.SelectObject( GetStockObject( WHITE_PEN ));
			dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
			dc.LineTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
			dc.SelectObject( GetStockObject( BLACK_PEN ));
			// draw the bottom
			dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.bottom - 1 );
			// draw the black outline on right
			dc.MoveTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.top );
			dc.LineTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.bottom - 1 );
		}
		else// draw the inactive button
		{
			if ( IsNextButtonSelected(lpDrawItemStruct->itemID, pTabCtrl) == FALSE )
			{	// draw the separators between the bottons
				CRect rectSep(lpDrawItemStruct->rcItem.right - 1,
					lpDrawItemStruct->rcItem.top + 3,
					lpDrawItemStruct->rcItem.right,
					lpDrawItemStruct->rcItem.bottom - 3);

				dc.FillSolidRect(rectSep,  m_pSkinXP->GetBorderColor());
			}

			// determine the position of this button in relation to the child window
			// it is important to know if the button is in the bottom or top and in which
			// row of tabs
			CRect rPage;
			pTabCtrl->GetClientRect( rPage );
			pTabCtrl->AdjustRect( FALSE, rPage );

			int nPosDifference = lpDrawItemStruct->rcItem.top - rPage.bottom;
			// Question 1, is the tab on top or bottom
			if ( nPosDifference > TAB_MARGIN )
			{	// the tab is on top, in a row other than the immediate below the client area
				// draw the separator line at the top of the item
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.top );
				dc.SelectObject( pOldBrush );
			}
			else if ( nPosDifference >= 0 )
			{	// the tab is on top
				// draw the black line at the top
				dc.SelectObject( GetStockObject( BLACK_PEN ));
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.top );
			}
			else
			{	// the tab is on the of the window
				// draw the separator line at the bottom of the item
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.SelectObject( pOldBrush );
			}
		}
	}
	else
	{
		if ( lpDrawItemStruct->itemState == ODS_SELECTED )
		{
			// draw the white line (on the left)
			dc.SelectObject( GetStockObject( WHITE_PEN ));
			dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
			dc.LineTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
			// draw the top
			dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.top );
			// draw the black outline on right
			dc.SelectObject( GetStockObject( BLACK_PEN ));
			dc.MoveTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.top + 1 );
			dc.LineTo( lpDrawItemStruct->rcItem.right - 1, lpDrawItemStruct->rcItem.bottom - 1 );
		}
		else// draw the inactive button
		{
			if ( IsNextButtonSelected(lpDrawItemStruct->itemID, pTabCtrl) == FALSE )
			{
				CRect rectSep(lpDrawItemStruct->rcItem.right - 1,
					lpDrawItemStruct->rcItem.top + 3,
					lpDrawItemStruct->rcItem.right,
					lpDrawItemStruct->rcItem.bottom - 3);

				dc.FillSolidRect(rectSep,  m_pSkinXP->GetBorderColor());
			}

			// determine the position of this button in relation to the child window
			// it is important to know if the button is in the bottom or top and in which
			// row of tabs
			CRect rPage;
			pTabCtrl->GetClientRect( rPage );
			pTabCtrl->AdjustRect( FALSE, rPage );

			int nPosDifference = rPage.top - lpDrawItemStruct->rcItem.top;
			// Question 1, is the tab on top or bottom
			if ( nPosDifference > ( lpDrawItemStruct->rcItem.bottom - lpDrawItemStruct->rcItem.top + TAB_MARGIN ))
			{	// the tab is on top, in a row other than the immediate above the client area
				// draw the white line at the bottom
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.SelectObject( pOldBrush );
			}
			else if ( nPosDifference > 0 )
			{	// the tab is on top
				// draw the white line at the bottom
				dc.SelectObject( GetStockObject( WHITE_PEN ));
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.bottom - 1 );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.bottom - 1 );
			}
			else
			{	// the tab is on the bottom
				// draw the separator line above
				CPen *pOldBrush = dc.SelectObject( &m_sepPen );
				dc.MoveTo( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
				dc.LineTo( lpDrawItemStruct->rcItem.right, lpDrawItemStruct->rcItem.top );
				dc.SelectObject( pOldBrush );
			}
		}
	}

	dc.Detach();
}

void COXTabSkin2003::OnPaintSpinCtrl(COXSkinnedSpinCtrl* pSpinCtrl)
{
	CPaintDC dc(pSpinCtrl); // device context for painting
	// retrieve the client area size info
	CRect clientRect;
	pSpinCtrl->GetClientRect( clientRect );
	// create and initialize memory DC to draw on
	CDC itemMemDc;
	CBitmap bmpMem,*pOldItemMemBmp;
	itemMemDc.CreateCompatibleDC( &dc );
	bmpMem.CreateCompatibleBitmap( &dc,clientRect.Width(), clientRect.Height());
	pOldItemMemBmp = itemMemDc.SelectObject( &bmpMem );

	// Draw the background
	
	CTabCtrl* pTabCtrl = (CTabCtrl*) pSpinCtrl->GetParent();
	CRect rectClient;
	pTabCtrl->GetWindowRect(&rectClient);
	CRect rectPage(rectClient);
	pTabCtrl->AdjustRect(FALSE, rectPage);
	pSpinCtrl->ScreenToClient(rectClient);
	pSpinCtrl->ScreenToClient(rectPage);

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	if (pTabCtrl->GetStyle() & TCS_BOTTOM)
	{
		// draw background for the button area
		pSkin2003->GradientFill(&itemMemDc, CRect(rectClient.left, rectPage.top + TAB_MARGIN,
						  rectClient.right, rectClient.bottom),
			pSkin2003->GetTabBackgroundLightColor(),
			pSkin2003->GetTabBackgroundDarkColor(),
			GRADIENT_FILL_RECT_V);
	}
	else
	{
		// draw background for the button area
		pSkin2003->GradientFill(&itemMemDc, CRect(rectClient.left, rectClient.top,
						  rectClient.right, rectPage.top),
			pSkin2003->GetTabBackgroundDarkColor(),
			pSkin2003->GetTabBackgroundLightColor(),
			GRADIENT_FILL_RECT_V);
	}

	// adjust the rect to provide extended border
	if (!( pTabCtrl->GetStyle()&TCS_BOTTOM ))
		clientRect.top += 2;
	else
		clientRect.bottom -= 2;

	clientRect.left += 2;
	clientRect.right -= 2;

	// calculate the sizes of the buttons
	int midPoint = ( clientRect.right - clientRect.left ) / 2;
	int btnWidth = midPoint - 1;
	CRect downRect( clientRect.left, clientRect.top, clientRect.left + btnWidth, clientRect.bottom );
	CRect upRect( midPoint, clientRect.top, midPoint + btnWidth, clientRect.bottom );

	DrawDownArrow(&itemMemDc, downRect, pSpinCtrl);
	DrawUpArrow(&itemMemDc, upRect, pSpinCtrl);

	CPoint mousePos;
	::GetCursorPos( &mousePos );
	pSpinCtrl->ScreenToClient( &mousePos );

	int lower, upper;
	pSpinCtrl->GetRange32( lower, upper );
	// draw frame
	if ( upRect.PtInRect( mousePos ) && LOWORD(pSpinCtrl->GetPos()) != upper )
	{
		DrawArrowBorder(&itemMemDc, upRect, pSpinCtrl);
	}
	else if ( downRect.PtInRect( mousePos ) && LOWORD(pSpinCtrl->GetPos()) != 0 )
	{
		DrawArrowBorder(&itemMemDc, downRect, pSpinCtrl);
	}
	//Copy drawing from memory device context to the screen
	dc.BitBlt( clientRect.left,clientRect.top,clientRect.Width(),
		clientRect.Height(),&itemMemDc,clientRect.left,clientRect.top,SRCCOPY);
	// a final clean up
	itemMemDc.SelectObject( pOldItemMemBmp );
}

// This function returns a pointer to the spin control of a tab container
COXSkinnedSpinCtrl* COXTabSkinXP::GetSpinCtrl(CTabCtrl* pTabContainer)
{
	COXSkinnedTabCtrl* pSkinnedTabCtrl = DYNAMIC_DOWNCAST(COXSkinnedTabCtrl, pTabContainer);
	if (pSkinnedTabCtrl != NULL)
		return &pSkinnedTabCtrl->m_updown;

	return NULL;
}

void COXTabSkinXP::OnPaintSpinCtrl(COXSkinnedSpinCtrl* pSpinCtrl)
{
	CPaintDC dc(pSpinCtrl); // device context for painting
	// retrieve the client area size info
	CRect clientRect;
	pSpinCtrl->GetClientRect( clientRect );
	// create and initialize memory DC to draw on
	CDC itemMemDc;
	CBitmap bmpMem,*pOldItemMemBmp;
	itemMemDc.CreateCompatibleDC( &dc );
	bmpMem.CreateCompatibleBitmap( &dc,clientRect.Width(), clientRect.Height());
	pOldItemMemBmp = itemMemDc.SelectObject( &bmpMem );

	// clear the background
	itemMemDc.FillSolidRect( clientRect,  m_pSkinXP->GetTabButtonsBackgroundColor() );
	// adjust the rect to provide extended border
	if (!( pSpinCtrl->GetParent()->GetStyle()&TCS_BOTTOM ))
		clientRect.top += 2;
	else
		clientRect.bottom -= 2;

	clientRect.left += 2;
	clientRect.right -= 2;

	// calculate the sizes of the buttons
	int midPoint = ( clientRect.right - clientRect.left ) / 2;
	int btnWidth = midPoint - 1;
	CRect downRect( clientRect.left, clientRect.top, clientRect.left + btnWidth, clientRect.bottom );
	CRect upRect( midPoint, clientRect.top, midPoint + btnWidth, clientRect.bottom );

	DrawDownArrow(&itemMemDc, downRect, pSpinCtrl);
	DrawUpArrow(&itemMemDc, upRect, pSpinCtrl);

	CPoint mousePos;
	::GetCursorPos( &mousePos );
	pSpinCtrl->ScreenToClient( &mousePos );

	int lower, upper;
	pSpinCtrl->GetRange32( lower, upper );
	// draw frame
	if ( upRect.PtInRect( mousePos ) && LOWORD(pSpinCtrl->GetPos()) != upper )
	{
		DrawArrowBorder(&itemMemDc, upRect, pSpinCtrl);
	}
	else if ( downRect.PtInRect( mousePos ) && LOWORD(pSpinCtrl->GetPos()) != 0 )
	{
		DrawArrowBorder(&itemMemDc, downRect, pSpinCtrl);
	}
	//Copy drawing from memory device context to the screen
	dc.BitBlt( clientRect.left,clientRect.top,clientRect.Width(),
		clientRect.Height(),&itemMemDc,clientRect.left,clientRect.top,SRCCOPY);
	// a final clean up
	itemMemDc.SelectObject( pOldItemMemBmp );
}

void COXTabSkinXP::DrawDownArrow(CDC* pDc, CRect btnRect, COXSkinnedSpinCtrl* pSpinCtrl)
{
	CBrush *pOldBrush = NULL;
	CPen *pOldPen = pDc->SelectObject( &m_btnLine );

	if ( LOWORD(pSpinCtrl->GetPos()) != 0 )
		pOldBrush = pDc->SelectObject( &m_btnFill );

	// draw the down arrow
	CSize arrowSize( 4, 8 );
	CPoint points[4];
	int xMargin = ( btnRect.right - btnRect.left - arrowSize.cx ) / 2;
	int yMargin = ( btnRect.bottom - btnRect.top - arrowSize.cy ) / 2;
	int midPoint = btnRect.top + yMargin + ( arrowSize.cy / 2 );
	points[0].x = btnRect.left + xMargin;
	points[0].y = midPoint - 1;
	points[1].x = btnRect.left + xMargin + arrowSize.cx;
	points[1].y = btnRect.top + yMargin - 1;
	points[2].x = btnRect.left + xMargin + arrowSize.cx;
	points[2].y = btnRect.top + yMargin + arrowSize.cy - 1;
	points[3].x = btnRect.left + xMargin;
	points[3].y = midPoint - 1;

	pDc->Polygon( points, 4 );

	// clean up
	if ( pOldBrush != NULL )
		pDc->SelectObject( pOldBrush );

	pDc->SelectObject( pOldPen );
}

void COXTabSkinXP::DrawUpArrow(CDC* pDc, CRect btnRect, COXSkinnedSpinCtrl* pSpinCtrl)
{
	int lower, upper;
	pSpinCtrl->GetRange32( lower, upper );
	CBrush *pOldBrush = NULL;
	CPen *pOldPen = pDc->SelectObject( &m_btnLine );

	if ( LOWORD(pSpinCtrl->GetPos()) != upper )
		pOldBrush = pDc->SelectObject( &m_btnFill );

	// draw the down arrow
	CSize arrowSize( 4, 8 );
	CPoint points[4];
	int xMargin = ( btnRect.right - btnRect.left - arrowSize.cx ) / 2;
	int yMargin = ( btnRect.bottom - btnRect.top - arrowSize.cy ) / 2;
	int midPoint = btnRect.top + yMargin + ( arrowSize.cy / 2 );
	points[0].x = btnRect.left + xMargin + arrowSize.cx;
	points[0].y = midPoint - 1;
	points[1].x = btnRect.left + xMargin;
	points[1].y = btnRect.top + yMargin - 1;
	points[2].x = btnRect.left + xMargin;
	points[2].y = btnRect.top + yMargin + arrowSize.cy - 1;
	points[3].x = btnRect.left + xMargin + arrowSize.cx;
	points[3].y = midPoint - 1;

	pDc->Polygon( points, 4 );

	// clean up
	if ( pOldBrush != NULL )
		pDc->SelectObject( pOldBrush );

	pDc->SelectObject( pOldPen );
}

// this function will get the proper rect for a tab, and it will check if it
// overlaps the up-down control.  If it does than the tab's rect will be adjusted.
BOOL COXTabSkinXP::AdjustItemRect(int /*nIndex*/, RECT *tabRect, CTabCtrl* pTabCtrl)
{
	// before drawing item, check if it overlaps the spin control
	COXSkinnedSpinCtrl* pUpDown = GetSpinCtrl(pTabCtrl);
	if (pUpDown != NULL && pUpDown->GetSafeHwnd() != NULL )
	{
		if ( pUpDown->IsWindowVisible())
		{
			CRect spinRect, tabclientRect;
			pUpDown->GetClientRect( spinRect );
			pTabCtrl->GetClientRect( tabclientRect );

			if ( tabRect->left > ( tabclientRect.right - spinRect.Width()))
				return FALSE;

			if ( tabRect->right <= ( tabclientRect.left + TAB_MARGIN ))
				return FALSE;

			if ( tabRect->right > ( tabclientRect.right - spinRect.Width()))
				// the right edge of the tab button extends over the up-down control
				tabRect->right = tabclientRect.right - spinRect.Width();
		}
	}
	
	return TRUE;
}

BOOL COXTabSkinXP::IsNextButtonSelected(int nItemID, CTabCtrl* pTabCtrl)
{
	int nCount = pTabCtrl->GetItemCount();

	if ( nItemID < nCount - 1 )
	{
		if ( pTabCtrl->GetItemState( nItemID + 1, TCIS_BUTTONPRESSED ) == TCIS_BUTTONPRESSED )
			return TRUE;
	}
	return FALSE;
}

void COXTabSkinXP::DrawArrowBorder(CDC* pDc, CRect btnRect, COXSkinnedSpinCtrl* /*pSpinCtrl*/)
{
	btnRect.DeflateRect( 1, 1 );

	if ( GetKeyState( VK_LBUTTON ) < 0 )
	{
		// 0,0,0
		pDc->SelectObject( GetStockObject( BLACK_PEN ));
		pDc->MoveTo( btnRect.left, btnRect.bottom );
		pDc->LineTo( btnRect.left, btnRect.top );
		pDc->LineTo( btnRect.right, btnRect.top );
		// 241,239,226
		pDc->SelectObject( GetStockObject( WHITE_PEN ));
		pDc->LineTo( btnRect.right, btnRect.bottom );
		pDc->LineTo( btnRect.left, btnRect.bottom );
	}
	else
	{
		// 241,239,226
		pDc->SelectObject( GetStockObject( WHITE_PEN ));
		pDc->MoveTo( btnRect.left, btnRect.bottom );
		pDc->LineTo( btnRect.left, btnRect.top );
		pDc->LineTo( btnRect.right, btnRect.top );
		// 0,0,0
		pDc->SelectObject( GetStockObject( BLACK_PEN ));
		pDc->LineTo( btnRect.right, btnRect.bottom );
		pDc->LineTo( btnRect.left, btnRect.bottom );
	}
}


// COXMenuSkin
//


// COXMenuSkinClassic
//

#include "OXBitmapMenu.h"
#include "OXBitmapMenuOrganizer.h"

COXMenuSkinClassic::COXMenuSkinClassic()
{
	// Initialize the dimension constants structure
	m_DimensionConstants.m_nGapLeftBitmap = 2;
	m_DimensionConstants.m_nGapBitmapText = 8;	
	m_DimensionConstants.m_nGapTextAcclrtr = 2;	
	m_DimensionConstants.m_nGapAcclrtrRight = 3;
	m_DimensionConstants.m_nGapVertText = 4;	
	m_DimensionConstants.m_nGapVertBitmap = 3;
	m_DimensionConstants.m_nSeparatorHeight = ID_OXBITMAPMENU_SEPARATOR_HEIGHT;
	m_DimensionConstants.m_nMinBitmapWidth = 0;
	m_DimensionConstants.m_nGapMenuItems = 12;
}

void COXMenuSkinClassic::DistributeSpace(UINT /*nState*/, COXImageInfo* pImageInfo, LPRECT lpItemRect,
										 CRect& rectButton, CRect& rectImage, CRect& rectText1,
										 CRect& rectText2, COXBitmapMenu* pBitmapMenu)
{
	CRect rectItem(lpItemRect);
	OXDIMENSIONCONSTANTS& oxdc = GetDimentionConstants();

	// Compute the image and button rectangle
	if(pImageInfo != NULL)
	{
		// Get the actual bitmap rect
		IMAGEINFO ii;
		::ZeroMemory(&ii, sizeof(ii));
		pImageInfo->GetImageList()->GetImageInfo(pImageInfo->GetIndex(), &ii);
		
		// Center it vertically in the item rect
		CRect bitmapRect= ii.rcImage;
		bitmapRect -= bitmapRect.TopLeft();
		int nVertGap=(rectItem.Height() - bitmapRect.Height()) / 2;

		ASSERT(bitmapRect.Width() <= rectItem.Width());

		rectImage=bitmapRect;
		rectImage += rectItem.TopLeft();
		rectImage += CPoint(oxdc.m_nGapLeftBitmap, nVertGap);

		// Compute the button rectangle
		rectButton=rectImage;
		rectButton.InflateRect(2, 2);
	}

	// Compute the rectangle for the text in front of the tab 
	rectText1=rectItem;
	rectText1.left=oxdc.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + oxdc.m_nGapBitmapText;
	rectText1.right=rectText1.left + pBitmapMenu->m_nStringExtent;

	// Compute the rectangle for the text after the tab (shortcut key)
	rectText2=rectItem;
	rectText2.right -= oxdc.m_nGapAcclrtrRight;
	rectText2.left=rectText2.right - pBitmapMenu->m_nAcceleratorExtent;
	int nGapTextHorz=(rectText2.left - rectText1.right) / 2;
	rectText2 -= CPoint(nGapTextHorz, 0);

	// Center the text vertically
	int nGapTextVert=(rectItem.Height() - pBitmapMenu->m_nTextHeight) / 2;
	rectText1.InflateRect(0, -nGapTextVert);
	rectText2.top=rectText1.top;
	rectText2.bottom=rectText1.bottom;
}

void COXMenuSkinClassic::DrawBackground(CDC* pDC, UINT nState, COXImageInfo* pImageInfo, LPRECT lpItemRect, LPRECT lpButtonRect, COXBitmapMenu* pBitmapMenu)
{
	CRect itemRect(lpItemRect);
	CRect buttonRect(lpButtonRect);

	BOOL bSelected=nState & ODS_SELECTED;
	BOOL bChecked=nState & ODS_CHECKED;
	BOOL bHidden=nState & OXODS_HIDDEN;

	COLORREF clrBackground=::GetSysColor(bSelected ? COLOR_HIGHLIGHT : COLOR_MENU); 

	if((bHidden && !pImageInfo->IsDefaultImgList()) || (bChecked && !bSelected))
	{
		HBRUSH hBrush=pBitmapMenu->HBrushDitherCreate(::GetSysColor(COLOR_MENU),
			::GetSysColor(COLOR_BTNHIGHLIGHT));
		if(hBrush!=NULL)
		{
			::FillRect(pDC->GetSafeHdc(),buttonRect,hBrush);
			::DeleteObject((HGDIOBJ)hBrush);
		}
	}
	else
	{
		// Draw the image on a special background depending on selection, 
		// check state and Default image or not
		COLORREF clrBtnBackground=::GetSysColor(bSelected ? 
			(bChecked ? COLOR_MENU : (pImageInfo->IsDefaultImgList() ? 
			COLOR_HIGHLIGHT : COLOR_MENU)) : 
			(bChecked ? COLOR_3DHILIGHT : COLOR_MENU)); 
		pDC->FillSolidRect(&buttonRect, clrBtnBackground);
	}

	if(!bHidden || bSelected)
	{
		itemRect.left=__max(buttonRect.right, m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + 
			(!bChecked ? (pImageInfo->IsDefaultImgList() ? -1 : 1) : 2));
		itemRect.bottom -= 1;
		CBrush brush;
		brush.CreateSolidBrush(clrBackground);
		pDC->FillRect(&itemRect,&brush);
	}
	else
	{
		HBRUSH hBrush=pBitmapMenu->HBrushDitherCreate(::GetSysColor(COLOR_MENU),
			::GetSysColor(COLOR_BTNHIGHLIGHT));
		if(hBrush!=NULL)
		{
			::FillRect(pDC->GetSafeHdc(),itemRect,hBrush);
			::DeleteObject((HGDIOBJ)hBrush);
		}
	}

	if(bHidden && !bSelected)
	{
		if(nState & OXODS_HIDDENFIRST)
		{
			CPen pen(PS_SOLID,1,::GetSysColor(COLOR_3DSHADOW));
			CPen* pOldPen=pDC->SelectObject(&pen);
			pDC->MoveTo(itemRect.TopLeft());
			pDC->LineTo(itemRect.right,itemRect.top);
			pDC->SelectObject(pOldPen);
		}

		if(nState & OXODS_HIDDENLAST)
		{
			CPen pen(PS_SOLID,1,::GetSysColor(COLOR_3DHILIGHT));
			CPen* pOldPen=pDC->SelectObject(&pen);
			pDC->MoveTo(itemRect.left,itemRect.bottom-1);
			pDC->LineTo(itemRect.right,itemRect.bottom-1);
			pDC->SelectObject(pOldPen);
		}
	}
}

void COXMenuSkinClassic::DrawButton(CDC* pDC, UINT nState,  COXImageInfo* pImageInfo, LPRECT lpButtonRect, COXBitmapMenu* /*pBitmapMenu*/)
{
	BOOL bSelected=nState & ODS_SELECTED;
	BOOL bDisabled=nState & ODS_DISABLED;
	BOOL bChecked=nState & ODS_CHECKED;

	// Draw edge around the image according to the state of the item
	// (The background has already been filled with the right color)
	if(bSelected && !bDisabled && !bChecked && !pImageInfo->IsDefaultImgList())
	{
		pDC->DrawEdge(lpButtonRect, BDR_RAISEDINNER, BF_RECT);
	}
	else if(bChecked)
	{
		pDC->DrawEdge(lpButtonRect, BDR_SUNKENOUTER, BF_RECT);
	}
}

void COXMenuSkinClassic::DrawImage(CDC* pDC, UINT nState, COXImageInfo* pImageInfo, LPRECT lpImageRect, COXBitmapMenu* /*pBitmapMenu*/)
{
	CRect imageRect(lpImageRect);

	BOOL bDisabled=nState & ODS_DISABLED;
	BOOL bChecked=nState & ODS_CHECKED;
	BOOL bSelected=nState & ODS_SELECTED;

	if(pImageInfo->IsDefaultImgList() && !bChecked)
	{
		// The default checkmark is not drawn when it isn't checked
		return;
	}

	int nIndex=pImageInfo->GetIndex();
	if(bSelected && pImageInfo->GetHotIndex()!=-1)
	{
		nIndex=pImageInfo->GetHotIndex();
	}

	if(!bDisabled)
	{
		pImageInfo->GetImageList()->Draw(pDC, nIndex, 
			imageRect.TopLeft(), ILD_NORMAL|ILD_TRANSPARENT); 
	}
	else
	{
		HICON hIcon=pImageInfo->GetImageList()->ExtractIcon(nIndex);
		pDC->DrawState(
			imageRect.TopLeft(),imageRect.Size(),hIcon,DSS_DISABLED,(HBRUSH)NULL);
		VERIFY(::DestroyIcon(hIcon));
	}
}

void COXMenuSkinClassic::DrawText(CDC* pDC, UINT nState, LPCTSTR lpszText, LPRECT lpText1Rect, LPRECT lpText2Rect, COXBitmapMenu* /*pBitmapMenu*/)
{
	CRect text1Rect(lpText1Rect);
	CRect text2Rect(lpText2Rect);

	BOOL bSelected=nState & ODS_SELECTED;
	BOOL bDisabled=nState & ODS_DISABLED;

	// Split the text (in front of and after the tab)
	CString sText(lpszText);
	int nTabCharIndex=sText.Find(_T('\t'));
	CString sAfterTab;
	CString sBeforeTab;
	if(nTabCharIndex != -1)
	{
		sBeforeTab=sText.Left(nTabCharIndex);
		sAfterTab=sText.Mid(nTabCharIndex + 1);
	}
	else
	{
		sBeforeTab=sText;
		ASSERT(sAfterTab.IsEmpty());
	}

	// Draw the text
	// Sets the foreground color of the text based on its selection state
	COLORREF clrForeground=::GetSysColor(bDisabled ? COLOR_GRAYTEXT : 
		(bSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT)); 
	COLORREF clrOldForeground=pDC->SetTextColor(clrForeground);

	// set background filling mode
	int nOldBkMode=pDC->SetBkMode(TRANSPARENT);

	UINT nFlags=0;
	CRect newText2Rect(0,0,0,0);
	int nHorzAlign=0;
	if(bDisabled && !bSelected)
		nFlags |= DSS_DISABLED;

	pDC->DrawState(text1Rect.TopLeft(), text1Rect.Size(), sBeforeTab.GetBuffer(0),
		nFlags, TRUE, sBeforeTab.GetLength(), (CBrush*)NULL);

	// ... First calculate text width so we can right-align it
	pDC->DrawText(sAfterTab, newText2Rect, DT_CALCRECT | DT_SINGLELINE);
	nHorzAlign=text2Rect.Width() - newText2Rect.Width();
	if(!sAfterTab.IsEmpty())
	{
		pDC->DrawState(text2Rect.TopLeft() + CPoint(nHorzAlign, 0), 
			newText2Rect.Size(), sAfterTab.GetBuffer(0),
			nFlags, TRUE, sAfterTab.GetLength(), (CBrush*)NULL);
	}

	pDC->SetTextColor(clrOldForeground); 
	pDC->SetBkMode(nOldBkMode);
}

void COXMenuSkinClassic::DrawSeparator(CDC* pDC, LPRECT lpItemRect, COXBitmapMenu* /*pBitmapMenu*/)
{
	CRect itemRect(lpItemRect);
	ASSERT(pDC!=NULL);
	itemRect.DeflateRect(2,0);
	itemRect.top+=itemRect.Height()/2-1;
	itemRect.bottom=itemRect.top+2;
	pDC->Draw3dRect(itemRect,::GetSysColor(COLOR_BTNSHADOW),
		::GetSysColor(COLOR_BTNHILIGHT));
}

void COXMenuSkinClassic::DrawCustomized(CDC* pDC, LPRECT lpItemRect, COXBitmapMenu* /*pBitmapMenu*/)
{
	ASSERT(pDC!=NULL);
	pDC->DrawDragRect(lpItemRect,CSize(2,2),CRect(0,0,0,0),CSize(0,0),NULL,NULL);
}

void COXMenuSkinClassic::DrawInsertMark(CDC* pDC, LPRECT lpItemRect, BOOL bBefore, COXBitmapMenu* /*pBitmapMenu*/)
{
	CRect itemRect(lpItemRect);
	itemRect.DeflateRect(2,0);

	ASSERT(pDC!=NULL);
	if(bBefore)
	{
		itemRect.top-=2;
		itemRect.bottom=itemRect.top+3;
	}
	else
	{
		itemRect.bottom+=1;
		itemRect.top=itemRect.bottom-3;
	}

	pDC->MoveTo(itemRect.TopLeft());
	pDC->LineTo(itemRect.left+1,itemRect.top+1);
	pDC->LineTo(itemRect.right-1,itemRect.top+1);
	pDC->LineTo(itemRect.right,itemRect.top);
	pDC->LineTo(itemRect.right,itemRect.bottom);
	pDC->LineTo(itemRect.right-1,itemRect.bottom-1);
	pDC->LineTo(itemRect.left+1,itemRect.bottom-1);
	pDC->LineTo(itemRect.left,itemRect.bottom);
	pDC->LineTo(itemRect.TopLeft());
}

void COXMenuSkinClassic::DrawSubmenuItem(CDC* pDC, UINT nState, LPCTSTR lpszText, COXImageInfo* pImageInfo, 
									LPRECT lpItemRect, LPRECT lpButtonRect, LPRECT lpText1Rect, LPRECT lpText2Rect, COXBitmapMenu* pBitmapMenu)
{
	ASSERT(pDC!=NULL);
	pBitmapMenu->DrawBackground(pDC,nState,pImageInfo,lpItemRect,lpButtonRect);

	if(pBitmapMenu->IsInCustomizationMode())
	{
		// draw right aligned arrow
		//
		COLORREF clrShadow=::GetSysColor(COLOR_BTNSHADOW);
		CFont font;
		CFont* pOldFont=NULL;
		if((font.CreateFont(GetSystemMetrics(SM_CYMENUCHECK), 0, 0, 0, 
			FW_NORMAL, 0, 0, 0, SYMBOL_CHARSET, 0,0,0,0, _T("Marlett"))) != NULL)
		{
			pOldFont=(CFont*)pDC->SelectObject(&font);
		}
		int nOldBkMode=pDC->SetBkMode(TRANSPARENT);
		COLORREF oldTextColor=CLR_NONE;
		if((nState&ODS_DISABLED)==ODS_DISABLED)
		{
			oldTextColor=pDC->SetTextColor(clrShadow);
		}
		// draw arrow symbol
		pDC->DrawText(_T("8"),lpText2Rect,DT_CENTER|DT_VCENTER|DT_SINGLELINE);
		if((nState&ODS_DISABLED)==ODS_DISABLED)
		{
			pDC->SetTextColor(oldTextColor);
		}
		pDC->SetBkMode(nOldBkMode);
		if(pOldFont != NULL)
		{
			pDC->SelectObject(pOldFont);
		}
		//
		//////////////////////////////
	}

	DrawText(pDC,nState,lpszText,lpText1Rect,lpText2Rect,pBitmapMenu);
}

LRESULT COXMenuSkinClassic::MenuPopupWndProc(WNDPROC origWndProc, HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
	// Call the default
	return ::CallWindowProc(origWndProc, hWnd, nMsg, wParam, lParam);
}

void COXMenuSkinClassic::DrawExpansionItem(CDC* pDC, LPRECT lpItemRect, UINT nState, COXBitmapMenu* /*pBitmapMenu*/)
{
	ASSERT(pDC!=NULL);

	BOOL bSelected=nState & ODS_SELECTED;
	BOOL bDisabled=nState & ODS_DISABLED;

	CFont font;
	VERIFY(font.CreateFont(GetSystemMetrics(SM_CYMENUCHECK),0,0,0,
		FW_NORMAL,0,0,0,SYMBOL_CHARSET,0,0,0,0,_T("Marlett")));
	CFont* pOldFont=pDC->SelectObject(&font);
	int nOldBkMode=pDC->SetBkMode(TRANSPARENT);
	COLORREF clrText=::GetSysColor(bDisabled ? COLOR_GRAYTEXT : 
		(bSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT)); 
	COLORREF oldTextColor=pDC->SetTextColor(clrText);

	pDC->DrawText(_T("6"),lpItemRect,DT_CENTER|DT_VCENTER|DT_SINGLELINE);

	pDC->SetTextColor(oldTextColor);
	pDC->SetBkMode(nOldBkMode);
	pDC->SelectObject(pOldFont);
}

// COXMenuSkinXP
//

COXMenuSkinXP::COXMenuSkinXP(COXSkinXP* pSkinXP)
{
	m_pSkinXP = pSkinXP;

	// Initialize the dimension constants structure
	m_DimensionConstants.m_nGapLeftBitmap = 3;
	m_DimensionConstants.m_nGapRightBitmap = 5;
	m_DimensionConstants.m_nGapBitmapText = 15;	
	m_DimensionConstants.m_nGapTextAcclrtr = 12;	
	m_DimensionConstants.m_nGapAcclrtrRight = 6;
	m_DimensionConstants.m_nGapVertText = 10;	
	m_DimensionConstants.m_nGapVertBitmap = 4;
	m_DimensionConstants.m_nSeparatorHeight = 3;
	m_DimensionConstants.m_nMinBitmapWidth = 16;
	m_DimensionConstants.m_nGapMenuItems = 16;
}

COXMenuSkinXP::~COXMenuSkinXP()
{
	m_mapHWNDtoPos.RemoveAll();
}

void COXMenuSkinXP::DistributeSpace(UINT /*nState*/, COXImageInfo* pImageInfo, LPRECT lpItemRect,
										 CRect& rectButton, CRect& rectImage, CRect& rectText1,
										 CRect& rectText2, COXBitmapMenu* pBitmapMenu)
{
	CRect rectItem(lpItemRect);
	OXDIMENSIONCONSTANTS& oxdc = GetDimentionConstants();

	// Compute the image and button rectangle
	if(pImageInfo != NULL)
	{
		// Get the actual bitmap rect
		IMAGEINFO ii;
		::ZeroMemory(&ii, sizeof(ii));
		pImageInfo->GetImageList()->GetImageInfo(pImageInfo->GetIndex(), &ii);
		
		// Center it vertically in the item rect
		CRect bitmapRect= ii.rcImage;
		bitmapRect -= bitmapRect.TopLeft();
		int nVertGap=(rectItem.Height() - bitmapRect.Height()) / 2;

		ASSERT(bitmapRect.Width() <= rectItem.Width());

		rectImage=bitmapRect;
		rectImage += rectItem.TopLeft();
		rectImage += CPoint(oxdc.m_nGapLeftBitmap, nVertGap);

		// Compute the button rectangle
		rectButton = rectImage;
		rectButton.left = rectItem.left + 1;
		rectButton.top = rectItem.top + 1;
		rectButton.bottom = rectItem.bottom - 1;
		rectButton.right = rectButton.left + pBitmapMenu->m_nBitmapExtent + 4;
		if (pImageInfo->IsDefaultImgList())
		{
			// This is a check box
			// The image rectangle needs to be in the middle of the button
			int iHorizontalDiff = rectButton.Width() - rectImage.Width();
			rectImage.OffsetRect(iHorizontalDiff / 2 - 1, 0);
		}
	}

	// Compute the rectangle for the text in front of the tab 
	rectText1=rectItem;
	rectText1.left=oxdc.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + oxdc.m_nGapBitmapText;
	rectText1.right=rectText1.left + pBitmapMenu->m_nStringExtent;

	// Compute the rectangle for the text after the tab (shortcut key)
	rectText2=rectItem;
	rectText2.right -= oxdc.m_nGapAcclrtrRight;
	rectText2.left=rectText2.right - pBitmapMenu->m_nAcceleratorExtent;
	int nGapTextHorz=(rectText2.left - rectText1.right) / 2;
	rectText2 -= CPoint(nGapTextHorz, 0);

	// Center the text vertically
	int nGapTextVert=(rectItem.Height() - pBitmapMenu->m_nTextHeight) / 2;
	rectText1.InflateRect(0, -nGapTextVert);
	rectText2.top=rectText1.top;
	rectText2.bottom=rectText1.bottom;
}

void COXMenuSkinXP::DrawBackground(CDC* pDC, UINT nState, COXImageInfo* /*pImageInfo*/, LPRECT lpItemRect, LPRECT /*lpButtonRect*/, COXBitmapMenu* pBitmapMenu)
{
	bool bSelected = (nState & ODS_SELECTED) != 0;
	bool bHidden = (nState & OXODS_HIDDEN) != 0;
	bool bDisabled = (nState & ODS_DISABLED) != 0;

	if(bSelected && !bDisabled)
	{
		// Selected item
		CPen pen;
		pen.CreatePen(PS_SOLID, 1, m_pSkinXP->GetActiveBorderColor());
		CBrush brush;
		brush.CreateSolidBrush(m_pSkinXP->GetHotItemColor());

		CPen* pOldPen = pDC->SelectObject(&pen);
		CBrush* pOldBrush = pDC->SelectObject(&brush);
		pDC->Rectangle(lpItemRect);
		pDC->SelectObject(pOldBrush);
		pDC->SelectObject(pOldPen);
	}
	else
	{
		// Normal item
		CBrush brushFace;
		brushFace.CreateSolidBrush(m_pSkinXP->GetMenuFaceColor());
		pDC->FillRect(lpItemRect, &brushFace);

		CBrush brushIconArea;
		if (bHidden)
			brushIconArea.CreateSolidBrush(m_pSkinXP->GetHiddenItemBackgroundColor());
		else
			brushIconArea.CreateSolidBrush(m_pSkinXP->GetBackgroundColor());
		CRect rectIconArea(lpItemRect);
		rectIconArea.right = m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + m_DimensionConstants.m_nGapRightBitmap;
		pDC->FillRect(rectIconArea, &brushIconArea);
	}
}

void COXMenuSkinXP::AdjustExpansionItemHeight(UINT& nItemHeight, COXBitmapMenu* /*pBitmapMenu*/)
{
	nItemHeight = nItemHeight / 2 + 1;
}

void COXMenuSkinXP::DrawButton(CDC* pDC, UINT nState,  COXImageInfo* /*pImageInfo*/, LPRECT lpButtonRect, COXBitmapMenu* /*pBitmapMenu*/)
{
	BOOL bSelected=nState & ODS_SELECTED;
	BOOL bChecked=nState & ODS_CHECKED;
	if (!bChecked)
		return;

	// Set up the brish and the pen
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, m_pSkinXP->GetActiveBorderColor());
	CBrush brush;
	if (bSelected)
		brush.CreateSolidBrush(m_pSkinXP->GetHotSelectedItemColor());
	else
		brush.CreateSolidBrush(m_pSkinXP->GetCheckedItemColor());

	// Draw the rectangle
	CPen* pOldPen = pDC->SelectObject(&pen);
	CBrush* pOldBrush = pDC->SelectObject(&brush);
	pDC->Rectangle(lpButtonRect);
	pDC->SelectObject(pOldBrush);
	pDC->SelectObject(pOldPen);
}

void COXMenuSkinXP::DrawImage(CDC* pDC, UINT nState, COXImageInfo* pImageInfo, LPRECT lpImageRect, COXBitmapMenu* /*pBitmapMenu*/)
{
	BOOL bDisabled=nState & ODS_DISABLED;
	BOOL bChecked=nState & ODS_CHECKED;
	BOOL bSelected=nState & ODS_SELECTED;

	if(pImageInfo->IsDefaultImgList() && !bChecked)
	{
		// The default checkmark is not drawn when it isn't checked
		return;
	}

	CRect imageRect(lpImageRect);
	int nIndex=pImageInfo->GetIndex();
	if(bSelected && pImageInfo->GetHotIndex()!=-1)
	{
		nIndex=pImageInfo->GetHotIndex();
	}

	if (bDisabled)
	{
		// Draw a gray image
		CBrush brush;
		brush.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
		HICON hIcon = pImageInfo->GetImageList()->ExtractIcon(nIndex);
		if (hIcon != NULL)
		{
			pDC->DrawState(imageRect.TopLeft(), imageRect.Size(), hIcon, DST_ICON | DSS_MONO, &brush);
			::DestroyIcon(hIcon);
		}
	}
	else if (bSelected && !bChecked)
	{
		// Raised with a shadow
		CImageList* pImageList = pImageInfo->GetImageList();
		CPoint ptTopLeft = imageRect.TopLeft();

		// Draw the image shadow first
		ptTopLeft.x += 1;
		ptTopLeft.y += 1;
		CBrush brush;
		brush.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
		CBrush* pOldBrush = pDC->SelectObject(&brush);		
		COLORREF clrOldBkColor = pDC->SetBkColor(RGB(255, 255, 255));
		pImageList->DrawIndirect(pDC, nIndex, ptTopLeft, imageRect.Size(),
			CPoint(0, 0), ILD_ROP | ILD_MASK, 0x00B8074A);
		pDC->SetBkColor(clrOldBkColor);
		pDC->SelectObject(pOldBrush);
		
		ptTopLeft.x -= 2;
		ptTopLeft.y -= 2;

		// Draw the image
		pImageList->Draw(pDC, nIndex, ptTopLeft, ILD_TRANSPARENT);
	}
	else
	{
		// Normal image
		pImageInfo->GetImageList()->Draw(pDC, nIndex, imageRect.TopLeft(), ILD_TRANSPARENT);
	}
}


COLORREF COXMenuSkinXP::DarkenColor(long lScale, COLORREF lColor)
{ 
	long R = MulDiv(GetRValue(lColor), (255 - lScale), 255);
	long G = MulDiv(GetGValue(lColor), (255 - lScale), 255);
	long B = MulDiv(GetBValue(lColor), (255 - lScale), 255);

	return RGB(R, G, B); 
}

// Wrapper function for ::GetPixel(...) that facilitates the shadow buffering
COLORREF GetShadowPixel(HDC hDC, int iXPos, int iYPos, bool bUseSavedShadow)
{
	if (bUseSavedShadow)
		return 0; // we don't need this pixel

	return ::GetPixel(hDC, iXPos, iYPos);

}

// Wrapper function for ::SetPixelV(...) that facilitates the shadow buffering
void SetShadowPixel(HDC hDC, int iXPos, int iYPos, COLORREF clr, bool bSaveShadow, bool bUseSavedShadow, OXSHADOWARRAY* pShadowArray, int& iIndex)
{
	if (bUseSavedShadow)
		::SetPixelV(hDC, iXPos, iYPos, pShadowArray->GetAt(iIndex++));
	else
		::SetPixelV(hDC, iXPos, iYPos, clr);

	if (bSaveShadow)
		pShadowArray->Add(clr);
}

// Draws a menu shadow for the given rectangle
void COXMenuSkinXP::DrawMenuShadow(HDC hDC, LPRECT lpRect, LPRECT lpItemRect, OXSHADOWARRAY* pShadowArray)
{
	int iArrayIndex = 0;
	bool bSaveShadow, bUseSavedShadow;
	if (pShadowArray == NULL)
	{
		// We don't need to use the shadow array
		bSaveShadow = false;
		bUseSavedShadow = false;
	}
	else if (pShadowArray->GetSize() == 0)
	{
		// Save the shadow in the array
		bSaveShadow = true;
		bUseSavedShadow = false;
	}
	else
	{
		// Use the shadow from the array
		bSaveShadow = false;
		bUseSavedShadow = true;
	}

	CRect rectMenuItem(lpItemRect); // the rectangle of the menu item in screen coordinates
	CRect rectMenu(lpRect);

	// Draw the shadow - get the pixels from the desktop, darken them
	// and place them on the popup window
	HDC hDesktopDC = ::GetWindowDC(::GetDesktopWindow());

	// copy desktop to mem DC and work with that for Get/Set pixel (Vista bug)
	CDC* pDC = CDC::FromHandle(hDesktopDC);

	CDC dcMem;
	dcMem.CreateCompatibleDC(pDC);
	CBitmap bitmap;
	bitmap.CreateCompatibleBitmap(pDC, rectMenu.Width(), rectMenu.Height());
	CBitmap *pOldBitmap = dcMem.SelectObject(&bitmap);
	
	// working with a mem bitmap at 0,0 for GetPixel
	dcMem.BitBlt(0,0, rectMenu.Width(), rectMenu.Height(), pDC, rectMenu.left, rectMenu.top, SRCCOPY);

	int x, y;
	CPoint pt;
	COLORREF clr;

	int iLeft = 4;	
	int iTop =  4;
	int iRight = rectMenu.Width();
	int iBottom = rectMenu.Height();

	// Right shadow 
	for (x = 1; x <= 4; x++)
	{ 
		// Copy the top right pixels
		for (y = 1; y <= 4; y++)
		{
			pt.x = iRight - x;
			pt.y = iTop + y - 4 - 1;
			clr = GetShadowPixel(dcMem.m_hDC, pt.x, pt.y, bUseSavedShadow);
			SetShadowPixel(hDC, pt.x, pt.y, clr, bSaveShadow, bUseSavedShadow, pShadowArray, iArrayIndex);
		}

		// Top right corner
		for (y = 4; y >= 1; y--)
		{
			pt.x = iRight - x;
			pt.y = iTop + y - 1;
			clr = GetShadowPixel(dcMem.m_hDC, pt.x, pt.y, bUseSavedShadow);
			if (!rectMenuItem.PtInRect(pt))
			{
				// Darken the pixel
				SetShadowPixel(hDC, pt.x, pt.y, DarkenColor(3 * x * y, clr), bSaveShadow, bUseSavedShadow, pShadowArray, iArrayIndex);
			}
		}

		// Vertical line
		for (y = iTop + 4; y <= iBottom - 4 - 1; y++)
		{
			pt.x = iRight - x;
			pt.y = y;
			clr = GetShadowPixel(dcMem.m_hDC, pt.x, pt.y, bUseSavedShadow);
			// TD review this ...
//			if (!rectMenuItem.PtInRect(pt))
//			{
				// Darken the pixel
				SetShadowPixel(hDC, pt.x, pt.y, DarkenColor(15 * x, clr), bSaveShadow, bUseSavedShadow, pShadowArray, iArrayIndex);
//			}
		}

		// Bottom right corner
		for (y = 1; y <= 4; y++)
		{
			pt.x = iRight - x;
			pt.y = iBottom - y;
			clr = GetShadowPixel(dcMem.m_hDC,  pt.x, pt.y, bUseSavedShadow);
			SetShadowPixel(hDC, pt.x, pt.y, DarkenColor(3 * x * y,  clr), bSaveShadow, bUseSavedShadow, pShadowArray, iArrayIndex);
		}
	} 

	// Bottom shadow
	for (y = 1; y <= 4; y++)
	{
		// Copy the bottom left pixels
		for (x = 1; x <= 4; x++)
		{
			pt.x = iLeft - x;
			pt.y = iBottom - y;
			clr = GetShadowPixel(dcMem.m_hDC, pt.x, pt.y, bUseSavedShadow);
			SetShadowPixel(hDC, pt.x, pt.y, clr, bSaveShadow, bUseSavedShadow, pShadowArray, iArrayIndex);
		}

		// Bottom left corner
		for (x = 1; x <= 4; x++)
		{
			pt.x = iLeft - x + 4;
			pt.y = iBottom - y;
			clr = GetShadowPixel(dcMem.m_hDC, pt.x, pt.y, bUseSavedShadow);
			if (!rectMenuItem.PtInRect(pt))
			{
				// Darken the pixel
				SetShadowPixel(hDC, pt.x, pt.y, DarkenColor(3 * (5 - x) * y, clr), bSaveShadow, bUseSavedShadow, pShadowArray, iArrayIndex);
			}
		}
		
		// Horizontal line
		for (x = iLeft + 4; x <= iRight - 5; x++)
		{
			pt.x = x;
			pt.y = iBottom - y;
			clr = GetShadowPixel(dcMem.m_hDC, pt.x, pt.y, bUseSavedShadow);
			if (!rectMenuItem.PtInRect(pt))
			{
				// Darken the pixel
				SetShadowPixel(hDC, pt.x, pt.y, DarkenColor(15 * y, clr), bSaveShadow, bUseSavedShadow, pShadowArray, iArrayIndex);
			}
		}
	} 
	// done with bitmap here
	dcMem.SelectObject(pOldBitmap);

	// Draw the intersection of the item rectangle and the shadow
	{
		CRect rectIntersection;
		rectIntersection.IntersectRect(lpRect, lpItemRect);
		rectIntersection.OffsetRect(-lpRect->left, -lpRect->top);
		FillIntersectionRect(hDC, rectIntersection);
		HPEN hPen = ::CreatePen(PS_SOLID, 1, m_pSkinXP->GetMenuBorderColor());
		HPEN hOldPen = (HPEN) ::SelectObject(hDC, hPen);

		if (rectIntersection.Width() > rectIntersection.Height())
		{
			// We have a bottom menu
			::MoveToEx(hDC, rectIntersection.left, rectIntersection.top, NULL);
			::LineTo(hDC, rectIntersection.left, rectIntersection.bottom);
			::MoveToEx(hDC, rectIntersection.right - 1, rectIntersection.top, NULL);
			::LineTo(hDC, rectIntersection.right - 1, rectIntersection.bottom);
		}
		else
		{
			// We have a right menu
			::MoveToEx(hDC, rectIntersection.left, rectIntersection.top, NULL);
			::LineTo(hDC, rectIntersection.right, rectIntersection.top);
			::MoveToEx(hDC, rectIntersection.left, rectIntersection.bottom - 1, NULL);
			::LineTo(hDC, rectIntersection.right, rectIntersection.bottom - 1);
		}
		::SelectObject(hDC, hOldPen);
		::DeleteObject(hPen);
	}

	::ReleaseDC(0, hDesktopDC);
}

/*
The four different types of menu item shadows are:
		 _______________
1.		|				| 
		|				|\
		|	  File		| |
		|				| |
		|_______________| |
 
		 _______________
2.		|				| 
		|				|
		|	  File		|
		|				|
		|_______________|
		   \_____________

	     _______________
3.		|				| 
		|				|\
		|	  File		| |
		|				| |
		|_______________| |
		 ________________/

		 _______________
4.		|				| | 
		|				| |
		|	  File		| |
		|				| |
		|_______________| |
		   \_____________/
*/
void COXMenuSkinXP::DrawMenuItemShadow(HDC hDC, LPRECT lpRect, UINT nMenuItemShadowType)
{
//	int iLeft = lpRect->left + 4;
//	int iTop = lpRect->top + 4;
//	int iRight = lpRect->right;
//	int iBottom = lpRect->bottom;

	// Draw the shadow - get the pixels from the desktop, darken them
	// and place them on the popup window
	HDC hDesktopDC = ::GetWindowDC(::GetDesktopWindow());
	int x, y;
	CPoint pt;
	COLORREF clr;

	CDC* pDC = CDC::FromHandle(hDesktopDC);

	CRect rectMenu(lpRect);

	CDC dcMem;
	dcMem.CreateCompatibleDC(pDC);
	CBitmap bitmap;
	bitmap.CreateCompatibleBitmap(pDC, rectMenu.Width(), rectMenu.Height());
	CBitmap *pOldBitmap = dcMem.SelectObject(&bitmap);
	
	// working with a mem bitmap at 0,0 for GetPixel
	dcMem.BitBlt(0,0, rectMenu.Width(), rectMenu.Height(), pDC, rectMenu.left, rectMenu.top, SRCCOPY);

	int iLeft = 4;	
	int iTop =  4;
	int iRight = rectMenu.Width();
	int iBottom = rectMenu.Height();

	if (nMenuItemShadowType != 2)
	{
		// Right shadow
		for (x = 1; x <= 4; x++)
		{ 
			if (nMenuItemShadowType != 4)
			{
				// Copy the top right pixels
				for (y = 1; y <= 4; y++)
				{
					pt.x = iRight - x;
					pt.y = iTop + y - 4 - 1;
					clr = GetPixel(dcMem.m_hDC, pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, clr);
				}

				// Top right corner
				for (y = 4; y >= 1; y--)
				{
					pt.x = iRight - x;
					pt.y = iTop + y - 1;
					clr = GetPixel(dcMem.m_hDC, pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, DarkenColor(3 * x * y, clr));
				}

				// Vertical line
				for (y = iTop + 4; y <= iBottom - 4 - 1; y++)
				{
					pt.x = iRight - x;
					pt.y = y;
					clr = GetPixel(dcMem.m_hDC, pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, DarkenColor(15 * x, clr));
				}
			}
			else
			{
				// Just a vertical line from the top
				for (y = 1; y <= iBottom - 4 - 1; y++)
				{
					pt.x = iRight - x;
					pt.y = y;
					clr = GetPixel(dcMem.m_hDC, pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, DarkenColor(15 * x, clr));
				}
			}

			// Bottom right corner
			if (nMenuItemShadowType != 1)
			{
				for (y = 1; y <= 4; y++)
				{
					pt.x = iRight - x;
					pt.y = iBottom - y;
					clr = GetPixel(dcMem.m_hDC,  pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, DarkenColor(3 * x * y,  clr));
				}
			}
		} 
	}

	if (nMenuItemShadowType != 1)
	{
		// Bottom shadow
		for (y = 1; y <= 4; y++)
		{
			if (nMenuItemShadowType != 3)
			{
				// Copy the bottom left pixels
				for (x = 1; x <= 4; x++)
				{
					pt.x = iLeft - x;
					pt.y = iBottom - y;
					clr = GetPixel(dcMem.m_hDC, pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, clr);
				}

				// Bottom left corner
				for (x = 1; x <= 4; x++)
				{
					pt.x = iLeft - x + 4;
					pt.y = iBottom - y;
					clr = GetPixel(dcMem.m_hDC, pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, DarkenColor(3 * (5 - x) * y, clr));
				}
				
				// Horizontal line
				for (x = iLeft + 4; x <= iRight - 5; x++)
				{
					pt.x = x;
					pt.y = iBottom - y;
					clr = GetPixel(dcMem.m_hDC, pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, DarkenColor(15 * y, clr));
				}
			}
			else
			{
				// Horizontal line stretching all the way from the left coordinate
				for (x = 1; x <= iRight - 5; x++)
				{
					pt.x = x;
					pt.y = iBottom - y;
					clr = GetPixel(dcMem.m_hDC, pt.x, pt.y);
//					pt.Offset(-lpRect->left, -lpRect->top);
					SetPixel(hDC, pt.x, pt.y, DarkenColor(15 * y, clr));
				}
			}
		}
	}

	dcMem.SelectObject(pOldBitmap);
	::ReleaseDC(0, hDesktopDC);
}


LRESULT COXMenuSkinXP::MenuPopupWndProc(WNDPROC origWndProc, HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
	//TRACE(_T("\n%u for %u"), nMsg, hWnd);

	switch (nMsg)
	{
		case WM_CREATE:
		{
			//TRACE(_T("\nWM_DESTROY for %u"), hWnd);
			_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
			COXBitmapMenu* pBitmapMenu = DYNAMIC_DOWNCAST(COXBitmapMenu,
				CMenu::FromHandle(pThreadState->m_hTrackingMenu));
			if (pBitmapMenu != NULL)
			{
				// Add this container window to the stack of COXBitmapMenu
				pBitmapMenu->m_PopupWndStack.Push(hWnd);
			}
		}
		break;

		case WM_DESTROY:
		{
			//TRACE(_T("\nWM_DESTROY for %u"), hWnd);
			_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
			COXBitmapMenu* pBitmapMenu = DYNAMIC_DOWNCAST(COXBitmapMenu,
				CMenu::FromHandle(pThreadState->m_hTrackingMenu));
			if (pBitmapMenu != NULL)
			{
				// Remove this window from the stack of COXBitmapMenu
				pBitmapMenu->m_PopupWndStack.Remove(hWnd);

				if (GetVersion() >= 0x80000000)
				{
					// For Win9x if this is a popup menu we need to refresh the previous menu
					HWND hPreviousWnd = pBitmapMenu->m_PopupWndStack.Pop();
					if (hPreviousWnd != NULL)
						::SendMessage(hPreviousWnd, WM_NCPAINT, 1, 0);
				}
			}
		}
		break;

		case WM_ERASEBKGND:
		{
			//TRACE(_T("\nWM_ERASEBKGND for %u"), hWnd);
			_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
			COXBitmapMenu* pBitmapMenu = DYNAMIC_DOWNCAST(COXBitmapMenu,
				CMenu::FromHandle(pThreadState->m_hTrackingMenu));
			if (pBitmapMenu != NULL)
			{
				return 0;
			}
		}
		break;

		case WM_NCPAINT:
		{
			// For Windows95/98/ME/NT/XP we must perform the drawing here
			//TRACE(_T("\nWM_NCPAINT for %u"), hWnd);
			_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
			COXBitmapMenu* pBitmapMenu = DYNAMIC_DOWNCAST(COXBitmapMenu,
				CMenu::FromHandle(pThreadState->m_hTrackingMenu));
			if (pBitmapMenu != NULL)
			{
				// Get the window DC
				HDC hDC;
				if (wParam != 1)
					hDC = GetDCEx(hWnd, (HRGN)wParam, DCX_WINDOW | DCX_INTERSECTRGN);
				else
					hDC = GetWindowDC(hWnd);
				if (hDC == NULL)
					return 0;
				
				CDC* pDC = CDC::FromHandle(hDC);

				// Get the frame rectangle
				CRect rectFrame;
				::GetWindowRect(hWnd, rectFrame);
				CPoint ptOffset = rectFrame.TopLeft();
				rectFrame.OffsetRect(-ptOffset.x, -ptOffset.y);
				rectFrame.right -= 4;
				rectFrame.bottom -= 4;

				// Exclude the client rectangle
				CRect rectClient(rectFrame);
				rectClient.DeflateRect(3, 3, 3, 3);
				pDC->ExcludeClipRect(rectClient);

				// Draw the shadow
				CRect rectWnd;
				::GetWindowRect(hWnd, rectWnd);
				CPoint ptTopLeft;
				m_mapHWNDtoPos.Lookup(hWnd, ptTopLeft);
				m_mapHWNDtoPos.RemoveKey(hWnd);

				DrawMenuShadow(pDC->m_hDC, rectWnd, pBitmapMenu->m_rectDropDownItem,
					pBitmapMenu->m_PopupWndStack.GetShadowArray(hWnd));
				
				// Draw the menu frame
				pDC->FillSolidRect(rectFrame, m_pSkinXP->GetMenuFaceColor());
				DrawItemStrip(pDC, CRect(rectFrame.left, rectFrame.top + 2,
					rectFrame.left + m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + 8,
					rectFrame.bottom - 4));
				CBrush brush;
				brush.CreateSolidBrush(m_pSkinXP->GetMenuBorderColor());
				pDC->FrameRect(rectFrame, &brush);

				// Interrupt the menu frame where it meets the menu item

				CRect rectDropDownItem(pBitmapMenu->m_rectDropDownItem);
				rectDropDownItem.OffsetRect(-ptOffset.x, -ptOffset.y);
				if (rectDropDownItem.bottom == rectFrame.top || rectDropDownItem.top == rectFrame.bottom)
				{
					// The drop down item is either on top or at the bottom of the menu
					rectDropDownItem.InflateRect(-1, 1);
					DrawJoiningLine(pDC, rectDropDownItem);
				}
				else if (rectDropDownItem.right == rectFrame.left || rectDropDownItem.left == rectFrame.right)
				{
					// The drop down item is either on the left or on the right of the menu
					rectDropDownItem.InflateRect(1, -1);
					DrawJoiningLine(pDC, rectDropDownItem);
				}

				::ReleaseDC(hWnd, hDC);
				return 0;
			}
		}
		break;

		case WM_PRINT:
		{
			// For Windows 2000 we must perform the drawing here

			//TRACE(_T("\nWM_PRINT"));
			_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
			COXBitmapMenu* pBitmapMenu = DYNAMIC_DOWNCAST(COXBitmapMenu,
				CMenu::FromHandle(pThreadState->m_hTrackingMenu));
			if (pBitmapMenu != NULL)
			{
				MSG msg;
				while (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != 0)
				{
					::TranslateMessage(&msg);
					::DispatchMessage(&msg);
				}	

				// Get the window rectangle
				CRect rectWindow;
				::GetWindowRect(hWnd, rectWindow);
				rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);

				// Draw the client to a memory dc
				CDC* pDC = CDC::FromHandle((HDC) wParam);
				CDC dcMem;
				dcMem.CreateCompatibleDC(pDC);
				CBitmap bitmap;
				bitmap.CreateCompatibleBitmap(pDC, rectWindow.Width(), rectWindow.Height());
				CBitmap* pOldBitmap = dcMem.SelectObject(&bitmap);
				dcMem.IntersectClipRect(rectWindow);

				// Get the client to paint
				CPoint ptOldOrigin = dcMem.SetViewportOrg(3, 3);
				SendMessage(hWnd, WM_PRINTCLIENT, (WPARAM) dcMem.m_hDC, lParam);
				dcMem.SetViewportOrg(ptOldOrigin);

				// Draw the shadow if not drawn by XP
				CRect rectWnd;
				::GetWindowRect(hWnd, rectWnd);
				CPoint ptTopLeft;
				m_mapHWNDtoPos.Lookup(hWnd, ptTopLeft);
				m_mapHWNDtoPos.RemoveKey(hWnd);
				int iWidth = rectWnd.Width();
				int iHeight = rectWnd.Height();
				rectWnd.left = ptTopLeft.x;
				rectWnd.top = ptTopLeft.y;
				rectWnd.right = ptTopLeft.x + iWidth;
				rectWnd.bottom = ptTopLeft.y + iHeight;

				DrawMenuShadow(dcMem.m_hDC, rectWnd, pBitmapMenu->m_rectDropDownItem, NULL);

				// Determine the frame rectangle
				CRect rectFrame(rectWindow);
				rectFrame.DeflateRect(0, 0, 4, 4);

				// Exclude the client rectangle
				CRect rectClient(rectFrame);
				rectClient.DeflateRect(3, 3, 3, 3);
				dcMem.ExcludeClipRect(rectClient);

				// Draw the menu frame
				dcMem.FillSolidRect(rectFrame, m_pSkinXP->GetMenuFaceColor());
				DrawItemStrip(&dcMem, CRect(rectFrame.left, rectFrame.top + 2,
					rectFrame.left + m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + 8,
					rectFrame.bottom - 4));
				CBrush brush;
				brush.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
				dcMem.FrameRect(rectFrame, &brush);

				// Interrupt the menu frame where it meets the menu item
				CRect rectDropDownItem(pBitmapMenu->m_rectDropDownItem);
				rectDropDownItem.OffsetRect(-rectWnd.left, -rectWnd.top);
				if (rectDropDownItem.bottom == rectFrame.top || rectDropDownItem.top == rectFrame.bottom)
				{
					// The drop down item is either on top or at the bottom of the menu
					rectDropDownItem.InflateRect(-1, 1);
					DrawJoiningLine(&dcMem, rectDropDownItem);
				}
				else if (rectDropDownItem.right == rectFrame.left || rectDropDownItem.left == rectFrame.right)
				{
					// The drop down item is either on the left or on the right of the menu
					rectDropDownItem.InflateRect(1, -1);
					DrawJoiningLine(&dcMem, rectDropDownItem);
				}

				// Copy the memory DC to the window DC
				pDC->BitBlt(0, 0, rectWindow.Width(), rectWindow.Height(), &dcMem, 0, 0, SRCCOPY);
				dcMem.SelectObject(pOldBitmap);

				return 0;
			}
		}
		break;

		case WM_WINDOWPOSCHANGING:
		{
			_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
			COXBitmapMenu* pBitmapMenu = DYNAMIC_DOWNCAST(COXBitmapMenu,
				CMenu::FromHandle(pThreadState->m_hTrackingMenu));
			if (pBitmapMenu != NULL)
			{
				// Make the window larger so it can fit the shadow
				WINDOWPOS* pWP = (WINDOWPOS*) lParam;
				pWP->cx += 4;
				pWP->cy += 4;

				// Save the top left point (only used for Windows 2000/XP)
				CPoint ptTopLeft;
				ptTopLeft.x = pWP->x;
				ptTopLeft.y = pWP->y;
				m_mapHWNDtoPos.SetAt(hWnd, ptTopLeft);
			}
		}
		break;

		default:
			break;
	}

	return ::CallWindowProc(origWndProc, hWnd, nMsg, wParam, lParam);	
}

void COXMenuSkinXP::DrawJoiningLine(CDC* pDC, LPRECT lpRect)
{
	CBrush brushBG;
	brushBG.CreateSolidBrush(m_pSkinXP->GetBackgroundColor());

	pDC->FrameRect(lpRect, &brushBG);
}

void COXMenuSkinXP::FillIntersectionRect(HDC hDC, LPRECT lpRect)
{
	CDC dc;
	dc.Attach(hDC);
	dc.FillSolidRect(lpRect, m_pSkinXP->GetBackgroundColor());
	dc.Detach();
}

void COXMenuSkinXP::DrawItemStrip(CDC* pDC, LPRECT lpStripRect)
{
	pDC->FillSolidRect(lpStripRect->left,
		lpStripRect->top,
		lpStripRect->right,
		lpStripRect->bottom,
		m_pSkinXP->GetBackgroundColor());
}

void COXMenuSkinXP::OnNcPaintCustomizePopupWnd(COXBitmapMenuPopupWnd* pPopupWnd)
{
	CWindowDC dc(pPopupWnd);

	CRect rectWindow;
	pPopupWnd->GetWindowRect(rectWindow);
	rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);

	// Draw the menu frame
	dc.FillSolidRect(rectWindow, m_pSkinXP->GetMenuFaceColor());
	dc.FillSolidRect(rectWindow.left, rectWindow.top + 2,
		rectWindow.left + m_DimensionConstants.m_nGapLeftBitmap + pPopupWnd->m_pBitmapMenu->m_nBitmapExtent + 7,
		rectWindow.bottom - 4, m_pSkinXP->GetBackgroundColor());
	CBrush brush;
	brush.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
	dc.FrameRect(rectWindow, &brush);
}

void COXMenuSkinXP::OnPaintShadowedItemWnd(COXShadowedItemWnd* pShadowedItemWnd)
{
	CPaintDC dc(pShadowedItemWnd); // device context for painting

	// Get the rectangle of the selected item
	CRect rectItem;
	pShadowedItemWnd->GetClientRect(rectItem);
	rectItem.DeflateRect(0, 0, 4, 4);

	// Draw the frame of the selected item
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_BTNSHADOW));
	CPen* pOldPen = dc.SelectObject(&pen);

	CRect rect;
	pShadowedItemWnd->GetWindowRect(rect);

	if (pShadowedItemWnd->m_nPosFlags & OX_TPM_BOTTOM)
	{
		// The popup menu is below the item
		dc.MoveTo(rectItem.left, rectItem.bottom);
		dc.LineTo(rectItem.left, rectItem.top);
		dc.LineTo(rectItem.right - 1, rectItem.top);
		dc.LineTo(rectItem.right - 1, rectItem.bottom + 1);
		dc.SelectObject(pOldPen);
		
		// Draw the shadow
		DrawMenuItemShadow(dc.m_hDC, rect, 1);
	}
	else if (pShadowedItemWnd->m_nPosFlags & OX_TPM_RIGHT)
	{
		// The popup menu is to the right of the item
		dc.MoveTo(rectItem.right, rectItem.top);
		dc.LineTo(rectItem.left, rectItem.top);
		dc.LineTo(rectItem.left, rectItem.bottom - 1);
		dc.LineTo(rectItem.right, rectItem.bottom - 1);
		dc.SelectObject(pOldPen);
		
		// Draw the shadow
		DrawMenuItemShadow(dc.m_hDC, rect, 2);	
	}
	else if (pShadowedItemWnd->m_nPosFlags & OX_TPM_TOP)
	{
		// The popup menu is above the item
		dc.MoveTo(rectItem.left, rectItem.top);
		dc.LineTo(rectItem.left, rectItem.bottom - 1);
		dc.LineTo(rectItem.right - 1, rectItem.bottom - 1);
		dc.LineTo(rectItem.right - 1, rectItem.top - 1);
		dc.SelectObject(pOldPen);
		
		// Draw the shadow
		DrawMenuItemShadow(dc.m_hDC, rect, 4);
	}
	else if (pShadowedItemWnd->m_nPosFlags & OX_TPM_LEFT)
	{
		// The popup menu is to the left of the item
		dc.MoveTo(rectItem.left, rectItem.top);
		dc.LineTo(rectItem.right, rectItem.top);
		dc.LineTo(rectItem.right, rectItem.bottom - 1);
		dc.LineTo(rectItem.left - 1, rectItem.bottom - 1);
		dc.SelectObject(pOldPen);
		
		// Draw the shadow
		DrawMenuItemShadow(dc.m_hDC, rect, 3);
	}
}

void COXMenuSkinXP::DrawText(CDC* pDC, UINT nState, LPCTSTR lpszText, LPRECT lpText1Rect, LPRECT lpText2Rect, COXBitmapMenu* /*pBitmapMenu*/)
{
	CRect text1Rect(lpText1Rect);
	CRect text2Rect(lpText2Rect);

	BOOL bDisabled=nState & ODS_DISABLED;

	// Split the text (in front of and after the tab)
	CString sText(lpszText);
	int nTabCharIndex=sText.Find(_T('\t'));
	CString sAfterTab;
	CString sBeforeTab;
	if(nTabCharIndex != -1)
	{
		sBeforeTab=sText.Left(nTabCharIndex);
		sAfterTab=sText.Mid(nTabCharIndex + 1);
	}
	else
	{
		sBeforeTab=sText;
		ASSERT(sAfterTab.IsEmpty());
	}

	// Draw the text
	// Sets the foreground color of the text based on its selection state
	COLORREF clrForeground;
	if (bDisabled)
		clrForeground = m_pSkinXP->GetDisabledMenuTextColor();
	else
		clrForeground = ::GetSysColor(COLOR_MENUTEXT);
	
	COLORREF clrOldForeground=pDC->SetTextColor(clrForeground);

	// set background filling mode
	int nOldBkMode=pDC->SetBkMode(TRANSPARENT);

	UINT nFlags=0;
	CRect newText2Rect(0,0,0,0);
	int nHorzAlign=0;
	pDC->DrawState(text1Rect.TopLeft(), text1Rect.Size(), sBeforeTab.GetBuffer(0),
		nFlags, TRUE, sBeforeTab.GetLength(), (CBrush*)NULL);

	// ... First calculate text width so we can right-align it
	pDC->DrawText(sAfterTab, newText2Rect, DT_CALCRECT | DT_SINGLELINE);
	nHorzAlign=text2Rect.Width() - newText2Rect.Width();
	if(!sAfterTab.IsEmpty())
	{
		pDC->DrawState(text2Rect.TopLeft() + CPoint(nHorzAlign, 0), 
			newText2Rect.Size(), sAfterTab.GetBuffer(0),
			nFlags, TRUE, sAfterTab.GetLength(), (CBrush*)NULL);
	}

	pDC->SetTextColor(clrOldForeground); 
	pDC->SetBkMode(nOldBkMode);
}

void COXMenuSkinXP::DrawSeparator(CDC* pDC, LPRECT lpItemRect, COXBitmapMenu* pBitmapMenu)
{
	CRect rectItem(lpItemRect);

	// First draw the background
	CBrush brushFace;
	brushFace.CreateSolidBrush(m_pSkinXP->GetMenuFaceColor());
	pDC->FillRect(lpItemRect, &brushFace);

	CBrush brushIconArea;
	brushIconArea.CreateSolidBrush(m_pSkinXP->GetBackgroundColor());
	CRect rectIconArea(lpItemRect);
	rectIconArea.right =m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + m_DimensionConstants.m_nGapRightBitmap;
	pDC->FillRect(rectIconArea, &brushIconArea);

	// Draw the separator line
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, m_pSkinXP->GetSeparatorColor());
	CPen* pOldPen = pDC->SelectObject(&pen);
	pDC->MoveTo(m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + m_DimensionConstants.m_nGapBitmapText,
		rectItem.CenterPoint().y);
	pDC->LineTo(rectItem.right, rectItem.CenterPoint().y);
	pDC->SelectObject(pOldPen);
}

void COXMenuSkinXP::DrawCustomized(CDC* pDC, LPRECT lpItemRect, COXBitmapMenu* /*pBitmapMenu*/)
{
	// Draw a black rectangle, 2 pixels wide
	CBrush brush;
	brush.CreateSolidBrush(::GetSysColor(COLOR_BTNTEXT));

	CRect rectItem(lpItemRect);
	pDC->FrameRect(rectItem, &brush);
	rectItem.DeflateRect(1, 1);
	pDC->FrameRect(rectItem, &brush);
}

void COXMenuSkinXP::DrawInsertMark(CDC* pDC, LPRECT lpItemRect, BOOL bBefore, COXBitmapMenu* /*pBitmapMenu*/)
{
	CRect itemRect(lpItemRect);
	itemRect.DeflateRect(2,0);

	ASSERT(pDC!=NULL);
	if(bBefore)
	{
		itemRect.top-=2;
		itemRect.bottom=itemRect.top+3;
	}
	else
	{
		itemRect.bottom+=1;
		itemRect.top=itemRect.bottom-3;
	}

	pDC->MoveTo(itemRect.TopLeft());
	pDC->LineTo(itemRect.left+1,itemRect.top+1);
	pDC->LineTo(itemRect.right-1,itemRect.top+1);
	pDC->LineTo(itemRect.right,itemRect.top);
	pDC->LineTo(itemRect.right,itemRect.bottom);
	pDC->LineTo(itemRect.right-1,itemRect.bottom-1);
	pDC->LineTo(itemRect.left+1,itemRect.bottom-1);
	pDC->LineTo(itemRect.left,itemRect.bottom);
	pDC->LineTo(itemRect.TopLeft());
}

void COXMenuSkinXP::DrawSubmenuItem(CDC* pDC, UINT nState, LPCTSTR lpszText, COXImageInfo* pImageInfo, 
									LPRECT lpItemRect, LPRECT lpButtonRect, LPRECT lpText1Rect, LPRECT lpText2Rect, COXBitmapMenu* pBitmapMenu)
{
	ASSERT(pDC!=NULL);
	pBitmapMenu->DrawBackground(pDC,nState,pImageInfo,lpItemRect,lpButtonRect);

	/*
	// draw right aligned arrow
	//
	COLORREF clrShadow=::GetSysColor(COLOR_BTNSHADOW);
	CFont font;
	CFont* pOldFont=NULL;
	if((font.CreateFont(GetSystemMetrics(SM_CYMENUCHECK), 0, 0, 0, 
		FW_NORMAL, 0, 0, 0, SYMBOL_CHARSET, 0,0,0,0, _T("Marlett"))) != NULL)
	{
		pOldFont=(CFont*)pDC->SelectObject(&font);
	}
	int nOldBkMode=pDC->SetBkMode(TRANSPARENT);
	COLORREF oldTextColor=CLR_NONE;
	if((nState&ODS_DISABLED)==ODS_DISABLED)
	{
		oldTextColor=pDC->SetTextColor(clrShadow);
	}

	// draw arrow symbol
	CRect rectText2(lpText2Rect);
	rectText2.OffsetRect(lpItemRect->right - rectText2.right, 0);
	pDC->DrawText(_T("8"),rectText2,DT_RIGHT|DT_VCENTER|DT_SINGLELINE);
	if((nState&ODS_DISABLED)==ODS_DISABLED)
	{
		pDC->SetTextColor(oldTextColor);
	}
	pDC->SetBkMode(nOldBkMode);
	if(pOldFont != NULL)
	{
		pDC->SelectObject(pOldFont);
	}
	//
	//////////////////////////////
	*/

	DrawText(pDC,nState,lpszText,lpText1Rect,lpText2Rect,pBitmapMenu);
}

void COXMenuSkinXP::DrawExpansionItem(CDC* pDC, LPRECT lpItemRect, UINT nState, COXBitmapMenu* /*pBitmapMenu*/)
{
	ASSERT(pDC!=NULL);

	BOOL bDisabled=nState & ODS_DISABLED;

	CFont font;
	VERIFY(font.CreateFont(GetSystemMetrics(SM_CYMENUCHECK),0,0,0,
		FW_NORMAL,0,0,0,SYMBOL_CHARSET,0,0,0,0,_T("Marlett")));
	CFont* pOldFont=pDC->SelectObject(&font);
	int nOldBkMode=pDC->SetBkMode(TRANSPARENT);
	
	COLORREF clrText;
	if (bDisabled)
		clrText = m_pSkinXP->GetSeparatorColor();
	else
		clrText = ::GetSysColor(COLOR_MENUTEXT);

	COLORREF oldTextColor=pDC->SetTextColor(clrText);

	pDC->DrawText(_T("6"),lpItemRect,DT_CENTER|DT_VCENTER|DT_SINGLELINE);

	pDC->SetTextColor(oldTextColor);
	pDC->SetBkMode(nOldBkMode);
	pDC->SelectObject(pOldFont);
}


// COXMenuSkin2003
//

COXMenuSkin2003::COXMenuSkin2003(COXSkin2003* pSkin2003) :
	COXMenuSkinXP(pSkin2003)
{

}

COXMenuSkin2003::~COXMenuSkin2003()
{

}

void COXMenuSkin2003::DrawBackground(CDC* pDC, UINT nState, COXImageInfo* /*pImageInfo*/, LPRECT lpItemRect, LPRECT /*lpButtonRect*/, COXBitmapMenu* pBitmapMenu)
{
	bool bSelected = (nState & ODS_SELECTED) != 0;
	bool bHidden = (nState & OXODS_HIDDEN) != 0;
	bool bDisabled = (nState & ODS_DISABLED) != 0;

	if(bSelected && !bDisabled)
	{
		// Selected item
		CPen pen;
		pen.CreatePen(PS_SOLID, 1, m_pSkinXP->GetActiveBorderColor());
		CBrush brush;
		brush.CreateSolidBrush(m_pSkinXP->GetHotItemColor());

		CPen* pOldPen = pDC->SelectObject(&pen);
		CBrush* pOldBrush = pDC->SelectObject(&brush);
		pDC->Rectangle(lpItemRect);
		pDC->SelectObject(pOldBrush);
		pDC->SelectObject(pOldPen);
	}
	else
	{
		// Normal item
		CBrush brushFace;
		brushFace.CreateSolidBrush(m_pSkinXP->GetMenuFaceColor());
		pDC->FillRect(lpItemRect, &brushFace);

		CRect rectIconArea(lpItemRect);
		rectIconArea.left -= 2;
		rectIconArea.right = m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + m_DimensionConstants.m_nGapRightBitmap;

		COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
		COLORREF clrMenuStripLeftColor = pSkin2003->GetMenuStripLeftColor();
		COLORREF clrMenuStripRightColor = pSkin2003->GetMenuStripRightColor();
		if (bHidden)
		{
			// We need to darken the colors
			clrMenuStripLeftColor = pSkin2003->Blend3Colors(
				clrMenuStripLeftColor, 0, 0, 0.93f, 0.07f, 0);
			
			clrMenuStripRightColor = pSkin2003->Blend3Colors(
				clrMenuStripRightColor, 0, 0, 0.93f, 0.07f, 0);
		}

		pSkin2003->GradientFill(pDC, rectIconArea,
			clrMenuStripLeftColor,
			clrMenuStripRightColor,
			GRADIENT_FILL_RECT_H);
	}
}

void COXMenuSkin2003::DrawItemStrip(CDC* pDC, LPRECT lpStripRect)
{
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	lpStripRect->bottom += 2;
	pSkin2003->GradientFill(pDC, lpStripRect,
		pSkin2003->GetMenuStripLeftColor(),
		pSkin2003->GetMenuStripRightColor(),
		GRADIENT_FILL_RECT_H);
}

void COXMenuSkin2003::DrawSeparator(CDC* pDC, LPRECT lpItemRect, COXBitmapMenu* pBitmapMenu)
{
	CRect rectItem(lpItemRect);

	// First draw the background
	CBrush brushFace;
	brushFace.CreateSolidBrush(m_pSkinXP->GetMenuFaceColor());
	pDC->FillRect(lpItemRect, &brushFace);

	CRect rectIconArea(lpItemRect);
	rectIconArea.left -= 2;
	rectIconArea.right = m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + m_DimensionConstants.m_nGapRightBitmap;

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	pSkin2003->GradientFill(pDC, rectIconArea,
		pSkin2003->GetMenuStripLeftColor(),
		pSkin2003->GetMenuStripRightColor(),
		GRADIENT_FILL_RECT_H);

	// Draw the separator line
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, m_pSkinXP->GetSeparatorColor());
	CPen* pOldPen = pDC->SelectObject(&pen);
	pDC->MoveTo(m_DimensionConstants.m_nGapLeftBitmap + pBitmapMenu->m_nBitmapExtent + m_DimensionConstants.m_nGapBitmapText,
		rectItem.CenterPoint().y);
	pDC->LineTo(rectItem.right, rectItem.CenterPoint().y);
	pDC->SelectObject(pOldPen);
}

void COXMenuSkin2003::DrawImage(CDC* pDC, UINT nState, COXImageInfo* pImageInfo, LPRECT lpImageRect, COXBitmapMenu* /*pBitmapMenu*/)
{
	BOOL bDisabled=nState & ODS_DISABLED;
	BOOL bChecked=nState & ODS_CHECKED;
	BOOL bSelected=nState & ODS_SELECTED;

	if(pImageInfo->IsDefaultImgList() && !bChecked)
	{
		// The default checkmark is not drawn when it isn't checked
		return;
	}

	CRect imageRect(lpImageRect);
	int nIndex=pImageInfo->GetIndex();
	if(bSelected && pImageInfo->GetHotIndex()!=-1)
	{
		nIndex=pImageInfo->GetHotIndex();
	}

	if (bDisabled)
	{
		// Draw a gray image
		CBrush brush;
		brush.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
		HICON hIcon = pImageInfo->GetImageList()->ExtractIcon(nIndex);
		if (hIcon != NULL)
		{
			pDC->DrawState(imageRect.TopLeft(), imageRect.Size(), hIcon, DST_ICON | DSS_MONO, &brush);
			::DestroyIcon(hIcon);
		}
	}
	else
	{
		// Normal image
		pImageInfo->GetImageList()->Draw(pDC, nIndex, imageRect.TopLeft(), ILD_TRANSPARENT);
	}
}

void COXMenuSkin2003::DrawJoiningLine(CDC* pDC, LPRECT lpRect)
{
	CRect rect(lpRect);

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	pSkin2003->GradientFill(pDC, rect,
		pSkin2003->GetMenubarItemLightColor(),
		pSkin2003->GetMenubarItemDarkColor(),
		GRADIENT_FILL_RECT_V);
}

void COXMenuSkin2003::OnPaintShadowedItemWnd(COXShadowedItemWnd* pShadowedItemWnd)
{
	CPaintDC dc(pShadowedItemWnd); // device context for painting

	TBBUTTON tbb;
	CToolBarCtrl& ctrl = pShadowedItemWnd->m_pCoolToolbar->GetToolBarCtrl();
	ctrl.GetButton(pShadowedItemWnd->m_iMenuItem, &tbb);
	CRect rectMenuItem;
	ctrl.GetItemRect(pShadowedItemWnd->m_iMenuItem, rectMenuItem);
	ctrl.ClientToScreen(rectMenuItem);
	pShadowedItemWnd->ScreenToClient(rectMenuItem);
	COXToolbarSkinXP* pToolbarSkinXP = (COXToolbarSkinXP*) pShadowedItemWnd->m_pCoolToolbar->GetToolbarSkin();
	
	// Draw the item gradient background
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	pSkin2003->GradientFill(&dc, rectMenuItem,
		pSkin2003->GetMenubarItemLightColor(),
		pSkin2003->GetMenubarItemDarkColor(),
		GRADIENT_FILL_RECT_V);

	// Draw the item
	pToolbarSkinXP->DrawItem(&dc, &tbb, rectMenuItem, pShadowedItemWnd->m_pCoolToolbar, FALSE);

	// Get the rectangle of the selected item
	CRect rectItem;
	pShadowedItemWnd->GetClientRect(rectItem);
	rectItem.DeflateRect(0, 0, 4, 4);

	// Draw the frame of the selected item
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, pSkin2003->GetMenuBorderColor());
	CPen* pOldPen = dc.SelectObject(&pen);

	CRect rect;
	pShadowedItemWnd->GetWindowRect(rect);

	if (pShadowedItemWnd->m_nPosFlags & OX_TPM_BOTTOM)
	{
		// The popup menu is below the item
		dc.MoveTo(rectItem.left, rectItem.bottom);
		dc.LineTo(rectItem.left, rectItem.top);
		dc.LineTo(rectItem.right - 1, rectItem.top);
		dc.LineTo(rectItem.right - 1, rectItem.bottom + 1);
		dc.SelectObject(pOldPen);
		
		// Draw the shadow
		DrawMenuItemShadow(dc.m_hDC, rect, 1);
	}
	else if (pShadowedItemWnd->m_nPosFlags & OX_TPM_RIGHT)
	{
		// The popup menu is to the right of the item
		dc.MoveTo(rectItem.right, rectItem.top);
		dc.LineTo(rectItem.left, rectItem.top);
		dc.LineTo(rectItem.left, rectItem.bottom - 1);
		dc.LineTo(rectItem.right, rectItem.bottom - 1);
		dc.SelectObject(pOldPen);
		
		// Draw the shadow
		DrawMenuItemShadow(dc.m_hDC, rect, 2);	
	}
	else if (pShadowedItemWnd->m_nPosFlags & OX_TPM_TOP)
	{
		// The popup menu is above the item
		dc.MoveTo(rectItem.left, rectItem.top);
		dc.LineTo(rectItem.left, rectItem.bottom - 1);
		dc.LineTo(rectItem.right - 1, rectItem.bottom - 1);
		dc.LineTo(rectItem.right - 1, rectItem.top - 1);
		dc.SelectObject(pOldPen);
		
		// Draw the shadow
		DrawMenuItemShadow(dc.m_hDC, rect, 4);
	}
	else if (pShadowedItemWnd->m_nPosFlags & OX_TPM_LEFT)
	{
		// The popup menu is to the left of the item
		dc.MoveTo(rectItem.left, rectItem.top);
		dc.LineTo(rectItem.right, rectItem.top);
		dc.LineTo(rectItem.right, rectItem.bottom - 1);
		dc.LineTo(rectItem.left - 1, rectItem.bottom - 1);
		dc.SelectObject(pOldPen);
		
		// Draw the shadow
		DrawMenuItemShadow(dc.m_hDC, rect, 3);
	}
}

// COXShortcutBarSkin
//

void COXShortcutBarSkin::DrawHeader(LPDRAWITEMSTRUCT lpDrawItemStruct, COXShortcutBar * bar)
{
	HSHBGROUP hGroup=(HSHBGROUP)(INT_PTR)lpDrawItemStruct->itemID;
	ASSERT(hGroup);

	BOOL bFlat=((bar->GetBarStyle() & SHBS_FLATGROUPBUTTON)==SHBS_FLATGROUPBUTTON);

	CDC dc;
	dc.Attach(lpDrawItemStruct->hDC);	

	// Get the header rect
	CRect rectHeader(lpDrawItemStruct->rcItem);	

	// Save DC
	int nSavedDC=dc.SaveDC();
	ASSERT(nSavedDC);

	// get background colors
	COLORREF clrBackground=bar->GetGroupHeaderBkColor(hGroup);
	VERIFY(clrBackground!=ID_COLOR_NONE);
	// invert colors for dragging group
	if(bar->GetDragGroup()==hGroup)
	{
		clrBackground=InvertColor(clrBackground);
	}

	// Draw FrameRect
	COLORREF clrTopLeft=UpdateColor(clrBackground,64);
	COLORREF clrBottomRight=UpdateColor(clrBackground,-128);
	if(bFlat)
	{
		if(bar->GetDragGroup()==hGroup || bar->m_bCreatingDragImage)
		{
			dc.Draw3dRect(rectHeader,clrTopLeft,clrBottomRight);
			rectHeader.DeflateRect(1,1);
			dc.Draw3dRect(rectHeader,clrBackground,clrBackground);
			rectHeader.DeflateRect(1,1);
		}
		else if(bar->m_hPressedGroup!=NULL)
		{
			if(hGroup==bar->m_hPressedGroup)
			{
				if(hGroup==bar->m_hLastMouseIsOverGroup)
				{
					dc.Draw3dRect(rectHeader,clrBottomRight,clrBackground);
					rectHeader.DeflateRect(1,1);
					dc.Draw3dRect(rectHeader,clrBottomRight,clrTopLeft);
					rectHeader.DeflateRect(1,1);
				}
				else
				{
					dc.Draw3dRect(rectHeader,clrTopLeft,clrBottomRight);
					rectHeader.DeflateRect(1,1);
					dc.Draw3dRect(rectHeader,clrBackground,clrBottomRight);
					rectHeader.DeflateRect(1,1);
				}
			}
			else
			{
				dc.Draw3dRect(rectHeader,clrTopLeft,clrBottomRight);
				rectHeader.DeflateRect(1,1);
				dc.Draw3dRect(rectHeader,clrBackground,clrBackground);
				rectHeader.DeflateRect(1,1);
			}
		}
		else
		{
			if(hGroup==bar->m_hLastMouseIsOverGroup)
			{
				dc.Draw3dRect(rectHeader,clrTopLeft,clrBottomRight);
				rectHeader.DeflateRect(1,1);
				dc.Draw3dRect(rectHeader,clrBackground,clrBottomRight);
				rectHeader.DeflateRect(1,1);
			}
			else
			{
				dc.Draw3dRect(rectHeader,clrTopLeft,clrBottomRight);
				rectHeader.DeflateRect(1,1);
				dc.Draw3dRect(rectHeader,clrBackground,clrBackground);
				rectHeader.DeflateRect(1,1);
			}
		}
	}
	else
	{
		dc.Draw3dRect(rectHeader,clrTopLeft,clrBottomRight);
		rectHeader.DeflateRect(1,1);
		dc.Draw3dRect(rectHeader,clrTopLeft,clrBottomRight);
		rectHeader.DeflateRect(1,1);
	}

	// Fill the background
	CBrush brush(clrBackground);
	dc.FillRect(rectHeader,&brush);	

	// Labels are offset by a certain amount  
	// This offset is related to the width of a space character
	int offset=dc.GetTextExtent(_T(" "),1).cx*2;
	rectHeader.left+=offset;
	rectHeader.right-=offset;	

	rectHeader.left+=DrawHeaderImage(hGroup, bar, &dc, rectHeader.TopLeft());

	DrawHeaderText(hGroup, bar, &dc, rectHeader, bar->GetGroupHeaderTextFormat(hGroup), false);

	DrawDropTarget(hGroup, bar, &dc, lpDrawItemStruct);

	// Restore dc	
	dc.RestoreDC(nSavedDC);
	// Detach the dc before returning	
	dc.Detach();	
}

void COXShortcutBarSkin::DrawItem(LPDRAWITEMSTRUCT /*lpDrawItemStruct*/)
{
}

int COXShortcutBarSkin::DrawHeaderImage(HSHBGROUP hGroup, COXShortcutBar * bar, CDC *pDC, POINT topLeft )
{
	int width = 0;

	// Draw header image
	int nImage=(bar->GetExpandedGroup()==hGroup) ? 
		bar->GetGroupImageExpanded(hGroup) : bar->GetGroupImage(hGroup);
	if(nImage>=0)
	{
		ASSERT(bar->m_pImageList);
		if(bar->m_pImageList!=NULL)
		{
			bar->m_pImageList->Draw(pDC,nImage, topLeft,ILD_TRANSPARENT);
			// Adjust the rect further
			IMAGEINFO iInfo;
			VERIFY(bar->m_pImageList->GetImageInfo(nImage,&iInfo));
			width=iInfo.rcImage.right-iInfo.rcImage.left;	
		}
	}

	return width;
}

void COXShortcutBarSkin::DrawHeaderText(HSHBGROUP hGroup, COXShortcutBar * bar, CDC * pDC, RECT rectHeader, UINT nFormat, bool alwaysBold)
{
	// Get the text and format	
	CString sText=bar->GetGroupText(hGroup);
	if(rectHeader.right>rectHeader.left && !sText.IsEmpty())
	{
		// set transparent mode
		pDC->SetBkMode(TRANSPARENT);

		// set text color
		COLORREF clrText=bar->GetGroupHeaderTextColor(hGroup);
		VERIFY(clrText!=ID_COLOR_NONE);
		// invert colors for dragging group
		if(bar->GetDragGroup()==hGroup)
			clrText=InvertColor(clrText);
		pDC->SetTextColor(clrText);	

		// set text font
		CFont* pOldFont=NULL;
		LPLOGFONT pLF=bar->GetGroupHeaderTextFont(hGroup);
		ASSERT(pLF);
		CFont font;
		VERIFY(font.CreateFontIndirect(pLF));
		pOldFont=pDC->SelectObject(&font);

		// update font if specific SHBS_BOLDEXPANDEDGROUP style is set
		if(((bar->GetBarStyle()&SHBS_BOLDEXPANDEDGROUP)!=0 && bar->GetExpandedGroup()==hGroup) || alwaysBold)
		{
			// make it bold
			CFont* pFont=pDC->GetCurrentFont();
			ASSERT(pFont);
			LOGFONT lf;
			VERIFY(pFont->GetLogFont(&lf));
			lf.lfWeight=lf.lfWeight==0 ? FW_NORMAL : lf.lfWeight;
			lf.lfWeight+=FW_BOLD-FW_NORMAL;
			lf.lfWeight=lf.lfWeight>1000 ? 1000 : lf.lfWeight;

			if(pOldFont!=NULL)
				pDC->SelectObject(pOldFont);
			if((HFONT)font!=NULL)
				font.DeleteObject();
			VERIFY(font.CreateFontIndirect(&lf));
			pOldFont=pDC->SelectObject(&font);
		}

		pDC->DrawText(sText,&rectHeader,nFormat);

		if(pOldFont!=NULL)
		{
			pDC->SelectObject(pOldFont);
		}
	}
}

void COXShortcutBarSkin::DrawDropTarget(HSHBGROUP hGroup, COXShortcutBar * bar, CDC *pDC, LPDRAWITEMSTRUCT lpDrawItemStruct)
{
	// get background colors
	COLORREF clrBackground=bar->GetGroupHeaderBkColor(hGroup);
	VERIFY(clrBackground!=ID_COLOR_NONE);
	// invert colors for dragging group
	if(bar->GetDragGroup()==hGroup)
	{
		clrBackground=InvertColor(clrBackground);
	}

	// drop target effect for drop target group
	HSHBGROUP hDragGroup=bar->GetDragGroup();
	HSHBGROUP hDropHilightGroup=bar->GetDropHilightGroup();
	if(hDropHilightGroup!=NULL && hDropHilightGroup==hGroup && 
		hDropHilightGroup!=hDragGroup)
	{
		ASSERT(hDragGroup);

		// use red color to draw the effect
		COLORREF clrDragDropEffect=RGB(255,0,0);
		// if the header background color is to close to red then use blue one
		if(IsColorCloseTo(clrDragDropEffect,clrBackground,64))
		{
			clrDragDropEffect=RGB(0,0,255);
		}

		// get orders of drop target and drag groups
		int nDropHilightOrder=bar->GetGroupOrder(hDropHilightGroup);
		ASSERT(bar->VerifyOrder(nDropHilightOrder));
		int nDragOrder=bar->GetGroupOrder(hDragGroup);
		ASSERT(bar->VerifyOrder(nDragOrder));

		CRect rect=lpDrawItemStruct->rcItem;	

		CBrush brush(clrDragDropEffect);
		pDC->FrameRect(rect,&brush);

		rect.DeflateRect(4,4);
		CPen pen(PS_SOLID,1,clrDragDropEffect);
		CPen* pOldPen=pDC->SelectObject(&pen);

		// drag group will be placed after drag target group
		if(nDropHilightOrder<nDragOrder)
		{
			// left up arrow
			pDC->MoveTo(rect.left+2,rect.top+9);
			pDC->LineTo(rect.left+2,rect.top+3);

			pDC->MoveTo(rect.left+3,rect.top+9);
			pDC->LineTo(rect.left+3,rect.top+3);

			pDC->MoveTo(rect.left+4,rect.top+9);
			pDC->LineTo(rect.left+4,rect.top+3);

			pDC->MoveTo(rect.left,rect.top+3);
			pDC->LineTo(rect.left+7,rect.top+3);

			pDC->MoveTo(rect.left+1,rect.top+2);
			pDC->LineTo(rect.left+6,rect.top+2);

			pDC->MoveTo(rect.left+2,rect.top+1);
			pDC->LineTo(rect.left+5,rect.top+1);

			pDC->MoveTo(rect.left+3,rect.top);
			pDC->LineTo(rect.left+4,rect.top);

			// right up arrow
			pDC->MoveTo(rect.right-2,rect.top+9);
			pDC->LineTo(rect.right-2,rect.top+3);

			pDC->MoveTo(rect.right-3,rect.top+9);
			pDC->LineTo(rect.right-3,rect.top+3);

			pDC->MoveTo(rect.right-4,rect.top+9);
			pDC->LineTo(rect.right-4,rect.top+3);

			pDC->MoveTo(rect.right,rect.top+3);
			pDC->LineTo(rect.right-7,rect.top+3);

			pDC->MoveTo(rect.right-1,rect.top+2);
			pDC->LineTo(rect.right-6,rect.top+2);

			pDC->MoveTo(rect.right-2,rect.top+1);
			pDC->LineTo(rect.right-5,rect.top+1);

			pDC->MoveTo(rect.right-3,rect.top);
			pDC->LineTo(rect.right-4,rect.top);
		}
		// drag group will be placed before drag target group
		else if(nDropHilightOrder>nDragOrder)
		{
			// left down arrow
			pDC->MoveTo(rect.left+2,rect.bottom-9);
			pDC->LineTo(rect.left+2,rect.bottom-3);

			pDC->MoveTo(rect.left+3,rect.bottom-9);
			pDC->LineTo(rect.left+3,rect.bottom-3);

			pDC->MoveTo(rect.left+4,rect.bottom-9);
			pDC->LineTo(rect.left+4,rect.bottom-3);

			pDC->MoveTo(rect.left,rect.bottom-3);
			pDC->LineTo(rect.left+7,rect.bottom-3);

			pDC->MoveTo(rect.left+1,rect.bottom-2);
			pDC->LineTo(rect.left+6,rect.bottom-2);

			pDC->MoveTo(rect.left+2,rect.bottom-1);
			pDC->LineTo(rect.left+5,rect.bottom-1);

			pDC->MoveTo(rect.left+3,rect.bottom);
			pDC->LineTo(rect.left+4,rect.bottom);

			// right down arrow
			pDC->MoveTo(rect.right-2,rect.bottom-9);
			pDC->LineTo(rect.right-2,rect.bottom-3);

			pDC->MoveTo(rect.right-3,rect.bottom-9);
			pDC->LineTo(rect.right-3,rect.bottom-3);

			pDC->MoveTo(rect.right-4,rect.bottom-9);
			pDC->LineTo(rect.right-4,rect.bottom-3);

			pDC->MoveTo(rect.right,rect.bottom-3);
			pDC->LineTo(rect.right-7,rect.bottom-3);

			pDC->MoveTo(rect.right-1,rect.bottom-2);
			pDC->LineTo(rect.right-6,rect.bottom-2);

			pDC->MoveTo(rect.right-2,rect.bottom-1);
			pDC->LineTo(rect.right-5,rect.bottom-1);

			pDC->MoveTo(rect.right-3,rect.bottom);
			pDC->LineTo(rect.right-4,rect.bottom);
		}
		else
		{
			ASSERT(FALSE);
		}

		if(pOldPen!=NULL)
		{
			pDC->SelectObject(pOldPen);
		}
	}
}


// COXShortcutBarSkinClassic
//
COLORREF COXShortcutBarSkinClassic::GetBackgroundColor(CWnd* /*pWnd*/)
{
	return GetSysColor(COLOR_3DSHADOW);
}

COLORREF COXShortcutBarSkinClassic::GetGroupTextColor(COXShortcutBar* /*pShortcutBar*/)
{
	return ::GetSysColor(COLOR_CAPTIONTEXT);
}

void COXShortcutBarSkinClassic::DrawItemBorder(CDC* pDC, LPCRECT lpRect, BOOL bHot, BOOL bSelected, COXSHBListCtrl* pSHBListCtrl)
{
	COLORREF clrTopLeft = UpdateColor(pSHBListCtrl->GetBkColor(), 64);
	COLORREF clrBottomRight = UpdateColor(pSHBListCtrl->GetBkColor(), -128);

	if (bSelected)
		pDC->Draw3dRect(lpRect, clrBottomRight, clrTopLeft); // sunken
	else if (bHot)
		pDC->Draw3dRect(lpRect, clrTopLeft, clrBottomRight); // raised
}

COLORREF COXShortcutBarSkinClassic::UpdateColor(COLORREF clr, int nOffset)
{
	ASSERT(abs(nOffset)<256);

	int rValue=GetRValue(clr)+nOffset;
	int gValue=GetGValue(clr)+nOffset;
	int bValue=GetRValue(clr)+nOffset;
	if(nOffset>0)
	{
		rValue=rValue>255 ? 255 : rValue;
		gValue=gValue>255 ? 255 : gValue;
		bValue=bValue>255 ? 255 : bValue;
	}
	else
	{
		rValue=rValue<0 ? 0 : rValue;
		gValue=gValue<0 ? 0 : gValue;
		bValue=bValue<0 ? 0 : bValue;
	}

	return RGB(rValue,gValue,bValue);
}

void COXShortcutBarSkinClassic::FillBackground(CDC* pDC, LPCRECT lpRect, CWnd* pWnd, BOOL bHasBackgroundColor, COLORREF clrBackgroundColor)
{
	CRect rect(lpRect);
	if (pWnd->IsKindOf(RUNTIME_CLASS(COXSHBListCtrl)))
			rect.OffsetRect(-rect.left, -rect.top);
	
	// Determine the background color
	if (bHasBackgroundColor)
		pDC->FillSolidRect(rect, clrBackgroundColor);
	else
		pDC->FillSolidRect(rect, GetBackgroundColor(pWnd));
}

// COXShortcutBarSkinXP
//

COXShortcutBarSkinXP::COXShortcutBarSkinXP(COXSkinXP* pSkinXP)
{
	m_pSkinXP = pSkinXP;
	m_bAnimate = true;
}

COLORREF COXShortcutBarSkinXP::GetBackgroundColor(CWnd* /*pWnd*/)
{
	return m_pSkinXP->GetBackgroundColor();
}

COLORREF COXShortcutBarSkinXP::GetGroupTextColor(COXShortcutBar* /*pShortcutBar*/)
{
	return ::GetSysColor(COLOR_WINDOWTEXT);
}

void COXShortcutBarSkinXP::DrawItemBorder(CDC* pDC, LPCRECT lpRect, BOOL bHot, BOOL bSelected, COXSHBListCtrl* /*pSHBListCtrl*/)
{
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, m_pSkinXP->GetActiveBorderColor());
	CPen* pOldPen = pDC->SelectObject(&pen);

	CBrush brush;
	if (bHot && bSelected)
		brush.CreateSolidBrush(m_pSkinXP->GetHotSelectedItemColor());
	else if (bHot)
		brush.CreateSolidBrush(m_pSkinXP->GetHotItemColor());
	else if (bSelected)
		brush.CreateSolidBrush(m_pSkinXP->GetCheckedItemColor());

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

	pDC->Rectangle(lpRect);

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

void COXShortcutBarSkinXP::FillBackground(CDC* pDC, LPCRECT lpRect, CWnd* pWnd, BOOL bHasBackgroundColor, COLORREF clrBackgroundColor)
{
	CRect rect(lpRect);
	if (pWnd->IsKindOf(RUNTIME_CLASS(COXSHBListCtrl)))
			rect.OffsetRect(-rect.left, -rect.top);
	
	if (bHasBackgroundColor)
		pDC->FillSolidRect(rect, clrBackgroundColor);	
	else
		pDC->FillSolidRect(rect, GetBackgroundColor(pWnd));
}

void COXShortcutBarSkinXP::DrawTopHeader(COXShortcutBar * /*bar*/, CDC * /*pDC*/) 
{
}


// COXShortcutBarSkin2003
//

COXShortcutBarSkin2003::COXShortcutBarSkin2003(COXSkin2003* pSkin2003) :
	COXShortcutBarSkinXP(pSkin2003)
{
	m_bAnimate = false;
}

COXShortcutBarSkin2003::~COXShortcutBarSkin2003()
{
	m_bAnimate = false;
}

void COXShortcutBarSkin2003::DrawHeader(LPDRAWITEMSTRUCT lpDrawItemStruct, COXShortcutBar * bar)
{
	HSHBGROUP hGroup=(HSHBGROUP)(INT_PTR)lpDrawItemStruct->itemID;
	ASSERT(hGroup);

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	CDC dc;
	dc.Attach(lpDrawItemStruct->hDC);	

	// Get the header rect
	CRect rect(lpDrawItemStruct->rcItem);	

	// Save DC
	int nSavedDC=dc.SaveDC();
	ASSERT(nSavedDC);

//	if(bar->GetDragGroup()==hGroup || bar->m_bCreatingDragImage)

	if(bar->GetExpandedGroup()==hGroup)
	{
		if(hGroup==bar->m_hLastMouseIsOverGroup)
		{
		pSkin2003->FourPointGradientFill(&dc, rect,
			pSkin2003->GetSelShortcutBarDarkColor(), 
			pSkin2003->GetSelShortcutBarDarkColor(), 
			pSkin2003->GetSelShortcutBarLightColor(),
			pSkin2003->GetSelShortcutBarLightColor()); 
		}
		else
		{
			pSkin2003->FourPointGradientFill(&dc, rect,
				pSkin2003->GetSelShortcutBarLightColor(),
				pSkin2003->GetSelShortcutBarLightColor(), 
				pSkin2003->GetSelShortcutBarDarkColor(), 
				pSkin2003->GetSelShortcutBarDarkColor());
		}
	}
	else if(hGroup==bar->m_hLastMouseIsOverGroup)
{
		pSkin2003->FourPointGradientFill(&dc, rect,
			pSkin2003->GetHotShortcutBarLightColor(),
			pSkin2003->GetHotShortcutBarLightColor(), 
			pSkin2003->GetHotShortcutBarDarkColor(), 
			pSkin2003->GetHotShortcutBarDarkColor());
	}
	else
	{
		pSkin2003->FourPointGradientFill(&dc, rect,
			pSkin2003->GetShortcutBarLightColor(),
			pSkin2003->GetShortcutBarLightColor(), 
			pSkin2003->GetShortcutBarDarkColor(), 
			pSkin2003->GetShortcutBarDarkColor());
	}

	dc.FillSolidRect(rect.left, rect.bottom - 1, rect.right - rect.left, 1, RGB(0, 45, 150));

	CRect rectImage(rect);
	rectImage.OffsetRect(6,6);
	
	rectImage.left += DrawHeaderImage(hGroup, bar, &dc, rectImage.TopLeft()) + 6;
	DrawHeaderText(hGroup, bar, &dc, rectImage, DT_VCENTER, true);
	DrawDropTarget(hGroup, bar, &dc, lpDrawItemStruct);


	// Restore dc	
	dc.RestoreDC(nSavedDC);
	// Detach the dc before returning	
	dc.Detach();
}


void COXShortcutBarSkin2003::FillBackground(CDC* pDC, LPCRECT lpRect, CWnd* pWnd, BOOL bHasBackgroundColor, COLORREF clrBackgroundColor)
{
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	CRect rect(lpRect);

	// If this DC belogs to the COXSHBListCtrl class we need to do some
	// coordinate transformations
	COXSHBListCtrl* pSHBListCtrl = DYNAMIC_DOWNCAST(COXSHBListCtrl, pWnd);
	if (pSHBListCtrl != NULL)
	{
		CRect rectClient;
		pSHBListCtrl->m_pShortcutBar->GetClientRect(rectClient);

		CRect rectShortcutBar, rectSHBListCtrl;
		pSHBListCtrl->m_pShortcutBar->GetWindowRect(rectShortcutBar);
		pSHBListCtrl->GetWindowRect(rectSHBListCtrl);

		CPoint ptOffset(rectSHBListCtrl.left - rectShortcutBar.left,
			rectSHBListCtrl.top - rectShortcutBar.top);

		rect.left = -rect.left - ptOffset.x;
		rect.top = -rect.top - ptOffset.y;
		rect.right = rect.left + rectClient.Width();
		rect.bottom = rect.top + rectClient.Height();
	}

	if (bHasBackgroundColor)
		pDC->FillSolidRect(rect, clrBackgroundColor);
	else
		pSkin2003->FourPointGradientFill(pDC, rect,
			pSkin2003->GetShortcutBarLightColor(),
			pSkin2003->GetShortcutBarDarkColor(), 
			pSkin2003->GetShortcutBarDarkColor(), 
			pSkin2003->GetShortcutBarDarkColor());
}

void COXShortcutBarSkin2003::DrawTopHeader(COXShortcutBar * bar, CDC * pDC) 
{	
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	CRect rcHeader;
	bar->GetClientRect(&rcHeader);
	rcHeader.bottom = DFLT_TOPHDRHEIGHT2003;
	pSkin2003->FourPointGradientFill(pDC, &rcHeader,  RGB(85,131,211), RGB(85,131,211), RGB(3,56,147), RGB(3,56,147));

	// Get the text and format	
	HSHBGROUP hGroup=bar->GetExpandedGroup();
	CString sText=bar->GetGroupText(hGroup);
	if(!sText.IsEmpty())
	{
		// set transparent mode
		pDC->SetBkMode(TRANSPARENT);

		// set text color
		pDC->SetTextColor(RGB(255, 255, 255));	

		// set text font
		CFont* pOldFont=NULL;
		LPLOGFONT pLF=bar->GetGroupHeaderTextFont(hGroup);
		ASSERT(pLF);
		pLF->lfHeight = 22;
		pLF->lfWeight= FW_BOLD;
		CFont font;
		VERIFY(font.CreateFontIndirect(pLF));
		pOldFont=pDC->SelectObject(&font);

		CRect rcText(rcHeader);
		rcText.OffsetRect(6, 2);

		pDC->DrawText(sText,&rcText, DT_VCENTER);

		if(pOldFont!=NULL)
		{
			pDC->SelectObject(pOldFont);
		}
	}

	pDC->ExcludeClipRect(rcHeader);
}

// COXSkin
//

COXSkin::COXSkin() :
	m_pToolbarSkin(NULL),
	m_pMenuSkin(NULL),
	m_pMenubarSkin(NULL),
	m_pDockbarSkin(NULL),
	m_pTabSkin(NULL),
	m_pShortcutBarSkin(NULL),
	m_pMiniFrameSkin(NULL),
	m_pStatusbarSkin(NULL),
	m_pFrameSkin(NULL)
{

}

COXSkin::~COXSkin()
{
	if (m_pToolbarSkin != NULL)
		delete m_pToolbarSkin;

	if (m_pMenuSkin != NULL)
		delete m_pMenuSkin;

	if (m_pMenubarSkin != NULL)
		delete m_pMenubarSkin;

	if (m_pDockbarSkin != NULL)
		delete m_pDockbarSkin;

	if (m_pTabSkin != NULL)
		delete m_pTabSkin;

	if (m_pShortcutBarSkin != NULL)
		delete m_pShortcutBarSkin;

	if (m_pMiniFrameSkin != NULL)
		delete m_pMiniFrameSkin;
	
	if (m_pStatusbarSkin != NULL)
		delete m_pStatusbarSkin;

	if (m_pFrameSkin != NULL)
		delete m_pFrameSkin;
}

CString COXSkin::GetName() const
{
	return m_strName;
}

COXToolbarSkin* COXSkin::GetToolbarSkin() const
{
	return m_pToolbarSkin;
}

COXMenuSkin* COXSkin::GetMenuSkin() const
{
	return m_pMenuSkin;
}

COXDockbarSkin* COXSkin::GetDockbarSkin() const
{
	return m_pDockbarSkin;
}

COXTabSkin* COXSkin::GetTabSkin() const
{
	return m_pTabSkin;
}

COXShortcutBarSkin* COXSkin::GetShortcutBarSkin() const
{
	return m_pShortcutBarSkin;
}

COXToolbarSkin* COXSkin::GetMenubarSkin() const
{
	return m_pMenubarSkin;
}

COXMiniFrameSkin* COXSkin::GetMiniFrameSkin() const
{
	return m_pMiniFrameSkin;
}

COXStatusbarSkin* COXSkin::GetStatusbarSkin() const
{
	return m_pStatusbarSkin;
}

COXFrameSkin* COXSkin::GetFrameSkin() const
{
	return m_pFrameSkin;
}

void COXSkin::SetToolbarSkin(COXToolbarSkin* pToolbarSkin)
{
	if (m_pToolbarSkin != NULL)
		delete m_pToolbarSkin;

	m_pToolbarSkin = pToolbarSkin;
}

void COXSkin::SetTabSkin(COXTabSkin* pTabSkin)
{
	if (m_pTabSkin != NULL)
		delete m_pTabSkin;

	m_pTabSkin = pTabSkin;
}

void COXSkin::SetStatusbarSkin(COXStatusbarSkin* pStatusbarSkin)
{
	if (m_pStatusbarSkin != NULL)
		delete m_pStatusbarSkin;

	m_pStatusbarSkin = pStatusbarSkin;
}

void COXSkin::SetShortcutBarSkin(COXShortcutBarSkin* pShortcutBarSkin)
{
	if (m_pShortcutBarSkin != NULL)
		delete m_pShortcutBarSkin;

	m_pShortcutBarSkin = pShortcutBarSkin;
}

void COXSkin::SetMiniFrameSkin(COXMiniFrameSkin* pMiniFrameSkin)
{
	if (m_pMiniFrameSkin != NULL)
		delete m_pMiniFrameSkin;

	m_pMiniFrameSkin = pMiniFrameSkin;
}

void COXSkin::SetMenuSkin(COXMenuSkin* pMenuSkin)
{
	if (m_pMenuSkin != NULL)
		delete m_pMenuSkin;

	m_pMenuSkin = pMenuSkin;
}

void COXSkin::SetMenubarSkin(COXToolbarSkin* pMenubarSkin)
{
	if (m_pMenubarSkin != NULL)
		delete m_pMenubarSkin;

	m_pMenubarSkin = pMenubarSkin;
}

void COXSkin::SetFrameSkin(COXFrameSkin* pFrameSkin)
{
	if (m_pFrameSkin != NULL)
		delete m_pFrameSkin;

	m_pFrameSkin = pFrameSkin;
}

void COXSkin::SetDockbarSkin(COXDockbarSkin* pDockbarSkin)
{
	if (m_pDockbarSkin != NULL)
		delete m_pDockbarSkin;

	m_pDockbarSkin = pDockbarSkin;
}

CString COXSkin::GetProperty(LPCTSTR lpszName) const
{
	CString strValue;
	BOOL bResult = m_mapProperties.Lookup(lpszName, strValue);
	if (bResult)
		return strValue;
	else
		return _T("");
}

void COXSkin::SetProperty(LPCTSTR lpszName, LPCTSTR lpszValue)
{
	m_mapProperties.SetAt(lpszName, lpszValue);
}


// COXSkinClassic
//

COXSkinClassic::COXSkinClassic()
{
	m_strName = _T("Classic");
    m_pToolbarSkin = new COXToolbarSkinClassic();
    m_pMenuSkin = new COXMenuSkinClassic();
    m_pMenubarSkin = new COXToolbarSkinClassic();
    m_pDockbarSkin = new COXDockbarSkinClassic();
    m_pTabSkin = new COXTabSkinClassic();
    m_pShortcutBarSkin = new COXShortcutBarSkinClassic();
	m_pMiniFrameSkin = new COXMiniFrameSkinClassic();
	m_pStatusbarSkin = new COXStatusbarSkinClassic();
	m_pFrameSkin = new COXFrameSkinClassic();
}

COXSkinClassic::~COXSkinClassic()
{

}

/////////////////////////////////////////////////////////////////////////////
// COXSkinnedApp

IMPLEMENT_DYNCREATE(COXSkinnedApp, CWinApp)

COXSkinnedApp::COXSkinnedApp() :
	m_pCurrentSkin(NULL)
{
	// Add the skins
	AddSkin(new COXSkinClassic());
	AddSkin(new COXSkinXP());
	AddSkin(new COXSkin2003());
	SetCurrentSkin(_T("Office XP"));
}

COXSkinnedApp::~COXSkinnedApp()
{
	POSITION pos = m_mapSkins.GetStartPosition();
	while (pos != NULL)
	{
		CString strName;
		COXSkin* pSkin;
		m_mapSkins.GetNextAssoc(pos, strName, (void*&) pSkin);
		delete pSkin;
	}

	m_mapSkins.RemoveAll();
}

COXSkin* COXSkinnedApp::GetCurrentSkin()
{
	return m_pCurrentSkin;
}

void COXSkinnedApp::AddSkin(COXSkin* pSkin)
{

	m_mapSkins.SetAt(pSkin->GetName(), pSkin);
}

BOOL COXSkinnedApp::RemoveSkin(LPCTSTR lpszName)
{
	return m_mapSkins.RemoveKey(lpszName);
}

COXSkin* COXSkinnedApp::GetSkin(LPCTSTR lpszName)
{
	COXSkin* pSkin;
	BOOL bRes = m_mapSkins.Lookup(lpszName, (void*&) pSkin);
	if (bRes == FALSE)
		pSkin = NULL;

	return pSkin;
}

BOOL COXSkinnedApp::SetCurrentSkin(COXSkin* pSkin)
{
	COXSkin* pTempSkin = NULL;
	BOOL bRes = m_mapSkins.Lookup(pSkin->GetName(), (void*&) pTempSkin);
	if (bRes == FALSE)
	{
		m_pCurrentSkin = NULL;
		return FALSE;
	}

	m_currentSkin = pSkin->GetType();

	m_pCurrentSkin = pTempSkin;

	// Redraw the main window and all its descendents
	// Redraw the main window and all its descendents
	CWnd* pWnd = AfxGetMainWnd();
	if (pWnd != NULL && ::IsWindow(pWnd->m_hWnd))
	{
		UpdateFloatingWindows(pWnd);
		UpdateChildrenRec(pWnd);
	}

	return TRUE;
}

BOOL COXSkinnedApp::SetCurrentSkin(OXAppSkins skin)
{
	switch (skin)
	{
	case OXSkinClassic:
		return SetCurrentSkin(_T("Classic"));
		break;
	case OXSkinOfficeXP:
		return SetCurrentSkin(_T("Office XP"));
		break;
	case OXSkinOffice2003:
		return SetCurrentSkin(_T("Office 2003"));
		break;
	default:
		return FALSE;
	}
}


BOOL COXSkinnedApp::SetCurrentSkin(LPCTSTR lpszName)
{
	COXSkin* pTempSkin = NULL;
	BOOL bRes = m_mapSkins.Lookup(lpszName, (void*&) pTempSkin);
	if (bRes == FALSE)
	{
		m_pCurrentSkin = NULL;
		return FALSE;
	}

	m_pCurrentSkin = pTempSkin;
	m_currentSkin = pTempSkin->GetType();

	// Redraw the main window and all its descendents
	CWnd* pWnd = AfxGetMainWnd();
	if (pWnd != NULL && ::IsWindow(pWnd->m_hWnd))
	{
		UpdateFloatingWindows(pWnd);
		UpdateChildrenRec(pWnd);
	}

	return TRUE;
}

// Causes all direct and indirect children to recalculate their layouts and redraw.
// This is a recursive function.
void COXSkinnedApp::UpdateChildrenRec(CWnd* pWnd)
{
	// Update this window first
	CRect rectClient;
	pWnd->GetClientRect(rectClient);

	if ((pWnd->GetStyle() & WS_MAXIMIZE) == 0)
		pWnd->SendMessage(WM_SIZE, 0, MAKELONG(rectClient.right, rectClient.bottom));

	pWnd->SetWindowPos(NULL, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOMOVE |
		SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);
	pWnd->RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);

	// Update all children
	CWnd* pChild = pWnd->GetWindow(GW_CHILD);
	while (pChild != NULL)
	{
		UpdateChildrenRec(pChild);
		pChild = pChild->GetWindow(GW_HWNDNEXT);
	}
}

// COXSkin2003
//

COXSkin2003::COXSkin2003() : COXSkinXP(TRUE)
{
	m_strName = _T("Office 2003");
    m_pToolbarSkin = new COXToolbarSkin2003(this);
    m_pMenuSkin = new COXMenuSkin2003(this);
    m_pMenubarSkin = new COXToolbarSkinXP(this);
    m_pDockbarSkin = new COXDockbarSkin2003(this);
    m_pTabSkin = new COXTabSkin2003(this);
    m_pShortcutBarSkin = new COXShortcutBarSkin2003(this);
	m_pMiniFrameSkin = new COXMiniFrameSkinXP(this);
	m_pStatusbarSkin = new COXStatusbarSkin2003(this);
	m_pFrameSkin = new COXFrameSkin2003(this);

	m_hMsimg32DLL = ::LoadLibrary(_T("Msimg32.dll"));
	if (m_hMsimg32DLL != NULL)
		m_fpGradientFill = ::GetProcAddress(m_hMsimg32DLL, "GradientFill");
}

COXSkin2003::~COXSkin2003()
{
	if (m_hMsimg32DLL != NULL)
		::FreeLibrary(m_hMsimg32DLL);
}

// This function wraps Msimg32.dll's ::GradientFill, so that we do not need SDK installed
// in order to use it.
BOOL COXSkin2003::GradientFill(CDC* pDC, LPCRECT lpRect, COLORREF clrLeft, COLORREF clrRight, ULONG dwMode)
{
	if (m_hMsimg32DLL == NULL)
		return GradientFillManual(pDC, lpRect, clrLeft, clrRight, dwMode);

	BOOL (PASCAL* pfnGradientFill)(
		HDC hdc,
		TRIVERTEX* pVertex,
		ULONG dwNumVertex, 
		PVOID pMesh,
		ULONG dwNumMesh,
		ULONG dwMode) = NULL;

	TRIVERTEX vert[2];
	GRADIENT_RECT grect;

	grect.UpperLeft = 0;
	vert[0].x = lpRect->left;
	vert[0].y = lpRect->top;
	vert[0].Alpha = 0;
	vert[0].Red = (COLOR16) (GetRValue(clrLeft) * 255);
	vert[0].Green = (COLOR16) (GetGValue(clrLeft) * 255);
	vert[0].Blue = (COLOR16) (GetBValue(clrLeft) * 255);

	grect.LowerRight = 1;
	vert[1].x = lpRect->right;
	vert[1].y = lpRect->bottom;
	vert[1].Alpha = 0;
	vert[1].Red = (COLOR16) (GetRValue(clrRight) * 255);
	vert[1].Green = (COLOR16) (GetGValue(clrRight) * 255);
	vert[1].Blue = (COLOR16) (GetBValue(clrRight) * 255);

	(FARPROC&) pfnGradientFill = m_fpGradientFill;
	return (*pfnGradientFill)(pDC->m_hDC, vert, 2, &grect, 1, dwMode);
}

// This function is just to accomodate platforms where the ::GradientFill() API is not present.
BOOL COXSkin2003::GradientFillManual(CDC* pDC, LPCRECT lpRect, COLORREF clrLeft, COLORREF clrRight, ULONG dwMode)
{
	CRect rect(lpRect);

	// First break down the colors
	int iLeftRed = GetRValue(clrLeft);
	int iLeftGreen = GetGValue(clrLeft);
	int iLeftBlue = GetBValue(clrLeft);

	int iRightRed = GetRValue(clrRight);
	int iRightGreen = GetGValue(clrRight);
	int iRightBlue = GetBValue(clrRight);

	if (dwMode == GRADIENT_FILL_RECT_H)
	{

		for (int i = 0; i < rect.Width(); i++)
		{
			// Determine the current color
			int iRed = iLeftRed + (i * (iRightRed - iLeftRed) / rect.Width());
			int iGreen = iLeftGreen + (i * (iRightGreen - iLeftGreen) / rect.Width());
			int iBlue = iLeftBlue + (i * (iRightBlue - iLeftBlue) / rect.Width());

			CPen pen;
			pen.CreatePen(PS_SOLID, 1, RGB(iRed, iGreen, iBlue));
			CPen* pOldPen = pDC->SelectObject(&pen);

			pDC->MoveTo(rect.left + i, rect.top);
			pDC->LineTo(rect.left + i, rect.bottom);

			pDC->SelectObject(pOldPen);
		}
	}
	else // vertical
	{
		for (int i = 0; i < rect.Height(); i++)
		{
			// Determine the current color
			int iRed = iLeftRed + (i * (iRightRed - iLeftRed) / rect.Height());
			int iGreen = iLeftGreen + (i * (iRightGreen - iLeftGreen) / rect.Height());
			int iBlue = iLeftBlue + (i * (iRightBlue - iLeftBlue) / rect.Height());

			CPen pen;
			pen.CreatePen(PS_SOLID, 1, RGB(iRed, iGreen, iBlue));
			CPen* pOldPen = pDC->SelectObject(&pen);

			pDC->MoveTo(rect.left, rect.top + i);
			pDC->LineTo(rect.right, rect.top + i);

			pDC->SelectObject(pOldPen);		
		}
	}
	
	return TRUE;
}

BOOL COXSkin2003::FourPointGradientFill(CDC* pDC, LPCRECT lpRect,
									  COLORREF clrTopLeft, COLORREF clrTopRight,
									  COLORREF clrBottomLeft, COLORREF clrBottomRight)
{
	if (m_hMsimg32DLL == NULL)
		return FourPointGradientFillManual(pDC, lpRect, clrTopLeft, clrTopRight,
			clrBottomLeft, clrBottomRight);

	BOOL (PASCAL* pfnGradientFill)(
		HDC hdc,
		TRIVERTEX* pVertex,
		ULONG dwNumVertex, 
		PVOID pMesh,
		ULONG dwNumMesh,
		ULONG dwMode) = NULL;

	TRIVERTEX vert[6];
	GRADIENT_TRIANGLE gtriangle[2];

	// First triangle	 _______
	//					|      /
	//					|    /
	//					|  /
	//					|/

	gtriangle[0].Vertex1 = 0;
	vert[0].x = lpRect->left;
	vert[0].y = lpRect->top;
	vert[0].Alpha = 0;
	vert[0].Red = (COLOR16) (GetRValue(clrTopLeft) * 255);
	vert[0].Green = (COLOR16) (GetGValue(clrTopLeft) * 255);
	vert[0].Blue = (COLOR16) (GetBValue(clrTopLeft) * 255);

	gtriangle[0].Vertex2 = 1;
	vert[1].x = lpRect->right;
	vert[1].y = lpRect->top;
	vert[1].Alpha = 0;
	vert[1].Red = (COLOR16) (GetRValue(clrTopRight) * 255);
	vert[1].Green = (COLOR16) (GetGValue(clrTopRight) * 255);
	vert[1].Blue = (COLOR16) (GetBValue(clrTopRight) * 255);

	gtriangle[0].Vertex3 = 2;
	vert[2].x = lpRect->left;
	vert[2].y = lpRect->bottom;
	vert[2].Alpha = 0;
	vert[2].Red = (COLOR16) (GetRValue(clrBottomLeft) * 255);
	vert[2].Green = (COLOR16) (GetGValue(clrBottomLeft) * 255);
	vert[2].Blue = (COLOR16) (GetBValue(clrBottomLeft) * 255);


	// Second triangle		    /|
	//						  /	 |
	//						/	 |
	//					  /______|
	//				

	gtriangle[1].Vertex1 = 3;
	vert[3].x = lpRect->right;
	vert[3].y = lpRect->top;
	vert[3].Alpha = 0;
	vert[3].Red = (COLOR16) (GetRValue(clrTopRight) * 255);
	vert[3].Green = (COLOR16) (GetGValue(clrTopRight) * 255);
	vert[3].Blue = (COLOR16) (GetBValue(clrTopRight) * 255);

	gtriangle[1].Vertex2 = 4;
	vert[4].x = lpRect->left;
	vert[4].y = lpRect->bottom;
	vert[4].Alpha = 0;
	vert[4].Red = (COLOR16) (GetRValue(clrBottomLeft) * 255);
	vert[4].Green = (COLOR16) (GetGValue(clrBottomLeft) * 255);
	vert[4].Blue = (COLOR16) (GetBValue(clrBottomLeft) * 255);

	gtriangle[1].Vertex3 = 5;
	vert[5].x = lpRect->right;
	vert[5].y = lpRect->bottom;
	vert[5].Alpha = 0;
	vert[5].Red = (COLOR16) (GetRValue(clrBottomRight) * 255);
	vert[5].Green = (COLOR16) (GetGValue(clrBottomRight) * 255);
	vert[5].Blue = (COLOR16) (GetBValue(clrBottomRight) * 255);


	(FARPROC&) pfnGradientFill = m_fpGradientFill;
	return (*pfnGradientFill)(pDC->m_hDC, vert, 6, gtriangle, 2, GRADIENT_FILL_TRIANGLE);
}

// This function is just to accomodate platforms where the ::GradientFill() API is not present.
BOOL COXSkin2003::FourPointGradientFillManual(CDC* pDC, LPCRECT lpRect,
									  COLORREF clrTopLeft, COLORREF clrTopRight,
									  COLORREF clrBottomLeft, COLORREF /*clrBottomRight*/)
{
	CRect rect(lpRect);

	if (rect.Width() < rect.Height())
		return GradientFillManual(pDC, lpRect, clrTopLeft, clrTopRight, GRADIENT_FILL_RECT_H);
	else
		return GradientFillManual(pDC, lpRect, clrTopLeft, clrBottomLeft, GRADIENT_FILL_RECT_V);
}

void COXSkin2003::DrawGripperStripes(CDC* pDC, CRect &rect, bool bHorizontal)
{
	CPen pen, penShadow;
	pen.CreatePen(PS_SOLID, 1, GetGripperColor());
	penShadow.CreatePen(PS_SOLID, 1, GetGripperStripesShadowColor());
	CPen* pOldPen = pDC->SelectObject(&pen);

	if (bHorizontal)
	{
		int iYPos = rect.top;
		while (iYPos <= rect.bottom)
		{
			pDC->MoveTo(rect.left, iYPos);
			pDC->LineTo(rect.right, iYPos);
			pDC->MoveTo(rect.left, iYPos + 1);
			pDC->LineTo(rect.right, iYPos + 1);

			CPen* pPrevPen = pDC->SelectObject(&penShadow);
			pDC->MoveTo(rect.left + 1, iYPos + 2);
			pDC->LineTo(rect.right + 1, iYPos + 1);
			pDC->MoveTo(rect.left + 1, iYPos + 2);
			pDC->LineTo(rect.right + 1, iYPos + 2);
			pDC->SelectObject(pPrevPen);

			iYPos += 4;
		}
	}
	else // vertical
	{
		int iXPos = rect.left;
		while (iXPos <= rect.right)
		{
			pDC->MoveTo(iXPos, rect.top);
			pDC->LineTo(iXPos, rect.bottom);
			pDC->MoveTo(iXPos + 1, rect.top);
			pDC->LineTo(iXPos + 1, rect.bottom);			
		
			CPen* pPrevPen = pDC->SelectObject(&penShadow);
			pDC->MoveTo(iXPos + 2, rect.top + 1);
			pDC->LineTo(iXPos + 1, rect.bottom + 1);
			pDC->MoveTo(iXPos + 2, rect.top + 1);
			pDC->LineTo(iXPos + 2, rect.bottom + 1);
			pDC->SelectObject(pPrevPen);			
			
			iXPos += 4;
		}
	}

	pDC->SelectObject(pOldPen);
}

// Draws an Office 2003 style frame button with a gradient background
void COXSkin2003::DrawFrameButton(CDC* pDC, CRect& rcButton, UINT uType, BOOL bDisabled, BOOL bInvertFace, COLORREF clrBackground, CWnd* pParentWnd)
{
	// First determine some colors
	COLORREF clrDisabled = 0;
	if (bDisabled)
	{
		if (bInvertFace)
		{
			bInvertFace = FALSE;
			clrDisabled = ModifyColor(clrBackground, 64, 64, 64);
		}
		else
			clrDisabled = ModifyColor(clrBackground, -96, -96, -96);
	}

	// Get the cursor position in window coordinates
	CPoint ptCursor;
	::GetCursorPos(&ptCursor);
	CRect rectWindow;
	pParentWnd->GetWindowRect(rectWindow);
	ptCursor.Offset(-rectWindow.left, -rectWindow.top);

	bool bLeftButtonDown = (pParentWnd->GetCapture() != NULL);

	// Determine the colors
	CBrush brush;
	brush.m_hObject = NULL;
	if (bLeftButtonDown && rcButton.PtInRect(ptCursor))
	{
		// Pressed
		brush.CreateSolidBrush(GetHotSelectedItemColor());
	}
	else if (rcButton.PtInRect(ptCursor))
	{
		// Hot
		brush.CreateSolidBrush(GetHotItemColor());
	}

	///////////////////////// Perform the drawing
	// Draw to a memory dc to avoid flashing
	CDC dc;
	dc.CreateCompatibleDC(pDC);
	CBitmap bmpMem;
	CRect rectMem(rcButton);
	rectMem.OffsetRect(-rectMem.left, -rectMem.top);
	bmpMem.CreateCompatibleBitmap(pDC, rectMem.Width(), rectMem.Height());
	CBitmap* pOldBmp = dc.SelectObject(&bmpMem);

	if (brush.m_hObject != NULL && !bDisabled)
	{
		// Draw a frame
		CBrush* pOldBrush = dc.SelectObject(&brush);
		CPen penBorder;
		penBorder.CreatePen(PS_SOLID, 1, GetActiveBorderColor());
		CPen* pOldPen = dc.SelectObject(&penBorder);
		dc.Rectangle(rectMem);
		dc.SelectObject(pOldPen);
		dc.SelectObject(pOldBrush);
	}
	else
	{
		if (pParentWnd->IsKindOf(RUNTIME_CLASS(COXMenuBar)))
		{
			// Draw a gradient background
			CRect rectMain;
			pParentWnd->GetParentFrame()->GetWindowRect(rectMain);

			// Get the botton screen rectangle
			CRect rectButton(rcButton);
			pParentWnd->GetParentFrame()->ClientToScreen(rectButton);

			int iWidth = ::GetSystemMetrics(SM_CXSCREEN);
			if (iWidth < rectMain.Width())
				iWidth = rectMain.Width();

			CRect rectGradient;
			rectGradient.left = rectMain.left - rectButton.left;
			rectGradient.right = rectGradient.left + iWidth;
			rectGradient.top = 0;
			rectGradient.bottom = rectButton.Height();

			CRect rectSolid(rectGradient);
			rectGradient.right = rectGradient.CenterPoint().x;
			rectSolid.left = rectGradient.right;

			GradientFill(&dc, rectGradient,
				GetDockbarLeftColor(),
				GetDockbarRightColor(),
				GRADIENT_FILL_RECT_H);
			dc.FillSolidRect(rectSolid, GetDockbarRightColor());
		}
		else if (pParentWnd->IsKindOf(RUNTIME_CLASS(COXSizeControlBar)))
		{
			// Draw a gradient background
			
			COXSizeControlBar* pControlBar = (COXSizeControlBar*) pParentWnd;
			
			CRect rectMain = pControlBar->m_rectGripper;
			pControlBar->ClientToScreen(rectMain);

			// Get the botton screen rectangle
			CRect rectButton(rcButton);
			pParentWnd->ClientToScreen(rectButton);

			CRect rectGradient;
			if (pControlBar->m_dwStyle & CBRS_ORIENT_HORZ)
			{
				rectGradient.left = -rcButton.left;
				rectGradient.right = rectGradient.left + rectMain.Width();
				rectGradient.top = 0;
				rectGradient.bottom = rcButton.Height();

				GradientFill(&dc, rectGradient,
					GetControlBarLightColor(),
					GetControlBarDarkColor(),
					GRADIENT_FILL_RECT_H);
			}
			else
			{
				rectGradient.left = 0;
				rectGradient.right = rcButton.Width();
				rectGradient.top = -rcButton.top;
				rectGradient.bottom = rectGradient.top + rectMain.Height();

				GradientFill(&dc, rectGradient,
					GetControlBarLightColor(),
					GetControlBarDarkColor(),
					GRADIENT_FILL_RECT_V);
			}
		}
	}

	// Draw the symbol transparently
	CDC dcSymbol;
	dcSymbol.CreateCompatibleDC(pDC);
	CBitmap bmpSymbol;
	CRect rcSymbol(rectMem);
	rcSymbol.DeflateRect(2, 2);
	bmpSymbol.CreateCompatibleBitmap(pDC, rcSymbol.Width(), rcSymbol.Height());
	CBitmap* pOldBitmap = dcSymbol.SelectObject(&bmpSymbol);
	dcSymbol.DrawFrameControl(CRect(-2, -2, rcSymbol.Width() + 2, rcSymbol.Height() + 2),
		DFC_CAPTION, DFCS_FLAT | uType);

	COLORREF clrTransparent = ::GetSysColor(COLOR_BTNFACE);

	if (bLeftButtonDown && rcButton.PtInRect(ptCursor))
	{
		// Pressed, so invert the face color of the symbol
		dcSymbol.BitBlt(0, 0, rcSymbol.Width(), rcSymbol.Height(), &dcSymbol, 0, 0, PATINVERT);
		clrTransparent = InvertColor(clrTransparent);
	}
	else if (bInvertFace && !(rcButton.PtInRect(ptCursor)))
	{
		// Invert the face color
		dcSymbol.BitBlt(0, 0, rcSymbol.Width(), rcSymbol.Height(), &dcSymbol, 0, 0, PATINVERT);
		clrTransparent = InvertColor(clrTransparent);
	}

	dcSymbol.SelectObject(pOldBitmap);
	DrawTransparentBitmap(&bmpSymbol, &dc, 2, 2, rcSymbol.Width(), rcSymbol.Height(), clrTransparent);

	if (bDisabled)
	{
		// Draw a disabled button
		dc.SelectObject(pOldBmp);

		CBitmap bmpDisabled;
		bmpDisabled.CreateCompatibleBitmap(pDC, rectMem.Width(), rectMem.Height());
		pOldBmp = dc.SelectObject(&bmpDisabled);

		dc.FillSolidRect(CRect(0, 0, rcButton.Width(), rcButton.Height()), clrDisabled);
		DrawTransparentBitmap(&bmpMem, &dc, 0, 0, rcButton.Width(), rcButton.Height(), 0);

		// Copy the memory dc to the real dc
		pDC->BitBlt(rcButton.left, rcButton.top, rcButton.Width(), rcButton.Height(), &dc, 0, 0, SRCCOPY);
		dc.SelectObject(pOldBmp);	
	}
	else
	{
		// Copy the memory dc to the real dc
		pDC->BitBlt(rcButton.left, rcButton.top, rcButton.Width(), rcButton.Height(), &dc, 0, 0, SRCCOPY);
		dc.SelectObject(pOldBmp);
	}
}


COLORREF COXSkin2003::GetToolbarLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.95f, 0.05f, 0);
	}
	else
	{
		// 78% window background color, 22% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.78f, 0.22f, 0);
	}
}

COLORREF COXSkin2003::GetToolbarDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.2f, 0.8f, 0);
	}
	else
	{
		// 4% window background color, 96% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.04f, 0.96f, 0);
	}
}

COLORREF COXSkin2003::GetMenuStripLeftColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.95f, 0.05f, 0);
	}
	else
	{
		// 86% window background color, 14% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.86f, 0.14f, 0);
	}
}

COLORREF COXSkin2003::GetMenuStripRightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.2f, 0.8f, 0);
	}
	else
	{
		// 8% window background color, 92% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.08f, 0.92f, 0);
	}
}

// Returns the color of the gripper
COLORREF COXSkin2003::GetGripperColor()
{

	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT),0 , 0,
			0.7f, 0.3f, 0);
	}
	else
	{
		return COXSkinXP::GetGripperColor();
	}
}

COLORREF COXSkin2003::GetGripperStripesShadowColor()
{
	return ::GetSysColor(COLOR_WINDOW);
}

COLORREF COXSkin2003::GetControlBarLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.95f, 0.05f, 0);
	}
	else
	{
		// 73% window background color, 27% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.73f, 0.27f, 0);
	}
}

COLORREF COXSkin2003::GetControlBarDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.2f, 0.8f, 0);
	}
	else
	{
		return ::GetSysColor(COLOR_3DFACE);
	}
}

COLORREF COXSkin2003::GetDockbarLeftColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.5f, 0.5f, 0);
	}
	else
	{
		return ::GetSysColor(COLOR_3DFACE);
	}
}

COLORREF COXSkin2003::GetDockbarRightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.7f, 0.3f, 0);
	}
	else
	{
		// 80% window background color, 20% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.8f, 0.2f, 0);
	}
}

COLORREF COXSkin2003::GetTabBackgroundLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.95f, 0.05f, 0);
	}
	else
	{
		// 78% window background color, 22% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.78f, 0.22f, 0);
	}
}

COLORREF COXSkin2003::GetTabBackgroundDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.2f, 0.8f, 0);
	}
	else
	{
		// 4% window background color, 96% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.04f, 0.96f, 0);
	}
}

COLORREF COXSkin2003::GetTabItemLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.95f, 0.05f, 0);
	}
	else
	{
		// 73% window background color, 27% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.73f, 0.27f, 0);
	}
}

COLORREF COXSkin2003::GetTabItemDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return GetDockbarRightColor();
	}
	else
	{
		return ::GetSysColor(COLOR_3DFACE);
	}
}

COLORREF COXSkin2003::GetMenubarItemLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.95f, 0.05f, 0);
	}
	else
	{
		// 86% window background color, 14% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.86f, 0.14f, 0);
	}
}

COLORREF COXSkin2003::GetMenubarItemDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.2f, 0.8f, 0);
	}
	else
	{
		// 58% window background color, 42% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.58f, 0.42f, 0);
	}
}

COLORREF COXSkin2003::GetShortcutBarLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.95f, 0.05f, 0);
	}
	else
	{
		// 86% window background color, 14% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.86f, 0.14f, 0);
	}
}

COLORREF COXSkin2003::GetShortcutBarDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.5f, 0.5f, 0);
	}
	else
	{
		return GetBackgroundColor();
	}
}

COLORREF COXSkin2003::GetHotShortcutBarLightColor()
{
	return GetShortcutBarLightColor();
}

COLORREF COXSkin2003::GetHotShortcutBarDarkColor()
{
	return RGB(247,192,91);
}

COLORREF COXSkin2003::GetSelShortcutBarLightColor()
{
	return GetShortcutBarLightColor();
}

COLORREF COXSkin2003::GetSelShortcutBarDarkColor()
{
	return RGB(238,149,21);
}


COLORREF COXSkin2003::GetStatusbarTopColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.3f, 0.3f, 0.4f);
	}
	else
	{
		return ::GetSysColor(COLOR_3DSHADOW);
	}
}

COLORREF COXSkin2003::GetStatusbarMiddleColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.6f, 0.4f, 0);
	}
	else
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.5f, 0.5f, 0);
	}
}

COLORREF COXSkin2003::GetStatusbarBottomColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.3f, 0.7f, 0);
	}
	else
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.2f, 0.8f, 0);
	}	
}

COLORREF COXSkin2003::GetHotItemColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(255, 238, 194);
	else
		return COXSkinXP::GetHotItemColor();
}

COLORREF COXSkin2003::GetCheckedItemColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(255, 192, 111);
	else
		return COXSkinXP::GetCheckedItemColor();
}

COLORREF COXSkin2003::GetHotSelectedItemColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(254, 128, 62);
	else
		return COXSkinXP::GetHotSelectedItemColor();
}

COLORREF COXSkin2003::GetHotToolbarItemLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(255, 244, 204);
	else
		return COXSkinXP::GetHotItemColor();
}

COLORREF COXSkin2003::GetHotToolbarItemDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(255, 208, 145);
	else
		return COXSkinXP::GetHotItemColor();
}

COLORREF COXSkin2003::GetCheckedToolbarItemLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(255, 213, 140);
	else
		return COXSkinXP::GetCheckedItemColor();
}

COLORREF COXSkin2003::GetCheckedToolbarItemDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(255, 173, 85);
	else
		return COXSkinXP::GetCheckedItemColor();
}

COLORREF COXSkin2003::GetHotSelectedToolbarItemLightColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(254, 145, 78);
	else
		return COXSkinXP::GetHotSelectedItemColor();
}

COLORREF COXSkin2003::GetHotSelectedToolbarItemDarkColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return RGB(255, 211, 142);
	else
		return COXSkinXP::GetHotSelectedItemColor();
}

// Returns the color of the border of a hot item
COLORREF COXSkin2003::GetActiveBorderColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
		return ModifyColor(m_UxTheme.GetThemeSysColor(hTheme, COLOR_ACTIVECAPTION),
			0, -84, -99);
	else
		return ::GetSysColor(COLOR_HIGHLIGHT);
}

// Returns the face color of the menu
COLORREF COXSkin2003::GetMenuFaceColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return RGB(246, 246, 246);
	}
	else
	{
		// 86% window background color, 14% 3DFace color
		return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
			0.86f, 0.14f, 0);
	}
}

// Returns the border color of the menu
COLORREF COXSkin2003::GetMenuBorderColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(m_UxTheme.GetThemeSysColor(hTheme, COLOR_ACTIVECAPTION),
			0, 0,
			0.55f, 0.45f, 0);
	}
	else
	{
		return ::GetSysColor(COLOR_BTNSHADOW);
	}
}

// Returns the background color of the toolbar
COLORREF COXSkin2003::GetBackgroundColor()
{
	return COXSkinXP::GetBackgroundColor();
}

// Returns the background color of the dockbar
COLORREF COXSkin2003::GetDockbarBackgroundColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return GetDockbarRightColor();
	}
	else
	{
		return ::GetSysColor(COLOR_3DFACE);
	}
}

COLORREF COXSkin2003::GetInactiveTabTextColor()
{
	return ::GetSysColor(COLOR_BTNTEXT);
}

// Returns the color of the separators
COLORREF COXSkin2003::GetSeparatorColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(::GetSysColor(COLOR_WINDOW),
			m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0,
			0.2f, 0.8f, 0);
	}
	else
	{
		return COXSkinXP::GetSeparatorColor();
	}
}

// Returns the color of the splitter line
COLORREF COXSkin2003::GetSplitterLineColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return GetShortcutBarDarkColor();
	}
	else
	{
		return COXSkinXP::GetSeparatorColor();
	}
}

COLORREF COXSkin2003::GetBorderColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return Blend3Colors(m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT), 0, 0,
			0.5f, 0.5f, 0);
	}
	else
	{
		return COXSkinXP::GetSeparatorColor();
	}
}

COLORREF COXSkin2003::GetMiniFrameCaptionColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT);
	}
	else
	{
		return COXSkinXP::GetMiniFrameCaptionColor();
	}
}

COLORREF COXSkin2003::GetMiniFrameCaptionTextColor()
{
	return COXSkinXP::GetMiniFrameCaptionTextColor();
}

COLORREF COXSkin2003::GetMiniFrameBorderColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return m_UxTheme.GetThemeSysColor(hTheme, COLOR_HIGHLIGHT);
	}
	else
	{
		return COXSkinXP::GetMiniFrameBorderColor();
	}
}

COLORREF COXSkin2003::GetMiniFrameLightBorderColor()
{
	return GetDockbarBackgroundColor();
}

COLORREF COXSkin2003::GetDisabledTextColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return RGB(141, 141, 141);
	}
	else
	{
		return COXSkinXP::GetDisabledTextColor();
	}
}

COLORREF COXSkin2003::GetDisabledMenuTextColor()
{
	HTHEME hTheme = m_UxTheme.OpenThemeData(NULL, _T("button"));
	if (hTheme != NULL)
	{
		return RGB(141, 141, 141);
	}
	else
	{
		return COXSkinXP::GetDisabledMenuTextColor();
	}
}

// COXSkinXP
//

COXSkinXP::COXSkinXP()
{
	m_strName = _T("Office XP");
    m_pToolbarSkin = new COXToolbarSkinXP(this);
    m_pMenuSkin = new COXMenuSkinXP(this);
    m_pMenubarSkin = new COXToolbarSkinXP(this);
    m_pDockbarSkin = new COXDockbarSkinXP(this);
    m_pTabSkin = new COXTabSkinXP(this);
    m_pShortcutBarSkin = new COXShortcutBarSkinXP(this);
	m_pMiniFrameSkin = new COXMiniFrameSkinXP(this);
	m_pStatusbarSkin = new COXStatusbarSkinXP(this);
	m_pFrameSkin = new COXFrameSkinXP(this);
}

COXSkinXP::~COXSkinXP()
{

}

// This function modifies the given color by adding the values passed for red gree and blue.
COLORREF COXSkinXP::ModifyColor(COLORREF crBase, int iRed, int iGreen, int iBlue)
{
	int iBaseRed = GetRValue(crBase);
	int iBaseGreen = GetGValue(crBase);
	int iBaseBlue = GetBValue(crBase);

	iBaseRed += iRed;
	if (iBaseRed > 255)
		iBaseRed = 255;

	iBaseGreen += iGreen;
	if (iBaseGreen > 255)
		iBaseGreen = 255;

	iBaseBlue += iBlue;
	if (iBaseBlue > 255)
		iBaseBlue = 255;
	
	return RGB(iBaseRed, iBaseGreen, iBaseBlue);
}

COLORREF COXSkinXP::ModifyColor(COLORREF crBase, float fRed, float fGreen, float fBlue)
{
	int iBaseRed = GetRValue(crBase);
	int iBaseGreen = GetGValue(crBase);
	int iBaseBlue = GetBValue(crBase);

	iBaseRed = (int) (iBaseRed * fRed);
	if (iBaseRed > 255)
		iBaseRed = 255;

	iBaseGreen = (int) (iBaseGreen * fGreen);
	if (iBaseGreen > 255)
		iBaseGreen = 255;

	iBaseBlue = (int) (iBaseBlue * fBlue);
	if (iBaseBlue > 255)
		iBaseBlue = 255;
	
	return RGB(iBaseRed, iBaseGreen, iBaseBlue);
}

COLORREF COXSkinXP::Blend3Colors(COLORREF clrFirst, COLORREF clrSecond, COLORREF clrThird, float fFirts, float fSecond, float fThird)
{
	int iFirstRed = GetRValue(clrFirst);
	int iFirstGreen = GetGValue(clrFirst);
	int iFirstBlue = GetBValue(clrFirst);

	int iSecondRed = GetRValue(clrSecond);
	int iSecondGreen = GetGValue(clrSecond);
	int iSecondBlue = GetBValue(clrSecond);

	int iThirdRed = GetRValue(clrThird);
	int iThirdGreen = GetGValue(clrThird);
	int iThirdBlue = GetBValue(clrThird);

	int iRed = (int) (iFirstRed * fFirts + iSecondRed * fSecond + iThirdRed * fThird);
	if (iRed > 255)
		iRed = 255;

	int iGreen = (int) (iFirstGreen * fFirts + iSecondGreen * fSecond + iThirdGreen * fThird);
	if (iGreen > 255)
		iGreen = 255;

	int iBlue = (int) (iFirstBlue * fFirts + iSecondBlue * fSecond + iThirdBlue * fThird);
	if (iBlue > 255)
		iBlue = 255;
	
	return RGB(iRed, iGreen, iBlue);
}

// Returns the color of the gripper
COLORREF COXSkinXP::GetGripperColor()
{
	// The stripe color if the button shadow color incremented by 32
	return ModifyColor(::GetSysColor(COLOR_BTNSHADOW), 32, 32, 32);
}

// Returns the color of the separators
COLORREF COXSkinXP::GetSeparatorColor()
{
	// The separator color if the button shadow color incremented by 38
	return ModifyColor(::GetSysColor(COLOR_BTNSHADOW), 38, 38, 38);
}

COLORREF COXSkinXP::GetBorderColor()
{
	return ::GetSysColor(COLOR_3DSHADOW);
}

// Returns the color of the background color of the toolbar
COLORREF COXSkinXP::GetBackgroundColor()
{
	// 16% window background color, 84% 3DFace color
	return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
		0.16f, 0.84f, 0);
}

// Returns the background color of the dockbar
COLORREF COXSkinXP::GetDockbarBackgroundColor()
{
	return ::GetSysColor(COLOR_BTNFACE);
}

// Returns the background color of the icon of a hidden item
COLORREF COXSkinXP::GetHiddenItemBackgroundColor()
{
	// The button face color decremented by 8
	return ModifyColor(::GetSysColor(COLOR_BTNFACE), -8, -8, -8);
}

// Returns the color of a hot item
COLORREF COXSkinXP::GetHotItemColor()
{
	// 70% window background color, 30% selected item color
	return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_HIGHLIGHT), 0,
		0.7f, 0.3f, 0);
}

// Returns the color of a hot selected item
COLORREF COXSkinXP::GetHotSelectedItemColor()
{
	// 50% window background color, 50% selected item color
	return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_HIGHLIGHT), 0, 
		0.5f, 0.5f, 0);
}

// Returns the color of a checked item
COLORREF COXSkinXP::GetCheckedItemColor()
{
	// 42% 3DFace color, 48% window background color, 10% highlight color
	return Blend3Colors(::GetSysColor(COLOR_3DFACE), ::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_HIGHLIGHT), 
		0.42f, 0.48f, 0.10f);
}

// Returns the color of the border of a hot item
COLORREF COXSkinXP::GetActiveBorderColor()
{
	return ::GetSysColor(COLOR_HIGHLIGHT);
}

// Returns the color of the text of a normal item
COLORREF COXSkinXP::GetTextColor()
{
	return ::GetSysColor(COLOR_BTNTEXT);
}

// Returns the color of the text of a selected item
COLORREF COXSkinXP::GetSelectedTextColor()
{
	return ::GetSysColor(COLOR_HIGHLIGHTTEXT);
}

// Returns the color of the border of the mini frame window
COLORREF COXSkinXP::GetMiniFrameBorderColor()
{
	// The color is the button shadow color decremented by 9
	return ModifyColor(::GetSysColor(COLOR_BTNSHADOW), -9, -9, -9);
}

COLORREF COXSkinXP::GetMiniFrameLightBorderColor()
{
	return GetBackgroundColor();
}

// Returns the face color of the menu
COLORREF COXSkinXP::GetMenuFaceColor()
{
	// 86% window background color, 14% 3DFace color
	return Blend3Colors(::GetSysColor(COLOR_WINDOW), ::GetSysColor(COLOR_3DFACE), 0,
		0.86f, 0.14f, 0);
}

// Returns the face color of the menu
COLORREF COXSkinXP::GetMenuBorderColor()
{
	return ::GetSysColor(COLOR_BTNSHADOW);
}

// Returns the background color of the tab buttons is a tab control
COLORREF COXSkinXP::GetTabButtonsBackgroundColor()
{
	return ModifyColor(::GetSysColor(COLOR_3DFACE), 1.2f, 1.2f, 1.2f);
}

// Returns the text color of an inselected tab button
COLORREF COXSkinXP::GetInactiveTabTextColor()
{
	return ModifyColor(::GetSysColor(COLOR_GRAYTEXT), -8, -12, -22);
}

// Returns the color of border of a status bar pan
COLORREF COXSkinXP::GetStatusPaneColor()
{
	return ModifyColor(::GetSysColor(COLOR_BTNFACE), 17, 12, 16);
}

COLORREF COXSkinXP::InvertColor(COLORREF clr)
{
	int iBaseRed = GetRValue(clr);
	int iBaseGreen = GetGValue(clr);
	int iBaseBlue = GetBValue(clr);

	return RGB(255 - iBaseRed, 255 - iBaseGreen, 255 - iBaseBlue);
}

void COXSkinXP::DrawTransparentBitmap(CBitmap* pBitmap, CDC* pDestDC, int x, int y, int nWidth, int nHeight, COLORREF clrTransColor)
{
	COLORREF crOldBack = pDestDC->SetBkColor(RGB(255, 255, 255));
	COLORREF crOldText = pDestDC->SetTextColor(RGB(0, 0, 0));
	CDC dcImage, dcTrans;

	// Create two memory dcs for the image and the mask
	dcImage.CreateCompatibleDC(pDestDC);
	dcTrans.CreateCompatibleDC(pDestDC);

	// Select the image into the appropriate dc
	CBitmap* pOldBitmapImage = dcImage.SelectObject(pBitmap);

	// Create the mask bitmap
	CBitmap bitmapTrans;
	bitmapTrans.CreateBitmap(nWidth, nHeight, 1, 1, NULL);

	// Select the mask bitmap into the appropriate dc
	CBitmap* pOldBitmapTrans = dcTrans.SelectObject(&bitmapTrans);

	// Build mask based on transparent colour
	dcImage.SetBkColor(clrTransColor);
	dcTrans.BitBlt(0, 0, nWidth, nHeight, &dcImage, 0, 0, SRCCOPY);

	// Do the work - True Mask method - cool if not actual display
	pDestDC->BitBlt(x, y, nWidth, nHeight, &dcImage, 0, 0, SRCINVERT);
	pDestDC->BitBlt(x, y, nWidth, nHeight, &dcTrans, 0, 0, SRCAND);
	pDestDC->BitBlt(x, y, nWidth, nHeight, &dcImage, 0, 0, SRCINVERT);

	// Restore settings
	dcImage.SelectObject(pOldBitmapImage);
	dcTrans.SelectObject(pOldBitmapTrans);
	pDestDC->SetBkColor(crOldBack);
	pDestDC->SetTextColor(crOldText);
}

// Draws an Office XP style frame button
void COXSkinXP::DrawFrameButton(CDC* pDC, CRect& rcButton, UINT uType, BOOL bDisabled, BOOL bInvertFace, COLORREF clrBackground, CWnd* pParentWnd)
{
	// First determine some colors
	COLORREF clrDisabled = 0;
	if (bDisabled)
	{
		if (bInvertFace)
		{
			bInvertFace = FALSE;
			clrDisabled = ModifyColor(clrBackground, 64, 64, 64);
		}
		else
			clrDisabled = ModifyColor(clrBackground, -96, -96, -96);
	}

	// Get the cursor position in window coordinates
	CPoint ptCursor;
	::GetCursorPos(&ptCursor);
	CRect rectWindow;
	pParentWnd->GetWindowRect(rectWindow);
	ptCursor.Offset(-rectWindow.left, -rectWindow.top);

	bool bLeftButtonDown = (pParentWnd->GetCapture() != NULL);

	// Determine the colors
	CBrush brush;
	brush.m_hObject = NULL;
	if (bLeftButtonDown && rcButton.PtInRect(ptCursor))
	{
		// Pressed
		brush.CreateSolidBrush(GetHotSelectedItemColor());
	}
	else if (rcButton.PtInRect(ptCursor))
	{
		// Hot
		brush.CreateSolidBrush(GetHotItemColor());
	}

	///////////////////////// Perform the drawing
	// Draw to a memory dc to avoid flashing
	CDC dc;
	dc.CreateCompatibleDC(pDC);
	CBitmap bmpMem;
	CRect rectMem(rcButton);
	rectMem.OffsetRect(-rectMem.left, -rectMem.top);
	bmpMem.CreateCompatibleBitmap(pDC, rectMem.Width(), rectMem.Height());
	CBitmap* pOldBmp = dc.SelectObject(&bmpMem);

	if (brush.m_hObject != NULL && !bDisabled)
	{
		// Draw a frame
		CBrush* pOldBrush = dc.SelectObject(&brush);
		CPen penBorder;
		penBorder.CreatePen(PS_SOLID, 1, GetActiveBorderColor());
		CPen* pOldPen = dc.SelectObject(&penBorder);
		dc.Rectangle(rectMem);
		dc.SelectObject(pOldPen);
		dc.SelectObject(pOldBrush);
	}
	else
		dc.FillSolidRect(rectMem, clrBackground);

	// Draw the symbol transparently
	CDC dcSymbol;
	dcSymbol.CreateCompatibleDC(pDC);
	CBitmap bmpSymbol;
	CRect rcSymbol(rectMem);
	rcSymbol.DeflateRect(2, 2);
	bmpSymbol.CreateCompatibleBitmap(pDC, rcSymbol.Width(), rcSymbol.Height());
	CBitmap* pOldBitmap = dcSymbol.SelectObject(&bmpSymbol);
	dcSymbol.DrawFrameControl(CRect(-2, -2, rcSymbol.Width() + 2, rcSymbol.Height() + 2),
		DFC_CAPTION, DFCS_FLAT | uType);

	COLORREF clrTransparent = ::GetSysColor(COLOR_BTNFACE);

	if (bLeftButtonDown && rcButton.PtInRect(ptCursor))
	{
		// Pressed, so invert the face color of the symbol
		dcSymbol.BitBlt(0, 0, rcSymbol.Width(), rcSymbol.Height(), &dcSymbol, 0, 0, PATINVERT);
		clrTransparent = InvertColor(clrTransparent);
	}
	else if (bInvertFace && !(rcButton.PtInRect(ptCursor)))
	{
		// Invert the face color
		dcSymbol.BitBlt(0, 0, rcSymbol.Width(), rcSymbol.Height(), &dcSymbol, 0, 0, PATINVERT);
		clrTransparent = InvertColor(clrTransparent);
	}

	dcSymbol.SelectObject(pOldBitmap);
	DrawTransparentBitmap(&bmpSymbol, &dc, 2, 2, rcSymbol.Width(), rcSymbol.Height(), clrTransparent);

	if (bDisabled)
	{
		// Draw a disabled button
		dc.SelectObject(pOldBmp);

		CBitmap bmpDisabled;
		bmpDisabled.CreateCompatibleBitmap(pDC, rectMem.Width(), rectMem.Height());
		pOldBmp = dc.SelectObject(&bmpDisabled);

		dc.FillSolidRect(CRect(0, 0, rcButton.Width(), rcButton.Height()), clrDisabled);
		DrawTransparentBitmap(&bmpMem, &dc, 0, 0, rcButton.Width(), rcButton.Height(), 0);

		// Copy the memory dc to the real dc
		pDC->BitBlt(rcButton.left, rcButton.top, rcButton.Width(), rcButton.Height(), &dc, 0, 0, SRCCOPY);
		dc.SelectObject(pOldBmp);	
	}
	else
	{
		// Copy the memory dc to the real dc
		pDC->BitBlt(rcButton.left, rcButton.top, rcButton.Width(), rcButton.Height(), &dc, 0, 0, SRCCOPY);
		dc.SelectObject(pOldBmp);
	}
}

COLORREF COXSkinXP::GetMiniFrameCaptionColor()
{
	return ::GetSysColor(COLOR_BTNSHADOW);
}

COLORREF COXSkinXP::GetMiniFrameCaptionTextColor()
{
	return ::GetSysColor(COLOR_CAPTIONTEXT);
}

COLORREF COXSkinXP::GetDisabledTextColor()
{
	return ::GetSysColor(COLOR_GRAYTEXT);
}

COLORREF COXSkinXP::GetDisabledMenuTextColor()
{
	return GetSeparatorColor();
}

// COXToolbarSkin
//




// COXToolbarSkinClassic.cpp
//

void COXToolbarSkinClassic::DrawGripper(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* pCoolToolbar)
{
    if (pCoolToolbar->m_dwStyle & CBRS_FLOATING)
		return;		// no gripper if floating

	COLORREF clrHilight=::GetSysColor(COLOR_BTNHILIGHT);
	COLORREF clrShadow=::GetSysColor(COLOR_BTNSHADOW);
	
	CRect rect(lpRect);
	CRect gripperRect(lpRect);

	if (pCoolToolbar->m_dwStyle & CBRS_ORIENT_HORZ) 
	{
		gripperRect.DeflateRect(1, 1);
		gripperRect.OffsetRect(0, 1);
		// gripper at left
		if (pCoolToolbar->m_pDockContext != NULL)
		{
			// EnableDocking was called
			gripperRect.left += 2;
			gripperRect.bottom -= 2;
		}
		else
		{
			if (pCoolToolbar->m_dwStyle & CBRS_BORDER_BOTTOM)
			{
				gripperRect.top -= 2;
				gripperRect.bottom -= 2;
			}
		}
		gripperRect.right = gripperRect.left + 3;
        pDC->Draw3dRect(gripperRect, clrHilight, clrShadow);
		gripperRect.OffsetRect(3, 0);
        pDC->Draw3dRect(gripperRect, clrHilight, clrShadow);

		rect.left = gripperRect.right + 1;
	} 
	else 
	{
		gripperRect.DeflateRect(0, 1, 2, 1);
		gripperRect.OffsetRect(0, 1);
		// gripper at top
		if (pCoolToolbar->m_pDockContext == NULL)
		{
			// EnableDocking was not called
			gripperRect.right += 2;
		}
		else
		{
			gripperRect.left += 2;
		}
		gripperRect.bottom = gripperRect.top + 3;
		pDC->Draw3dRect(gripperRect, clrHilight, clrShadow);
		gripperRect.OffsetRect(0, 3);
        pDC->Draw3dRect(gripperRect, clrHilight, clrShadow);

		rect.top = gripperRect.bottom + 1;
	}
}

void COXToolbarSkinClassic::DrawNonClientArea(CDC* pDC, LPCRECT /*lpRect*/, COXCoolToolBar* pCoolToolbar)
{
	// get window DC that is clipped to the non-client area
	CRect rectClient;
	pCoolToolbar->GetClientRect(rectClient);
	CRect rectWindow;
	pCoolToolbar->GetWindowRect(rectWindow);
	pCoolToolbar->ScreenToClient(rectWindow);
	rectClient.OffsetRect(-rectWindow.left, -rectWindow.top);
	rectWindow.OffsetRect(-rectWindow.left, -rectWindow.top);

	// draw borders in non-client area
	if(!pCoolToolbar->IsCool())
	{
		// only if CoolToolBar is not used in CoolBar
		pCoolToolbar->DrawBorders(pDC, rectWindow);

		// fixing for spurious edges
		if((pCoolToolbar->m_dwStyle&CBRS_BORDER_3D)==0)
		{
			rectWindow.InflateRect(1,1);
		}
	}

	// erase parts not drawn
	pDC->IntersectClipRect(rectWindow);
	pDC->ExcludeClipRect(rectClient);
	pDC->FillSolidRect(rectWindow, ::GetSysColor(COLOR_3DFACE));
}

void COXToolbarSkinClassic::DrawSeparator(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* pCoolToolbar)
{
	CRect rc(lpRect);
	COLORREF clrHilight = ::GetSysColor(COLOR_BTNHILIGHT);
	COLORREF clrShadow = ::GetSysColor(COLOR_BTNSHADOW);
	
    BOOL bHorz= ((pCoolToolbar->m_dwStyle & CBRS_ORIENT_HORZ) !=0 ) ? TRUE : FALSE;
	// make sure, this separator is not a placeholder for
	// another control.
	if (rc.Width() <= 8) 
	{
		if (bHorz) 
		{
			// draw the separator bar in the middle
			int x = (rc.left + rc.right) / 2;
			rc.left = x - 1;
			rc.right = x + 1;
			pDC->Draw3dRect(rc, clrShadow, clrHilight);
		} 
		else 
		{
			// draw the separator bar in the middle
			UINT nButtonWidth = pCoolToolbar->GetButtonsSize().cx;
			rc.left = rc.left - nButtonWidth;
			rc.right = rc.left + nButtonWidth;
			rc.top=rc.bottom + 1;
			rc.bottom = rc.top + 3;
			int y = (rc.top+rc.bottom) / 2;
			rc.top = y - 1;
			rc.bottom = y + 1;
			pDC->Draw3dRect(rc, clrShadow, clrHilight);
		}
	}
}

void COXToolbarSkinClassic::DrawCustomizedButton(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* /*pCoolToolbar*/)
{
	pDC->DrawDragRect(lpRect, CSize(2,2), CRect(0,0,0,0), CSize(0,0), NULL, NULL);
}

void COXToolbarSkinClassic::OnCustomDraw(NMHDR*& pNotify, LRESULT*& pResult, COXCoolToolBar* pCoolToolbar)
{
	// in new version of comctl32.dll(4.71)
	// we use toolbar specific custom draw structure 
	LPNMTBCUSTOMDRAW pTBCDRW=NULL;
	LPNMCUSTOMDRAW pCDRW=NULL;
	if(pCoolToolbar->m_dwComCtlVersion>=_IE40_COMCTL_VERSION)
	{
		pTBCDRW=(LPNMTBCUSTOMDRAW)pNotify;
		pCDRW=&pTBCDRW->nmcd;
	}
	else
	{
		pCDRW=(LPNMCUSTOMDRAW)pNotify;
	}

	OXCTB_CUSTOMDRAW cd;
	if(pCoolToolbar->m_dwComCtlVersion>=_IE40_COMCTL_VERSION)
	{
		ASSERT(pTBCDRW!=NULL);
		cd.pCustomDraw=(LPNMCUSTOMDRAW)pTBCDRW;
	}
	else
	{
		cd.pCustomDraw=pCDRW;
	}
	cd.hdr.hwndFrom=pCDRW->hdr.hwndFrom;
	cd.hdr.idFrom=pCDRW->hdr.idFrom;
	cd.hdr.code=OXCTBN_CUSTOMDRAW;
	cd.result=CDRF_DODEFAULT;
	cd.bDoDefault=TRUE;

	CWnd* pParentWnd=NULL;
	if(pCoolToolbar->IsFloating())
	{
		pParentWnd=pCoolToolbar->GetTopLevelParent();
	}
	else
	{
		pParentWnd=pCoolToolbar->GetParentFrame();
	}

	ASSERT(pParentWnd != NULL);

	pParentWnd->SendMessage(WM_NOTIFY,cd.hdr.idFrom,(LPARAM)&cd);

	if(pCDRW->dwDrawStage==CDDS_PREPAINT && 
		pCoolToolbar->GetToolBarCtrl().GetButtonCount()>0)
	{
		CRect rect;
		pCoolToolbar->GetItemRect(0,&rect);
	}

	if(!cd.bDoDefault)
	{
		*pResult=cd.result;
	}
	else
	{
		CDC dc;
		dc.Attach(pTBCDRW->nmcd.hdc);

		*pResult = CDRF_DODEFAULT;
		switch( pCDRW->dwDrawStage )
		{
		case CDDS_PREPAINT:
			{
				// Draw the background
				DrawBackground(&dc, pCoolToolbar);

				/////////
				// draw separators
				/////////
				// in new version of comctl32.dll(4.71)
				// separators are drawn automatically
				// well, you have a chance to draw your own separator even
				// if new version of comctl32.dll installed. But you shouldn't 
				// forget that native separators will be drawn anyway
				if(pCoolToolbar->m_dwComCtlVersion<_IE40_COMCTL_VERSION)
				{
					if(pCoolToolbar->IsFlat() && pCoolToolbar->m_bSeparator)
					{
						int nBitmap; 
						UINT uID, uStyleState;
						CRect rc;
						for(int nIndex=0; 
							nIndex<pCoolToolbar->GetToolBarCtrl().GetButtonCount(); nIndex++)
						{
							pCoolToolbar->GetButtonInfo(nIndex, uID, uStyleState, nBitmap);
							WORD wStyle=LOWORD(uStyleState);
							WORD wState=HIWORD(uStyleState);
							if(wStyle==TBSTYLE_SEP && wState!=TBSTATE_HIDDEN) 
							{
								if(!(wState & TBSTATE_WRAP))
								{
									pCoolToolbar->GetItemRect(nIndex,&rc);
									rc.top-=1;
									pCoolToolbar->DrawSeparator(dc,rc);
								}
								else
								{
									CBrush brush(::GetSysColor(COLOR_BTNFACE));
									dc.FillRect(&rc,&brush);
								}
							}
						}
					}
				}

				// draw custom button in customized state if set
				int nCustomizedButton=pCoolToolbar->GetCustomizedButton();
				if(nCustomizedButton!=-1 && pCoolToolbar->IsCustomButton(nCustomizedButton))
				{
					CRect rect;
					pCoolToolbar->GetItemRect(nCustomizedButton,rect);
					pCoolToolbar->DrawCustomizedButton(dc,rect);
				}


				*pResult = CDRF_DODEFAULT | CDRF_NOTIFYPOSTPAINT | CDRF_NOTIFYITEMDRAW;
				break;
			}

		case CDDS_ITEMPREPAINT:
			{
				*pResult = CDRF_NOTIFYPOSTPAINT;	// request for ITEMPOSTPAINT
 
				CRect rectButton(pCDRW->rc);
				CRect rectBackground(pCDRW->rc);
				if(!pCoolToolbar->GetToolBarCtrl().IsButtonHidden(PtrToInt(pCDRW->dwItemSpec))) 
				{
					if(pCDRW->uItemState & CDIS_CHECKED)
					{
						if(pCDRW->uItemState & CDIS_HOT)
						{
							// set text color
							if(pCoolToolbar->GetSelectedTextColor() != CLR_DEFAULT)
							{
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									pTBCDRW->clrText = pCoolToolbar->GetSelectedTextColor();
								}
								else
								{
									::SetTextColor(pCDRW->hdc, pCoolToolbar->GetSelectedTextColor());
								}
							}

							// draw border
							if(pCoolToolbar->GetSelectedBorderColor() != CLR_DEFAULT)
							{
								CBrush brush(pCoolToolbar->GetSelectedBorderColor());
								dc.FrameRect(rectButton,&brush);
								rectBackground.DeflateRect(1,1,1,1);
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									*pResult |= TBCDRF_NOEDGES;
								}
							}

							// draw background
							if(pCoolToolbar->GetSelectedBkColor() != CLR_DEFAULT)
							{
								dc.FillSolidRect(rectBackground,pCoolToolbar->GetSelectedBkColor());
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									*pResult |= TBCDRF_NOETCHEDEFFECT;
								}
							}
						}
						else
						{
							// set text color
							if(pCoolToolbar->GetCheckedTextColor() != CLR_DEFAULT)
							{
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									pTBCDRW->clrText = pCoolToolbar->GetCheckedTextColor();
								}
								else
								{
									::SetTextColor(pCDRW->hdc, pCoolToolbar->GetCheckedTextColor());
								}
							}

							// draw border
							if(pCoolToolbar->GetCheckedBorderColor() != CLR_DEFAULT)
							{
								CBrush brush(pCoolToolbar->GetCheckedBorderColor());
								dc.FrameRect(rectButton,&brush);
								rectBackground.DeflateRect(1,1,1,1);
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									*pResult |= TBCDRF_NOEDGES;
								}
							}

							// draw background
							if(pCoolToolbar->GetCheckedBkColor() != CLR_DEFAULT)
							{
								dc.FillSolidRect(rectBackground,pCoolToolbar->GetCheckedBkColor());
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									*pResult |= TBCDRF_NOETCHEDEFFECT;
								}
							}
						}
					}
					else if(pCDRW->uItemState & CDIS_HOT)
					{
						if(pCDRW->uItemState & CDIS_SELECTED)
						{
							// set text color
							if(pCoolToolbar->GetSelectedTextColor() != CLR_DEFAULT)
							{
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									pTBCDRW->clrText = pCoolToolbar->GetSelectedTextColor();
								}
								else
								{
									::SetTextColor(pCDRW->hdc, pCoolToolbar->GetSelectedTextColor());
								}
							}

							// draw border
							if(pCoolToolbar->GetSelectedBorderColor() != CLR_DEFAULT)
							{
								CBrush brush(pCoolToolbar->GetSelectedBorderColor());
								dc.FrameRect(rectButton,&brush);
								rectBackground.DeflateRect(1,1,1,1);
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									*pResult |= TBCDRF_NOEDGES;
								}
							}

							// draw background
							if(pCoolToolbar->GetSelectedBkColor() != CLR_DEFAULT)
							{
								dc.FillSolidRect(rectBackground,pCoolToolbar->GetSelectedBkColor());
							}
						}
						else
						{
							// set text color
							if(pCoolToolbar->GetHotTextColor() != CLR_DEFAULT)
							{
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									pTBCDRW->clrText = pCoolToolbar->GetHotTextColor();
								}
								else
								{
									::SetTextColor(pCDRW->hdc, pCoolToolbar->GetHotTextColor());
								}
							}

							// draw border
							if(pCoolToolbar->GetHotBorderColor() != CLR_DEFAULT)
							{
								CBrush brush(pCoolToolbar->GetHotBorderColor());
								dc.FrameRect(rectButton,&brush);
								rectBackground.DeflateRect(1,1,1,1);
								if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
								{
									*pResult |= TBCDRF_NOEDGES;
								}
							}

							// draw background
							if(pCoolToolbar->GetHotBkColor() != CLR_DEFAULT)
							{
								dc.FillSolidRect(rectBackground,pCoolToolbar->GetHotBkColor());
							}
						}
					}
					else if(pCDRW->uItemState & CDIS_SELECTED)
					{
						// set text color
						if(pCoolToolbar->GetSelectedTextColor() != CLR_DEFAULT)
						{
							if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
							{
								pTBCDRW->clrText = pCoolToolbar->GetSelectedTextColor();
							}
							else
							{
								::SetTextColor(pCDRW->hdc, pCoolToolbar->GetSelectedTextColor());
							}
						}

						// draw border
						if(pCoolToolbar->GetSelectedBorderColor() != CLR_DEFAULT)
						{
							CBrush brush(pCoolToolbar->GetSelectedBorderColor());
							dc.FrameRect(rectButton,&brush);
							rectBackground.DeflateRect(1,1,1,1);
							if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
							{
								*pResult |= TBCDRF_NOEDGES;
							}
						}

						// draw background
						if(pCoolToolbar->GetSelectedBkColor() != CLR_DEFAULT)
						{
							dc.FillSolidRect(rectBackground,pCoolToolbar->GetSelectedBkColor());
						}
					}
					else
					{
						// set text color
						if(pCoolToolbar->GetDefaultTextColor() != CLR_DEFAULT)
						{
							if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
							{
								pTBCDRW->clrText = pCoolToolbar->GetDefaultTextColor();
							}
							else
							{
								::SetTextColor(pCDRW->hdc, pCoolToolbar->GetDefaultTextColor());
							}
						}

						// draw border
						if(pCoolToolbar->GetDefaultBorderColor() != CLR_DEFAULT)
						{
							CBrush brush(pCoolToolbar->GetDefaultBorderColor());
							dc.FrameRect(rectButton,&brush);
							rectBackground.DeflateRect(1,1,1,1);
							if(pCoolToolbar->m_dwComCtlVersion >= _IE40_COMCTL_VERSION)
							{
								*pResult |= TBCDRF_NOEDGES;
							}
						}

						// draw background
						if(pCoolToolbar->GetDefaultBkColor() != CLR_DEFAULT)
						{
							dc.FillSolidRect(rectBackground,pCoolToolbar->GetDefaultBkColor());
						}
					}
				}

				break;
			}

		case CDDS_ITEMPOSTPAINT:
			{
				int nIndex=pCoolToolbar->CommandToIndex(PtrToUint(pCDRW->dwItemSpec));

				if(!pCoolToolbar->GetToolBarCtrl().IsButtonHidden(PtrToInt(pCDRW->dwItemSpec)) && 
					pCoolToolbar->IsDropDownArrow() && (pCoolToolbar->GetButtonStyle(nIndex) & TBSTYLE_DROPDOWN))
				{
					CRect rectDropDownArrow(pCDRW->rc);
					rectDropDownArrow.left = 
						rectDropDownArrow.right - pCoolToolbar->GetDropDownArrowWidth();

					// draw border around drop down button
					if(pCDRW->uItemState & CDIS_CHECKED)
					{
						if(pCDRW->uItemState & CDIS_HOT)
						{
							if(pCoolToolbar->GetSelectedBorderColor() != CLR_DEFAULT)
							{
								CBrush brush(pCoolToolbar->GetSelectedBorderColor());
								dc.FrameRect(rectDropDownArrow,&brush);
							}
						}
						else
						{
							if(pCoolToolbar->GetCheckedBorderColor() != CLR_DEFAULT)
							{
								CBrush brush(pCoolToolbar->GetCheckedBorderColor());
								dc.FrameRect(rectDropDownArrow,&brush);
							}
						}
					}
					else if(pCDRW->uItemState & CDIS_HOT)
					{
						if(pCDRW->uItemState & CDIS_SELECTED)
						{
							if(pCoolToolbar->GetSelectedBorderColor() != CLR_DEFAULT)
							{
								CBrush brush(pCoolToolbar->GetSelectedBorderColor());
								dc.FrameRect(rectDropDownArrow,&brush);
							}
						}
						else
						{
							if(pCoolToolbar->GetHotBorderColor() != CLR_DEFAULT)
							{
								CBrush brush(pCoolToolbar->GetHotBorderColor());
								dc.FrameRect(rectDropDownArrow,&brush);
							}
						}
					}
					else if(pCDRW->uItemState & CDIS_SELECTED)
					{
						if(pCoolToolbar->GetSelectedBorderColor() != CLR_DEFAULT)
						{
							CBrush brush(pCoolToolbar->GetSelectedBorderColor());
							dc.FrameRect(rectDropDownArrow,&brush);
						}
					}
					else
					{
						if(pCoolToolbar->GetDefaultBorderColor() != CLR_DEFAULT)
						{
							CBrush brush(pCoolToolbar->GetDefaultBorderColor());
							dc.FrameRect(rectDropDownArrow,&brush);
						}
					}
				}

				if(pCoolToolbar->IsButtonCustomized(nIndex) && !pCoolToolbar->IsCustomButton(nIndex))
				{
					CRect rect;
					pCoolToolbar->GetItemRect(nIndex,rect);
					pCoolToolbar->DrawCustomizedButton(dc,rect);
				}
#if _MFC_VER<=0x0421
				else if(pCDRW->uItemState & CDIS_CHECKED)
				{
					CRect rect;
					GetItemRect(nIndex,rect);

					if(IsDropDownArrow() && GetButtonStyle(nIndex) & TBSTYLE_DROPDOWN)
					{
						rect.right-=m_nDropDownArrowWidth;
					}

					COLORREF clrHilight=::GetSysColor(COLOR_BTNHILIGHT);
					COLORREF clrShadow=::GetSysColor(COLOR_BTNSHADOW);
					dc.Draw3dRect(rect,clrShadow,clrHilight);
				}
#endif	//	_MFC_VER<=0x0421
				break;
			}

		case CDDS_POSTPAINT:
			{
				break;
			}

		default:
			{
				// CToolBar does not send other draw-stages than the above.
				//TRACE(_T("Unknown draw stage ...\n"));
				break;
			}
		}

		dc.Detach();
	}
}

void COXToolbarSkinClassic::DrawBackground(CDC* pDC, COXCoolToolBar* pCoolToolbar)
{
	CRect rcClient;
	pCoolToolbar->GetClientRect(rcClient);

	pDC->FillSolidRect(rcClient, ::GetSysColor(COLOR_BTNFACE));
}

void COXToolbarSkinClassic::DrawMenuButtons(CDC* pDC, COXMenuBar* pMenuBar)
{
	ASSERT(pMenuBar->m_pFrameWnd!=NULL);
	ASSERT(::IsWindow(pMenuBar->m_pFrameWnd->m_hWnd));
	ASSERT_KINDOF(CMDIFrameWnd,pMenuBar->m_pFrameWnd);

    BOOL bMaximize=FALSE;
	CMDIChildWnd* pChild=((CMDIFrameWnd*)pMenuBar->m_pFrameWnd)->MDIGetActive(&bMaximize);
	if(pChild==NULL || !bMaximize)
		return;

	ASSERT(!pMenuBar->m_rectCloseBtn.IsRectEmpty());
	if(pMenuBar->m_rectCloseBtn.IsRectEmpty())
		return;

	DWORD dwStyle=pChild->GetStyle();

	UINT nPushState;

	// close button
	nPushState=(pMenuBar->m_pressedBtn==OX_MNU_CLOSEBTN) ? DFCS_PUSHED : 0;
	pDC->DrawFrameControl(&pMenuBar->m_rectCloseBtn,DFC_CAPTION,
		DFCS_CAPTIONCLOSE|nPushState);

	// Max/restore button
	if(!pMenuBar->m_rectRestoreBtn.IsRectEmpty())
	{
		UINT nState=DFCS_CAPTIONRESTORE;
		if((dwStyle&WS_MAXIMIZEBOX)==0)
			nState|=DFCS_INACTIVE;
		nPushState=(pMenuBar->m_pressedBtn==OX_MNU_RESTOREBTN) ? DFCS_PUSHED : 0;
		pDC->DrawFrameControl(&pMenuBar->m_rectRestoreBtn,DFC_CAPTION,nState|nPushState);
	}

	// Minimize button
	if(!pMenuBar->m_rectMinimizeBtn.IsRectEmpty())
	{
		UINT nState=DFCS_CAPTIONMIN;
		if((dwStyle&WS_MINIMIZEBOX)==0)
			nState|=DFCS_INACTIVE;
		nPushState=(pMenuBar->m_pressedBtn==OX_MNU_MINIMIZEBTN) ? DFCS_PUSHED : 0;
		pDC->DrawFrameControl(&pMenuBar->m_rectMinimizeBtn,DFC_CAPTION,nState|nPushState);
	}
}

// COXToolbarSkinXP
//

COXToolbarSkinXP::COXToolbarSkinXP(COXSkinXP* pSkinXP)
{
	m_pSkinXP = pSkinXP;
}

void COXToolbarSkinXP::DrawGripper(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* pCoolToolbar)
{
    if (pCoolToolbar->m_dwStyle & CBRS_FLOATING)
		return;		// no gripper if floating

	CRect rect(lpRect);
	CRect gripperRect(lpRect);

	if (pCoolToolbar->m_dwStyle & CBRS_ORIENT_HORZ) 
	{
		gripperRect.DeflateRect(2, 6, 2, 5);
		// gripper at left
		if (pCoolToolbar->m_pDockContext != NULL)
		{
			// EnableDocking was called
			gripperRect.left += 2;
			gripperRect.bottom -= 2;
		}
		else
		{
			if (pCoolToolbar->m_dwStyle & CBRS_BORDER_BOTTOM)
			{
				gripperRect.top -= 2;
				gripperRect.bottom -= 2;
			}
		}
		gripperRect.right = gripperRect.left + 3;
        DrawGripperStripes(pDC, gripperRect, true);
	} 
	else // vertical
	{
		gripperRect.DeflateRect(3, 4, 7, 4);
		// gripper at top
		if (pCoolToolbar->m_pDockContext == NULL)
		{
			// EnableDocking was not called
			gripperRect.right += 2;
		}
		else
		{
			gripperRect.left += 2;
		}
		gripperRect.bottom = gripperRect.top + 3;
		DrawGripperStripes(pDC, gripperRect, false);
	}
}

void COXToolbarSkinXP::DrawNonClientArea(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* pCoolToolbar)
{
	CRect rcNonClient(lpRect);
	
	// Get the client rectangle in window coordinates
	CRect rcClient, rectWindow;
	pCoolToolbar->GetWindowRect(rectWindow);
	pCoolToolbar->GetClientRect(rcClient);
	pCoolToolbar->ClientToScreen(rcClient);
	rcClient.OffsetRect(-rectWindow.left, -rectWindow.top);
	
	// Clip out the client area
//	pDC->ExcludeClipRect(rcClient);

	// Fill the background
	if (pCoolToolbar->IsKindOf(RUNTIME_CLASS(COXMenuBar)))
		pDC->FillSolidRect(lpRect, ::GetSysColor(COLOR_BTNFACE));
	else
		pDC->FillSolidRect(lpRect, m_pSkinXP->GetBackgroundColor());

	// Draw the border
	CRect rcBorder(lpRect);
	CBrush brush;
	brush.CreateSolidBrush(::GetSysColor(COLOR_BTNFACE));

	pDC->FrameRect(rcBorder, &brush);
	rcBorder.DeflateRect(1, 1);
	pDC->FrameRect(rcBorder, &brush);
	rcBorder.DeflateRect(1, 1);

	// Draw the corner pixels
	COLORREF clrCorner = ::GetSysColor(COLOR_BTNFACE);
	pDC->SetPixelV(rcBorder.TopLeft(), clrCorner);
	pDC->SetPixelV(rcBorder.right - 1, rcBorder.top, clrCorner);
	pDC->SetPixelV(rcBorder.right - 1, rcBorder.bottom - 1, clrCorner);
	pDC->SetPixelV(rcBorder.left, rcBorder.bottom - 1, clrCorner);
}

void COXToolbarSkinXP::DrawSeparator(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* /*pCoolToolbar*/)
{
	CRect rect(lpRect);

	if (rect.Height() > rect.Width()) 
	{
		// Horizontal separator
		rect.left = rect.CenterPoint().x - 1;
		rect.right = rect.left + 1;
	} 
	else 
	{
		// Vertical separator
		rect.top = rect.CenterPoint().y - 1;
		rect.bottom = rect.top + 1;
	}

	pDC->FillSolidRect(rect,  m_pSkinXP->GetSeparatorColor());
}

// Draws the button when in customize mode
void COXToolbarSkinXP::DrawCustomizedButton(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* /*pCoolToolbar*/)
{
	// Draw a black rectangle, 2 pixels wide
	CBrush brush;
	brush.CreateSolidBrush(::GetSysColor(COLOR_BTNTEXT));

	CRect rectItem(lpRect);
	pDC->FrameRect(rectItem, &brush);
	rectItem.DeflateRect(1, 1);
	pDC->FrameRect(rectItem, &brush);
}

void COXToolbarSkinXP::DrawGripperStripes(CDC* pDC, CRect &rect, bool bHorizontal)
{
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, m_pSkinXP->GetGripperColor());
	CPen* pOldPen = pDC->SelectObject(&pen);

	if (bHorizontal)
	{
		int iYPos = rect.top;
		while (iYPos <= rect.bottom)
		{
			pDC->MoveTo(rect.left, iYPos);
			pDC->LineTo(rect.right, iYPos);
			iYPos += 2;
		}
	}
	else // vertical
	{
		int iXPos = rect.left;
		while (iXPos <= rect.right)
		{
			pDC->MoveTo(iXPos, rect.top);
			pDC->LineTo(iXPos, rect.bottom);
			iXPos += 2;
		}
	}

	pDC->SelectObject(pOldPen);
}

void COXToolbarSkinXP::OnCustomDraw(NMHDR*& pNotify, LRESULT*& pResult, COXCoolToolBar* pCoolToolbar)
{
	// The toolbar needs to have the TBSTYLE_FLAT style in order for this skin to work
	// in new version of comctl32.dll(4.71)
	// we use toolbar specific custom draw structure 

	LPNMTBCUSTOMDRAW pTBCDRW=NULL;
	LPNMCUSTOMDRAW pCDRW=NULL;
	if(pCoolToolbar->m_dwComCtlVersion>=_IE40_COMCTL_VERSION)
	{
		pTBCDRW=(LPNMTBCUSTOMDRAW)pNotify;
		pCDRW=&pTBCDRW->nmcd;
	}
	else
	{
		pCDRW=(LPNMCUSTOMDRAW)pNotify;
	}

	OXCTB_CUSTOMDRAW cd;
	if(pCoolToolbar->m_dwComCtlVersion>=_IE40_COMCTL_VERSION)
	{
		ASSERT(pTBCDRW!=NULL);
		cd.pCustomDraw=(LPNMCUSTOMDRAW)pTBCDRW;
	}
	else
	{
		cd.pCustomDraw=pCDRW;
	}
	cd.hdr.hwndFrom=pCDRW->hdr.hwndFrom;
	cd.hdr.idFrom=pCDRW->hdr.idFrom;
	cd.hdr.code=OXCTBN_CUSTOMDRAW;
	cd.result=CDRF_DODEFAULT;
	cd.bDoDefault=TRUE;

	CWnd* pParentWnd=NULL;
	if(pCoolToolbar->IsFloating())
	{
		pParentWnd=pCoolToolbar->GetTopLevelParent();
	}
	else
	{
		pParentWnd=pCoolToolbar->GetParentFrame();
	}

	ASSERT(pParentWnd != NULL);

	pParentWnd->SendMessage(WM_NOTIFY,cd.hdr.idFrom,(LPARAM)&cd);

	if(pCDRW->dwDrawStage==CDDS_PREPAINT && 
		pCoolToolbar->GetToolBarCtrl().GetButtonCount()>0)
	{
		CRect rect;
		pCoolToolbar->GetItemRect(0,&rect);
	}

	if(!cd.bDoDefault)
	{
		*pResult=cd.result;
	}
	else
	{
		CDC dc;
		dc.Attach(pTBCDRW->nmcd.hdc);

		// Draw to a memory dc in order to avoid flashing
		CDC dcMem;
		dcMem.CreateCompatibleDC(&dc);
		CBitmap bmpMem;
		CRect rectMem;
		pCoolToolbar->GetClientRect(rectMem);
		rectMem.OffsetRect(-rectMem.left, -rectMem.top);
		bmpMem.CreateCompatibleBitmap(&dc, rectMem.Width(), rectMem.Height());
		CBitmap* pOldBmp = dcMem.SelectObject(&bmpMem);

		*pResult = CDRF_DODEFAULT;
		switch( pCDRW->dwDrawStage )
		{
		case CDDS_PREPAINT:
			{
				// Draw the background
				DrawBackground(&dcMem, pCoolToolbar);

				// Draw each item
				CToolBarCtrl& ctrl = pCoolToolbar->GetToolBarCtrl();
				int iButonCount = ctrl.GetButtonCount();
				for (int i = 0; i < iButonCount; i++)
				{
					TBBUTTON tbb;
					ctrl.GetButton(i, &tbb);

					// Do not draw hidden items
					if (tbb.fsState & TBSTATE_HIDDEN)
						continue;

					CRect rectItem;
					ctrl.GetItemRect(i, rectItem);

					// Draw either a button or a separator
					if (tbb.fsStyle & TBSTYLE_SEP)
					{
						if (tbb.fsState & TBSTATE_WRAP)
						{
							// We have a horizontal separator
							CRect rectSep;
							pCoolToolbar->GetClientRect(rectSep);
							rectSep.bottom = rectItem.bottom;
							rectSep.top = rectItem.bottom - rectItem.Width();

							pCoolToolbar->DrawSeparator(dcMem, rectSep);
						}
						else // vertical separator
						{
							if (rectItem.Height() > rectItem.Width())
								pCoolToolbar->DrawSeparator(dcMem, rectItem);
						}
					}
					else // button
						DrawItem(&dcMem, &tbb, rectItem, pCoolToolbar);

					// If this is a customized button draw a border around it
					if (pCoolToolbar->IsButtonCustomized(i) && !pCoolToolbar->IsCustomButton(i))
						pCoolToolbar->DrawCustomizedButton(dcMem, rectItem);
				}

				// Draw the insert mark if any
				DrawInsertMark(&dcMem, pCoolToolbar);

				*pResult = CDRF_SKIPDEFAULT;
				break;
			}

		}

		dc.BitBlt(0, 0, rectMem.right, rectMem.bottom, &dcMem, 0, 0, SRCCOPY);
		dcMem.SelectObject(pOldBmp);
		dc.Detach();
	}
}

void COXToolbarSkinXP::DrawItem(CDC* pDC, TBBUTTON* pTBB, LPCRECT lpRectItem, COXCoolToolBar* pCoolToolbar, BOOL bDrawBackground)
{
	// Determine the state flags
	bool bSelected = ((pTBB->fsState & TBSTATE_PRESSED) != 0);
	bool bHot = (pCoolToolbar->GetToolBarCtrl().GetHotItem() == pCoolToolbar->CommandToIndex(pTBB->idCommand));
	bool bDisabled = ((pTBB->fsState & TBSTATE_ENABLED) == 0);
	bool bChecked = ((pTBB->fsState & TBSTATE_CHECKED) != 0);

	DWORD dwStyleEx = pCoolToolbar->GetStyleEx();

	if (pCoolToolbar->m_iDropDownIndex == pTBB->idCommand)
	{
		// We have a droped drop down button
		pCoolToolbar->m_iDropDownIndex = -1;

		if (bDrawBackground)
			DrawDroppedItemBackground(pDC, lpRectItem);

		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, true, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);
	}
	else if (bSelected && bHot)
	{
		// Selected and hot
		if (bDrawBackground)
			DrawItemBackground(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetActiveBorderColor(),
				m_pSkinXP->GetHotSelectedItemColor());
		
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetSelectedTextColor(), pCoolToolbar);
	}
	else if (bChecked && bHot)
	{
		// Checked and hot - same as selected and hot
		if (bDrawBackground)
			DrawItemBackground(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetActiveBorderColor(),
				m_pSkinXP->GetHotSelectedItemColor());
		
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetSelectedTextColor(), pCoolToolbar);
	}
	else if (bChecked)
	{
		// Just chequed
		if (bDrawBackground)
			DrawItemBackground(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetActiveBorderColor(),
				m_pSkinXP->GetCheckedItemColor());
		
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, false, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);
	}
	else if (bHot)
	{
		// Just hot
		if (bDrawBackground)
			DrawItemBackground(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetActiveBorderColor(),
				m_pSkinXP->GetHotItemColor());

		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, true, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);
	}
	else if (bSelected)
	{
		// This is a menu item, so decrease the height
		if (bDrawBackground)
		{
			CRect rectItem(lpRectItem);
			rectItem.DeflateRect(0, 1);
			DrawDroppedItemBackground(pDC, rectItem);
		}

		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, true, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);
	}
	else if (bDisabled)
	{
		// Disabled
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, false, true, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, ::GetSysColor(COLOR_GRAYTEXT), pCoolToolbar);
	}
	else
	{
		// Normal
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, false, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);		
	}
}

void COXToolbarSkinXP::DrawItemBackground(CDC* pDC, TBBUTTON* pTBB, DWORD dwStyleEx, LPCRECT lpRect, COLORREF crBorder, COLORREF crInside)
{
	// Fill the inside
	CRect rect(lpRect);
	rect.DeflateRect(1, 1);
	pDC->FillSolidRect(rect, crInside);
	rect.InflateRect(1, 1);

	if (pTBB->iBitmap == -1 && (pTBB->fsStyle & TBSTYLE_DROPDOWN) && !(dwStyleEx & TBSTYLE_EX_DRAWDDARROWS))
	{
		// This is a menu item, so decrease the height
		rect.DeflateRect(0, 1);
	}

	// Draw the borders
	CBrush brush;
	brush.CreateSolidBrush(crBorder);
	pDC->FrameRect(rect, &brush);

	// If this is drop arrow button, frame the arrow part
	if ((pTBB->fsStyle & TBSTYLE_DROPDOWN) && (dwStyleEx & TBSTYLE_EX_DRAWDDARROWS))
		pDC->FrameRect(GetDropArrowRect(pDC, rect), &brush);
}

// Draws a raised background with a shadow
void COXToolbarSkinXP::DrawDroppedItemBackground(CDC* pDC, LPCRECT lpRect)
{
	CRect rectFill(lpRect);
	pDC->FillSolidRect(rectFill, m_pSkinXP->GetBackgroundColor());
}

// Draws the icon of the button according to the button's state
void COXToolbarSkinXP::DrawItemIcon(CDC* pDC, TBBUTTON* pTBB, DWORD dwStyleEx, LPCRECT lpRect, bool bRaised, bool bHot, bool bGrayed, COXCoolToolBar* pCoolToolbar)
{
	if (pCoolToolbar->IsKindOf(RUNTIME_CLASS(COXMenuBar)))
		return;

	if (pTBB->iBitmap == -1)
		return; // there is no icon

	CToolBarCtrl& ctrl = pCoolToolbar->GetToolBarCtrl();
	CImageList* pImageList = ctrl.GetImageList();
	CRect rcItem(lpRect);
	
	// If this is a drop down item the rectangle needs to be decremented
	if ((pTBB->fsStyle & TBSTYLE_DROPDOWN)  && (dwStyleEx & TBSTYLE_EX_DRAWDDARROWS))
	{
		CRect rectDropArrow = GetDropArrowRect(pDC, lpRect);
		rcItem.right -= rectDropArrow.Width();

		// Might as well draw the down arrow here
		CFont fontWebdings;
		fontWebdings.CreatePointFont(80, _T("Marlett"));
		CFont* pOldFont = pDC->SelectObject(&fontWebdings);
		int iOldBkMode = pDC->SetBkMode(TRANSPARENT);
		pDC->DrawText(_T("6"), rectDropArrow, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
		pDC->SetBkMode(iOldBkMode);
		pDC->SelectObject(pOldFont);
	}

	// Get the image rectangle and size
	CRect rectImage = GetIconRect(pTBB->idCommand, pCoolToolbar);
	CSize sizeImage(rectImage.Width(), rectImage.Height());

	// Determine the top left coordinate of the icon
	CPoint ptTopLeft;
	CString strText = pCoolToolbar->GetButtonText(pCoolToolbar->CommandToIndex(pTBB->idCommand));
	if (strText.IsEmpty())
	{
		// There is not text, so the icon is in the middle of the button	
		ptTopLeft.x = rcItem.left + (rcItem.Width() - sizeImage.cx) / 2;
		ptTopLeft.y = rcItem.top + (rcItem.Height() - sizeImage.cy) / 2;
	}
	else // there is text
	{
		if (pCoolToolbar->IsList())
		{
			// The icon is on the left
			ptTopLeft.x = rcItem.left + 3;
			ptTopLeft.y = rcItem.top + (rcItem.Height() - sizeImage.cy) / 2;
		}
		else // not list
		{
			// The icon is on top
			ptTopLeft.x = rcItem.left + (rcItem.Width() - sizeImage.cx) / 2;
			ptTopLeft.y = rcItem.top + 3;
		}
	}

	if (bHot)
	{
		// Hot image - raised with a shadow

		CImageList* pHotImageList = ctrl.GetHotImageList();
		if (pHotImageList == NULL)
			pHotImageList = pImageList;

		if (bRaised) // raised icon with a shadow
		{
			// Draw the image shadow first
			ptTopLeft.x += 1;
			ptTopLeft.y += 1;
			CBrush brush;
			brush.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
			CBrush* pOldBrush = pDC->SelectObject(&brush);
			COLORREF clrOldBkColor = pDC->SetBkColor(RGB(255, 255, 255));
			pHotImageList->DrawIndirect(pDC, pTBB->iBitmap, ptTopLeft, sizeImage,
				CPoint(0, 0), ILD_ROP | ILD_MASK, 0x00B8074A);
			pDC->SetBkColor(clrOldBkColor);
			pDC->SelectObject(pOldBrush);

			ptTopLeft.x -= 2;
			ptTopLeft.y -= 2;
		}

		// Draw the image
		pHotImageList->Draw(pDC, pTBB->iBitmap, ptTopLeft, ILD_TRANSPARENT);
	}
	else if (bGrayed)
	{
		// Disabled image - grayed

		CImageList* pDisabledImageList = ctrl.GetDisabledImageList();
		if (pDisabledImageList != NULL)
			pDisabledImageList->Draw(pDC, pTBB->iBitmap, ptTopLeft, ILD_TRANSPARENT);
		else
		{
			CBrush brush;
			brush.CreateSolidBrush(m_pSkinXP->GetDisabledTextColor());
			HICON hIcon = pImageList->ExtractIcon(pTBB->iBitmap);
			if (hIcon != NULL)
			{
				pDC->DrawState(ptTopLeft, sizeImage, hIcon, DST_ICON | DSS_MONO, &brush);
				::DestroyIcon(hIcon);
			}
		}
	}
	else
	{
		// Normal
		pImageList->Draw(pDC, pTBB->iBitmap, ptTopLeft, ILD_TRANSPARENT);
	}
}

void COXToolbarSkinXP::DrawBackground(CDC* pDC, COXCoolToolBar* pCoolToolbar)
{
	CRect rcClient;
	pCoolToolbar->GetClientRect(rcClient);

	if (pCoolToolbar->IsKindOf(RUNTIME_CLASS(COXMenuBar)))
		pDC->FillSolidRect(rcClient, ::GetSysColor(COLOR_BTNFACE));
	else
		pDC->FillSolidRect(rcClient, m_pSkinXP->GetBackgroundColor());
}

void COXToolbarSkinXP::OnPaintComboBox(COXSkinnedComboBox* pComboBox)
{
	pComboBox->Default();
	CPaintDC dc(pComboBox);
	DrawComboBox(pComboBox);
}

void COXToolbarSkinXP::DrawComboBox(COXSkinnedComboBox* pComboBox)
{
	CClientDC dc(pComboBox);

	CRect rect;
	pComboBox->GetClientRect(rect);
	POINT ptCursor;
	::GetCursorPos(&ptCursor);
	pComboBox->ScreenToClient(&ptCursor);

	// Determine and exclude the edit box rectangle
	CRect rectEdit(rect);
	rectEdit.DeflateRect(3, 3, rect.Height() - 2, 3);

	dc.ExcludeClipRect(rectEdit);
	rectEdit.InflateRect(1, 1);
	if (pComboBox->m_bCommonControls6)
		rectEdit.right += 3;

	// Determine the button rectangle
	CRect rectButton(rect);
	rectButton.DeflateRect(2, 2, 3, 2);
	rectButton.left = rectEdit.Width() + 2;

	// Fill the background
	dc.FillSolidRect(rect, m_pSkinXP->GetBackgroundColor());

	// Draw the inner white border
	CBrush brushWhite;
	COLORREF clrWhite = ::GetSysColor(COLOR_WINDOW);
	brushWhite.CreateSolidBrush(clrWhite);
	rectEdit.InflateRect(1, 1, 0, 0);
	dc.FillSolidRect(rectEdit, clrWhite);

	rectButton.InflateRect(1, 1, 0, 0);
	dc.FrameRect(rectButton, &brushWhite);

	// The combo box can have three states - normal, hot and dropped
	// Determine the state of the combo box
	CBrush brush;
	COLORREF clrArrow = ::GetSysColor(COLOR_BTNTEXT);
	if (pComboBox->GetDroppedState())
	{
		// The combo box is dropped

		brush.CreateSolidBrush(m_pSkinXP->GetHotSelectedItemColor());
		clrArrow = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
	}
	else if (rect.PtInRect(ptCursor) || CWnd::GetFocus() == pComboBox ||
		(CWnd::GetFocus() && CWnd::GetFocus()->GetParent() == pComboBox))
	{
		// The combo box is hot
		brush.CreateSolidBrush(m_pSkinXP->GetHotItemColor());
	}

	// Perform the drawing of a droped or hot combo box
	if (brush.m_hObject != NULL)
	{
		rectEdit.InflateRect(1, 1, 0, 1);
		rectButton.InflateRect(0, 1, 1, 1);

		// Draw the button
		CPen penBorder;
		penBorder.CreatePen(PS_SOLID, 1, m_pSkinXP->GetActiveBorderColor());
		CPen* pOldPen = dc.SelectObject(&penBorder);
		CBrush* pOldBrush = dc.SelectObject(&brush);
		dc.Rectangle(rectButton);
		dc.SelectObject(pOldBrush);
		dc.Rectangle(rectEdit);
		dc.SelectObject(pOldPen);
	}
	
	// Draw the drop arrow
	CPoint ptCenter = rectButton.CenterPoint();
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, clrArrow);
	CPen* pOldPen = dc.SelectObject(&pen);
	dc.MoveTo(ptCenter.x - 2, ptCenter.y - 1);
	dc.LineTo(ptCenter.x + 3, ptCenter.y - 1);
	dc.MoveTo(ptCenter.x - 1, ptCenter.y);
	dc.LineTo(ptCenter.x + 2, ptCenter.y);
	dc.SetPixelV(ptCenter.x, ptCenter.y + 1, clrArrow);
	dc.SelectObject(pOldPen);
}

void COXToolbarSkinXP::DrawWndFrame(CWnd* pWnd)
{
	CWindowDC dc(pWnd);

	CRect rect;
	pWnd->GetWindowRect(rect);
	CRect rectWindow(rect);
	pWnd->ScreenToClient(&rect);
	CPoint ptOffset(-rect.left, -rect.top);
	rect.OffsetRect(ptOffset);

	// Exclude the client rectangle
	CRect rectClient;
	pWnd->GetClientRect(rectClient);
	rectClient.OffsetRect(ptOffset);
	dc.ExcludeClipRect(rectClient);

	// Fill the background
	dc.FillSolidRect(rect, m_pSkinXP->GetBackgroundColor());

	// Draw the inner white border
	CBrush brushWhite;
	COLORREF clrWhite = ::GetSysColor(COLOR_WINDOW);
	brushWhite.CreateSolidBrush(clrWhite);
	rect.DeflateRect(1, 1);
	dc.FillSolidRect(rect, clrWhite);

	// Determine the state of the edit box
	CPoint ptCursor;
	::GetCursorPos(&ptCursor);
	if (rectWindow.PtInRect(ptCursor) || CWnd::GetFocus() == pWnd)
	{
		// The combo box is hot - draw the border
		rect.InflateRect(1, 1);
		CBrush brush;
		brush.CreateSolidBrush(m_pSkinXP->GetActiveBorderColor());
		dc.FrameRect(rect, &brush);
	}
}

// Draw the text in the specified rectangle
void COXToolbarSkinXP::DrawItemText(CDC* pDC, TBBUTTON* pTBB, DWORD dwStyleEx, LPCRECT lpRectItem, COLORREF clrText, COXCoolToolBar* pCoolToolbar)
{
	CString strText;

	// This is either a toolbar or a menubar
	COXMenuBar* pMenuBar = DYNAMIC_DOWNCAST(COXMenuBar, pCoolToolbar);
	if (pMenuBar != NULL && (pTBB->fsStyle & TBSTYLE_DROPDOWN) && !(dwStyleEx & TBSTYLE_EX_DRAWDDARROWS))
		strText = pMenuBar->GetItemText(pTBB->idCommand - 1);
	else
		strText = pCoolToolbar->GetButtonText(pCoolToolbar->CommandToIndex(pTBB->idCommand));

	if (strText.IsEmpty())
		return; // there is no text
	
	CRect rectItem(lpRectItem);

	// Get the image rectangle and size
	CRect rectImage = GetIconRect(pTBB->idCommand, pCoolToolbar);
	CSize sizeImage(rectImage.Width(), rectImage.Height());
	
	// If this is a drop down item the rectangle needs to be decremented
	if ((pTBB->fsStyle & TBSTYLE_DROPDOWN)  && (dwStyleEx & TBSTYLE_EX_DRAWDDARROWS))
	{
		CRect rectDropArrow = GetDropArrowRect(pDC, lpRectItem);
		rectItem.right -= rectDropArrow.Width();
	}

	CRect rectIcon = GetIconRect(pTBB->idCommand, pCoolToolbar);

	// Determine the text rectangle
	if (pCoolToolbar->IsList())
	{
		// The text needs to be to the right of the icon
		rectItem.left += sizeImage.cx + 6;
		rectItem.right -= 3;
	}
	else // not list
	{
		// The text needs to be under the icon
		rectItem.top += rectIcon.Height() + 1;
		rectItem.DeflateRect(3, 3);
	}

	DWORD dwDTFlags = DT_WORDBREAK | DT_END_ELLIPSIS;
	if (pCoolToolbar->GetTextRows() == 1)
		dwDTFlags |= DT_SINGLELINE;
	
	if (pCoolToolbar->IsList())
		dwDTFlags |= DT_VCENTER;
	else
		dwDTFlags |= DT_CENTER;

	COLORREF clrOldColor = pDC->SetTextColor(clrText);
	CFont* pOldFont = pDC->SelectObject(pCoolToolbar->GetFont());
	int iOldBkMode = pDC->SetBkMode(TRANSPARENT);
	pDC->DrawText(strText, rectItem, dwDTFlags);
	pDC->SetBkMode(iOldBkMode);
	pDC->SelectObject(pOldFont);
	pDC->SetTextColor(clrOldColor);
}

// Returns the rectangle of the item's icon
CRect COXToolbarSkinXP::GetIconRect(DWORD dwCommandID, COXCoolToolBar* pCoolToolbar)
{
	CImageList* pImageList = pCoolToolbar->GetToolBarCtrl().GetImageList();

	// Get the image index of the item
	int iImageIndex;
	UINT nDummy;
	pCoolToolbar->GetButtonInfo(pCoolToolbar->CommandToIndex(dwCommandID), nDummy, nDummy, iImageIndex);

	if (iImageIndex == -1)
		return CRect(0, 0, 0, 0); // no icon

	// Get the image rectangle and size
	IMAGEINFO img_info;
	pImageList->GetImageInfo(iImageIndex, &img_info);

	return img_info.rcImage;
}

// Determine the rectangle of the drop arrow button
CRect COXToolbarSkinXP::GetDropArrowRect(CDC* pDC, LPCRECT lpRectItem)
{
	CRect rectItem(lpRectItem);

	// Determine the width of the drop arrow character
	CFont fontWebdings;
	fontWebdings.CreatePointFont(80, _T("Marlett"));
	CFont* pOldFont = pDC->SelectObject(&fontWebdings);
	CRect rectChar(0, 0, 0, 0);
	pDC->DrawText(_T("6"), rectChar, DT_CALCRECT);
	pDC->SelectObject(pOldFont);

	rectItem.left = rectItem.right - rectChar.right - 4;
	return rectItem;
}

// Draws the insert mark of the toolbar when in customize mode
void COXToolbarSkinXP::DrawInsertMark(CDC* pDC, COXCoolToolBar* pCoolToolbar)
{
	// Get the insert mark
	CToolBarCtrl& ctrl = pCoolToolbar->GetToolBarCtrl();
	TBINSERTMARK tbim;
	ctrl.GetInsertMark(&tbim);

	if (tbim.iButton == -1)
		return; // there is no insert mark

	// Determine the position rectangle of the insert mark
	CRect rectMark;
	pCoolToolbar->GetItemRect(tbim.iButton, &rectMark);
	if (tbim.dwFlags == 0)
	{
		// The insert mark is before the button
		rectMark.right = rectMark.left + 3;
	}
	else if (tbim.dwFlags & TBIMHT_AFTER)
	{
		// The insert mark is after the button
		rectMark.left = rectMark.right - 3;
	}
	else
		return;

	// Do the actual drawing
	pDC->FillSolidRect(rectMark, ::GetSysColor(COLOR_BTNTEXT));
}

void COXToolbarSkinXP::DrawMenuButtons(CDC* pDC, COXMenuBar* pMenuBar)
{
	ASSERT(pMenuBar->m_pFrameWnd!=NULL);
	ASSERT(::IsWindow(pMenuBar->m_pFrameWnd->m_hWnd));
	ASSERT_KINDOF(CMDIFrameWnd,pMenuBar->m_pFrameWnd);

    BOOL bMaximize=FALSE;
	CMDIChildWnd* pChild=((CMDIFrameWnd*)pMenuBar->m_pFrameWnd)->MDIGetActive(&bMaximize);
	if(pChild==NULL || !bMaximize)
		return;

	ASSERT(!pMenuBar->m_rectCloseBtn.IsRectEmpty());
	if(pMenuBar->m_rectCloseBtn.IsRectEmpty())
		return;

	// close button
	m_pSkinXP->DrawFrameButton(pDC, pMenuBar->m_rectCloseBtn, DFCS_CAPTIONCLOSE,
		FALSE, FALSE, ::GetSysColor(COLOR_BTNFACE), pMenuBar);

	// Max/restore button
	if (!pMenuBar->m_rectRestoreBtn.IsRectEmpty())
		m_pSkinXP->DrawFrameButton(pDC, pMenuBar->m_rectRestoreBtn, DFCS_CAPTIONRESTORE,
		FALSE, FALSE, ::GetSysColor(COLOR_BTNFACE), pMenuBar);

	// Minimize button
	if (!pMenuBar->m_rectMinimizeBtn.IsRectEmpty())
		m_pSkinXP->DrawFrameButton(pDC, pMenuBar->m_rectMinimizeBtn, DFCS_CAPTIONMIN,
		FALSE, FALSE, ::GetSysColor(COLOR_BTNFACE), pMenuBar);
}

// COXToolbarSkin2003
//

COXToolbarSkin2003::COXToolbarSkin2003(COXSkin2003* pSkin2003) :
	COXToolbarSkinXP(pSkin2003)
{
}

COXToolbarSkin2003::~COXToolbarSkin2003()
{
}

void COXToolbarSkin2003::DrawBackground(CDC* pDC, COXCoolToolBar* pCoolToolbar)
{
	CRect rcClient;
	pCoolToolbar->GetWindowRect(rcClient);
	pCoolToolbar->ScreenToClient(rcClient);

	if (pCoolToolbar->IsKindOf(RUNTIME_CLASS(COXMenuBar)))
	{
		CRect rectMain;
		pCoolToolbar->GetParentFrame()->GetWindowRect(rectMain);

		// Get the toolbar screen rectangle
		CRect rectToolbar;
		pCoolToolbar->GetWindowRect(rectToolbar);

		int iWidth = ::GetSystemMetrics(SM_CXSCREEN);
		if (iWidth < rectMain.Width())
			iWidth = rectMain.Width();

		CRect rectGradient;
		rectGradient.left = rectMain.left - rectToolbar.left - 2;
		rectGradient.right = rectGradient.left + iWidth;
		rectGradient.top = 0;
		rectGradient.bottom = rectToolbar.Height();

		CRect rectSolid(rectGradient);
		rectGradient.right = rectGradient.CenterPoint().x;
		rectSolid.left = rectGradient.right;

		COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
		pSkin2003->GradientFill(pDC, rectGradient,
			pSkin2003->GetDockbarLeftColor(),
			pSkin2003->GetDockbarRightColor(),
			GRADIENT_FILL_RECT_H);
		pDC->FillSolidRect(rectSolid, pSkin2003->GetDockbarRightColor());
	}
	else
	{
		COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
		if (pCoolToolbar->m_dwStyle & CBRS_ORIENT_HORZ)
			pSkin2003->GradientFill(pDC, rcClient,
				pSkin2003->GetToolbarLightColor(),
				pSkin2003->GetToolbarDarkColor(),
				GRADIENT_FILL_RECT_V);
		else
			pSkin2003->GradientFill(pDC, rcClient,
				pSkin2003->GetToolbarLightColor(),
				pSkin2003->GetToolbarDarkColor(),
				GRADIENT_FILL_RECT_H);
	}
}

void COXToolbarSkin2003::DrawNonClientArea(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* pCoolToolbar)
{
	CRect rcNonClient(lpRect);

	// Get the client rectangle in window coordinates
	CRect rcClient, rectWindow;
	pCoolToolbar->GetWindowRect(rectWindow);
	pCoolToolbar->GetClientRect(rcClient);
	pCoolToolbar->ClientToScreen(rcClient);
	rcClient.OffsetRect(-rectWindow.left, -rectWindow.top);
	
	// Clip out the client area
	pDC->ExcludeClipRect(rcClient);

	// Fill the background

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	// Draw the border gradient first, which should match the dockbar
	
	if (pCoolToolbar->m_pDockBar != NULL)
	{
		CRect rectMain;
		pCoolToolbar->GetParentFrame()->GetWindowRect(rectMain);

		// Get the toolbar screen rectangle
		CRect rectToolbar;
		pCoolToolbar->GetWindowRect(rectToolbar);

		int iWidth = ::GetSystemMetrics(SM_CXSCREEN);
		if (iWidth < rectMain.Width())
			iWidth = rectMain.Width();

		CRect rectGradient;
		rectGradient.left = rectMain.left - rectToolbar.left;
		rectGradient.right = rectGradient.left + iWidth;
		rectGradient.top = 0;
		rectGradient.bottom = rectToolbar.Height();

		CRect rectSolid(rectGradient);
		rectGradient.right = rectGradient.CenterPoint().x;
		rectSolid.left = rectGradient.right;

		if (::GetVersion() >= 0x80000000)
			// Adoid a problem with the ::GradientFill() API in Win98 and ME
			pSkin2003->GradientFillManual(pDC, rectGradient,
				pSkin2003->GetDockbarLeftColor(),
				pSkin2003->GetDockbarRightColor(),
				GRADIENT_FILL_RECT_H);
		else
			pSkin2003->GradientFill(pDC, rectGradient,
				pSkin2003->GetDockbarLeftColor(),
				pSkin2003->GetDockbarRightColor(),
				GRADIENT_FILL_RECT_H);

		pDC->FillSolidRect(rectSolid, pSkin2003->GetDockbarRightColor());
	}
	else
		pDC->FillSolidRect(rcNonClient, pSkin2003->GetDockbarBackgroundColor());


	if (!pCoolToolbar->IsKindOf(RUNTIME_CLASS(COXMenuBar)))
	{
		CRect rectInner(lpRect);
		rectInner.DeflateRect(2, 2);

		// Save the four corner pixels
		COLORREF clrPixels[4];
		clrPixels[0] = pDC->GetPixel(rectInner.TopLeft());
		clrPixels[1] = pDC->GetPixel(rectInner.right - 1, rectInner.top);
		clrPixels[2] = pDC->GetPixel(rectInner.left, rectInner.bottom - 1);
		clrPixels[3] = pDC->GetPixel(rectInner.right - 1, rectInner.bottom - 1);

		// Now draw the toolbar gradient
		ULONG ulGradientOrientation;
		if (pCoolToolbar->m_dwStyle & CBRS_ORIENT_HORZ)
			ulGradientOrientation = GRADIENT_FILL_RECT_V;
		else
			ulGradientOrientation = GRADIENT_FILL_RECT_H;

		if (::GetVersion() >= 0x80000000)
			// Adoid a problem with the ::GradientFill() API in Win98 and ME
			pSkin2003->GradientFillManual(pDC, rectInner,
				pSkin2003->GetToolbarLightColor(),
				pSkin2003->GetToolbarDarkColor(),
				ulGradientOrientation);
		else
			pSkin2003->GradientFill(pDC, rectInner,
				pSkin2003->GetToolbarLightColor(),
				pSkin2003->GetToolbarDarkColor(),
				ulGradientOrientation);

		// Restore the four corner pixels
		pDC->SetPixelV(rectInner.TopLeft(), clrPixels[0]);
		pDC->SetPixelV(rectInner.right - 1, rectInner.top, clrPixels[1]);
		pDC->SetPixelV(rectInner.left, rectInner.bottom - 1, clrPixels[2]);
		pDC->SetPixelV(rectInner.right - 1, rectInner.bottom - 1, clrPixels[3]);
	}
}

void COXToolbarSkin2003::DrawGripper(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* pCoolToolbar)
{
    if (pCoolToolbar->m_dwStyle & CBRS_FLOATING)
		return;		// no gripper if floating

	CRect rect(lpRect);
	CRect gripperRect(lpRect);
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	if (pCoolToolbar->m_dwStyle & CBRS_ORIENT_HORZ) 
	{
		gripperRect.DeflateRect(2, 6, 2, 5);
		gripperRect.OffsetRect(1, 0);
		// gripper at left
		if (pCoolToolbar->m_pDockContext != NULL)
		{
			// EnableDocking was called
			gripperRect.left += 2;
			gripperRect.bottom -= 2;
		}
		else
		{
			if (pCoolToolbar->m_dwStyle & CBRS_BORDER_BOTTOM)
			{
				gripperRect.top -= 2;
				gripperRect.bottom -= 2;
			}
		}
		gripperRect.right = gripperRect.left + 2;
        pSkin2003->DrawGripperStripes(pDC, gripperRect, true);
	} 
	else // vertical
	{
		gripperRect.DeflateRect(3, 4, 7, 4);
		gripperRect.OffsetRect(0, 1);
		// gripper at top
		if (pCoolToolbar->m_pDockContext == NULL)
		{
			// EnableDocking was not called
			gripperRect.right += 2;
		}
		else
		{
			gripperRect.left += 2;
		}
		gripperRect.bottom = gripperRect.top + 2;
		pSkin2003->DrawGripperStripes(pDC, gripperRect, false);
	}
}

void COXToolbarSkin2003::DrawSeparator(CDC* pDC, LPCRECT lpRect, COXCoolToolBar* /*pCoolToolbar*/)
{
	CRect rect(lpRect);

	if (rect.Height() > rect.Width()) 
	{
		// Horizontal separator
		rect.left = rect.CenterPoint().x - 1;
		rect.right = rect.left + 1;
		rect.top += 4;
		rect.bottom -= 4;
	} 
	else 
	{
		// Vertical separator
		rect.top = rect.CenterPoint().y - 1;
		rect.bottom = rect.top + 1;
		rect.left += 4;
		rect.right -= 4;
	}

	pDC->FillSolidRect(rect,  m_pSkinXP->GetSeparatorColor());
	rect.OffsetRect(1, 1);
	pDC->FillSolidRect(rect,  RGB(255,255,255)); // This color is always white
}

void COXToolbarSkin2003::DrawMenuButtons(CDC* pDC, COXMenuBar* pMenuBar)
{
	ASSERT(pMenuBar->m_pFrameWnd!=NULL);
	ASSERT(::IsWindow(pMenuBar->m_pFrameWnd->m_hWnd));
	ASSERT_KINDOF(CMDIFrameWnd,pMenuBar->m_pFrameWnd);

    BOOL bMaximize=FALSE;
	CMDIChildWnd* pChild=((CMDIFrameWnd*)pMenuBar->m_pFrameWnd)->MDIGetActive(&bMaximize);
	if(pChild==NULL || !bMaximize)
		return;

	ASSERT(!pMenuBar->m_rectCloseBtn.IsRectEmpty());
	if(pMenuBar->m_rectCloseBtn.IsRectEmpty())
		return;

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	// close button
	pSkin2003->DrawFrameButton(pDC, pMenuBar->m_rectCloseBtn, DFCS_CAPTIONCLOSE,
		FALSE, FALSE, ::GetSysColor(COLOR_BTNFACE), pMenuBar);

	// Max/restore button
	if (!pMenuBar->m_rectRestoreBtn.IsRectEmpty())
		pSkin2003->DrawFrameButton(pDC, pMenuBar->m_rectRestoreBtn, DFCS_CAPTIONRESTORE,
			FALSE, FALSE, ::GetSysColor(COLOR_BTNFACE), pMenuBar);

	// Minimize button
	if (!pMenuBar->m_rectMinimizeBtn.IsRectEmpty())
		pSkin2003->DrawFrameButton(pDC, pMenuBar->m_rectMinimizeBtn, DFCS_CAPTIONMIN,
			FALSE, FALSE, ::GetSysColor(COLOR_BTNFACE), pMenuBar);
}

// Draws a raised background with a shadow
void COXToolbarSkin2003::DrawDroppedItemBackground(CDC* /*pDC*/, LPCRECT /*lpRect*/)
{

}

void COXToolbarSkin2003::DrawItem(CDC* pDC, TBBUTTON* pTBB, LPCRECT lpRectItem, COXCoolToolBar* pCoolToolbar, BOOL bDrawBackground)
{
	// Determine the state flags
	bool bSelected = ((pTBB->fsState & TBSTATE_PRESSED) != 0);
	bool bHot = (pCoolToolbar->GetToolBarCtrl().GetHotItem() == pCoolToolbar->CommandToIndex(pTBB->idCommand));
	bool bDisabled = ((pTBB->fsState & TBSTATE_ENABLED) == 0);
	bool bChecked = ((pTBB->fsState & TBSTATE_CHECKED) != 0);

	DWORD dwStyleEx = pCoolToolbar->GetStyleEx();
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	if (pCoolToolbar->m_iDropDownIndex == pTBB->idCommand)
	{
		// We have a droped drop down button
		pCoolToolbar->m_iDropDownIndex = -1;

		if (bDrawBackground)
			DrawDroppedItemBackground(pDC, lpRectItem);

		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);
	}
	else if (bSelected && bHot)
	{
		// Selected and hot
		if (bDrawBackground)
			DrawGradientItemBackground(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetActiveBorderColor(),
				pSkin2003->GetHotSelectedToolbarItemLightColor(),
				pSkin2003->GetHotSelectedToolbarItemDarkColor());
		
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetSelectedTextColor(), pCoolToolbar);
	}
	else if (bChecked && bHot)
	{
		// Checked and hot - same as selected and hot
		if (bDrawBackground)
			DrawGradientItemBackground(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetActiveBorderColor(),
				pSkin2003->GetHotSelectedToolbarItemLightColor(),
				pSkin2003->GetHotSelectedToolbarItemDarkColor());
		
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetSelectedTextColor(), pCoolToolbar);
	}
	else if (bChecked)
	{
		// Just chequed
		if (bDrawBackground)
			DrawGradientItemBackground(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetActiveBorderColor(),
				pSkin2003->GetCheckedToolbarItemLightColor(),
				pSkin2003->GetCheckedToolbarItemDarkColor());
		
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, false, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);
	}
	else if (bHot)
	{
		// Just hot
		if (bDrawBackground)
			DrawGradientItemBackground(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetActiveBorderColor(),
				pSkin2003->GetHotToolbarItemLightColor(),
				pSkin2003->GetHotToolbarItemDarkColor());

		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);
	}
	else if (bSelected)
	{
		// This can only be a menu item, so decrease the height
		if (bDrawBackground)
		{
			CRect rectItem(lpRectItem);
			rectItem.DeflateRect(0, 1);
			DrawDroppedItemBackground(pDC, rectItem);
		}

		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, true, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);
	}
	else if (bDisabled)
	{
		// Disabled
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, false, true, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetDisabledTextColor(), pCoolToolbar);
	}
	else
	{
		// Normal
		DrawItemIcon(pDC, pTBB, dwStyleEx, lpRectItem, false, false, false, pCoolToolbar);
		DrawItemText(pDC, pTBB, dwStyleEx, lpRectItem, m_pSkinXP->GetTextColor(), pCoolToolbar);		
	}
}

void COXToolbarSkin2003::DrawGradientItemBackground(CDC* pDC, TBBUTTON* pTBB, DWORD dwStyleEx, LPCRECT lpRect, COLORREF crBorder, COLORREF crInsideLight, COLORREF crInsideDark)
{
	// Fill the inside
	CRect rect(lpRect);
	rect.DeflateRect(1, 1);

	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
	pSkin2003->GradientFill(pDC, rect, crInsideLight, crInsideDark, GRADIENT_FILL_RECT_V);
	rect.InflateRect(1, 1);

	if (pTBB->iBitmap == -1 && (pTBB->fsStyle & TBSTYLE_DROPDOWN) && !(dwStyleEx & TBSTYLE_EX_DRAWDDARROWS))
	{
		// This is a menu item, so decrease the height
		rect.DeflateRect(0, 1);
	}

	// Draw the borders
	CBrush brush;
	brush.CreateSolidBrush(crBorder);
	pDC->FrameRect(rect, &brush);

	// If this is drop arrow button, frame the arrow part
	if ((pTBB->fsStyle & TBSTYLE_DROPDOWN) && (dwStyleEx & TBSTYLE_EX_DRAWDDARROWS))
		pDC->FrameRect(GetDropArrowRect(pDC, rect), &brush);
}

void COXToolbarSkin2003::DrawComboBox(COXSkinnedComboBox* pComboBox)
{
	CClientDC dc(pComboBox);
	COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;

	CRect rect;
	pComboBox->GetClientRect(rect);
	POINT ptCursor;
	::GetCursorPos(&ptCursor);
	pComboBox->ScreenToClient(&ptCursor);

	// Determine and exclude the combo box rectangle
	CRect rectCombo(rect);
	rectCombo.DeflateRect(3, 3, rect.Height() - 2, 3);

	dc.ExcludeClipRect(rectCombo);
	rectCombo.InflateRect(1, 1);
	if (pComboBox->m_bCommonControls6)
		rectCombo.right += 3;

	// Determine the button rectangle
	CRect rectButton(rect);
	rectButton.DeflateRect(2, 2, 3, 2);
	rectButton.left = rectCombo.Width() + 2;

	// Fill the background - must match the toolbar background
	{
		COXCoolToolBar* pToolbar = (COXCoolToolBar*) pComboBox->GetParent();

		CRect rectToolbar;
		pToolbar->GetWindowRect(rectToolbar);

		// Get the combo box rectangle
		CRect rectCombo;
		pComboBox->GetWindowRect(rectCombo);
		rectCombo.OffsetRect(-rectToolbar.left, -rectToolbar.top);

		CRect rectGradient(rect);
		rectGradient.top = -rectCombo.top;
		rectGradient.bottom = rectGradient.top + rectToolbar.Height();

		// Limit the drawing to the combo box
		dc.IntersectClipRect(rect);

		pSkin2003->GradientFill(&dc, rectGradient,
			pSkin2003->GetTabBackgroundLightColor(),
			pSkin2003->GetTabBackgroundDarkColor(),
			GRADIENT_FILL_RECT_V);
	}

	// Draw the inner white border
	CBrush brushWhite;
	COLORREF clrWhite = ::GetSysColor(COLOR_WINDOW);
	brushWhite.CreateSolidBrush(clrWhite);
	rectCombo.InflateRect(1, 1, 0, 0);
	dc.FillSolidRect(rectCombo, clrWhite);

	rectButton.InflateRect(1, 1, 0, 0);
	dc.FrameRect(rectButton, &brushWhite);

	// The combo box can have three states - normal, hot and dropped
	// Determine the state of the combo box
	BOOL bHotOrSelected = FALSE;
	COLORREF clrLightColor = 0, clrDarkColor = 0;
	COLORREF clrArrow = ::GetSysColor(COLOR_BTNTEXT);
	if (pComboBox->GetDroppedState())
	{
		// The combo box is dropped
		bHotOrSelected = TRUE;
		clrLightColor = pSkin2003->GetHotSelectedToolbarItemLightColor();
		clrDarkColor = pSkin2003->GetHotSelectedToolbarItemDarkColor();
		clrArrow = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
	}
	else if (rect.PtInRect(ptCursor) || CWnd::GetFocus() == pComboBox ||
		(CWnd::GetFocus() && CWnd::GetFocus()->GetParent() == pComboBox))
	{
		// The combo box is hot
		bHotOrSelected = TRUE;
		clrLightColor = pSkin2003->GetHotToolbarItemLightColor();
		clrDarkColor = pSkin2003->GetHotToolbarItemDarkColor();
	}

	// Perform the drawing of a droped or hot combo box
	if (bHotOrSelected)
	{
		rectCombo.InflateRect(1, 1, 0, 1);
		rectButton.InflateRect(0, 1, 1, 1);

		// Draw the button
		CPen penBorder;
		penBorder.CreatePen(PS_SOLID, 1, m_pSkinXP->GetActiveBorderColor());
		CPen* pOldPen = dc.SelectObject(&penBorder);
		dc.Rectangle(rectButton);

		CRect rectGradient(rectButton);
		rectGradient.DeflateRect(1, 1);
		pSkin2003->GradientFill(&dc, rectGradient, clrLightColor, clrDarkColor,
			GRADIENT_FILL_RECT_V);

		dc.Rectangle(rectCombo);
		dc.SelectObject(pOldPen);
	}
	
	// Draw the drop arrow
	CPoint ptCenter = rectButton.CenterPoint();
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, clrArrow);
	CPen* pOldPen = dc.SelectObject(&pen);
	dc.MoveTo(ptCenter.x - 2, ptCenter.y - 1);
	dc.LineTo(ptCenter.x + 3, ptCenter.y - 1);
	dc.MoveTo(ptCenter.x - 1, ptCenter.y);
	dc.LineTo(ptCenter.x + 2, ptCenter.y);
	dc.SetPixelV(ptCenter.x, ptCenter.y + 1, clrArrow);
	dc.SelectObject(pOldPen);
}

void COXToolbarSkin2003::DrawWndFrame(CWnd* pWnd)
{
	CWindowDC dc(pWnd);

	CRect rect;
	pWnd->GetWindowRect(rect);
	CRect rectWindow(rect);
	pWnd->ScreenToClient(&rect);
	CPoint ptOffset(-rect.left, -rect.top);
	rect.OffsetRect(ptOffset);

	// Exclude the client rectangle
	CRect rectClient;
	pWnd->GetClientRect(rectClient);
	rectClient.OffsetRect(ptOffset);
	dc.ExcludeClipRect(rectClient);

	// Fill the background
	// Fill the background - must match the toolbar background
	{
		COXCoolToolBar* pToolbar = (COXCoolToolBar*) pWnd->GetParent();

		CRect rectToolbar;
		pToolbar->GetWindowRect(rectToolbar);

		// Get the combo box rectangle
		CRect rectCombo;
		pWnd->GetWindowRect(rectCombo);
		rectCombo.OffsetRect(-rectToolbar.left, -rectToolbar.top);

		CRect rectGradient(rect);
		rectGradient.top = -rectCombo.top;
		rectGradient.bottom = rectGradient.top + rectToolbar.Height();

		COXSkin2003* pSkin2003 = (COXSkin2003*) m_pSkinXP;
		if (::GetVersion() >= 0x80000000)
			// Adoid a problem with the ::GradientFill() API in Win98 and ME
			pSkin2003->GradientFillManual(&dc, rectGradient,
				pSkin2003->GetTabBackgroundLightColor(),
				pSkin2003->GetTabBackgroundDarkColor(),
				GRADIENT_FILL_RECT_V);
		else
			pSkin2003->GradientFill(&dc, rectGradient,
				pSkin2003->GetTabBackgroundLightColor(),
				pSkin2003->GetTabBackgroundDarkColor(),
				GRADIENT_FILL_RECT_V);
	}

	// Draw the inner white border
	CBrush brushWhite;
	COLORREF clrWhite = ::GetSysColor(COLOR_WINDOW);
	brushWhite.CreateSolidBrush(clrWhite);
	rect.DeflateRect(1, 1);
	dc.FillSolidRect(rect, clrWhite);

	// Determine the state of the edit box
	CPoint ptCursor;
	::GetCursorPos(&ptCursor);
	if (rectWindow.PtInRect(ptCursor) || CWnd::GetFocus() == pWnd)
	{
		// The combo box is hot - draw the border
		rect.InflateRect(1, 1);
		CBrush brush;
		brush.CreateSolidBrush(m_pSkinXP->GetActiveBorderColor());
		dc.FrameRect(rect, &brush);
	}
}

// COXMiniFrameSkin
//



// COXMiniFrameSkinClassic
//

BOOL COXMiniFrameSkinClassic::OnNcActivate(BOOL bActive, COXSizableMiniDockFrameWnd* pMiniDockFrameWnd)
{
	// CMiniDockFrameWnd class assumes if there is only 1 bar, 
	// then it's at position 1 in the array
	CControlBar* pBar=((COXSizeDockBar *)&pMiniDockFrameWnd->m_wndDockBar)->GetFirstControlBar();
	if(pBar!=NULL)
	{
		ASSERT_KINDOF(CControlBar, pBar);
		ASSERT(pBar->m_pDockContext != NULL);
		if(pBar->IsKindOf(RUNTIME_CLASS(COXSizeViewBar)))
		{
			COXMDIChildWndSizeDock* pMDIChild=((COXSizeViewBar*)pBar)->m_pChildWnd;
			if(::IsWindow(pMDIChild->m_hWnd))
			{
				if(pMDIChild->MDIGetActive()!=pMDIChild && bActive)
					return FALSE;
				else
					return (BOOL)pMiniDockFrameWnd->Default();
			}
		}
	}

	return ((CMiniDockFrameWnd*) pMiniDockFrameWnd)->OnNcActivate(bActive);
}

void COXMiniFrameSkinClassic::OnNcPaint(COXSizableMiniDockFrameWnd* pMiniDockFrameWnd)
{
	pMiniDockFrameWnd->Default();
}


// COXMiniFrameSkinXP
//

COXMiniFrameSkinXP::COXMiniFrameSkinXP(COXSkinXP* pSkinXP)
{
	m_pSkinXP = pSkinXP;
	m_fontCaption.CreatePointFont(85, _T("Tahoma BOLD"));
}

BOOL COXMiniFrameSkinXP::OnNcActivate(BOOL /*bActive*/, COXSizableMiniDockFrameWnd* /*pMiniDockFrameWnd*/)
{
	return TRUE;
}

// Draw the Office XP style caption of the mini frame window
void COXMiniFrameSkinXP::OnNcPaint(COXSizableMiniDockFrameWnd* pMiniDockFrameWnd)
{
	// Get the window rectangle and the DC
	CWindowDC dc(pMiniDockFrameWnd);
	CRect rect(0,0,0,0);
	pMiniDockFrameWnd->GetWindowRect(rect);
	pMiniDockFrameWnd->ScreenToClient(rect);
	CPoint ptOffset = rect.TopLeft();
	rect.OffsetRect(-ptOffset.x, -ptOffset.y);

	// Excluse the client rectangle from the clipping region
	CRect rectClient;
	pMiniDockFrameWnd->GetClientRect(rectClient);
	rectClient.OffsetRect(-ptOffset.x, -ptOffset.y);
	dc.ExcludeClipRect(rectClient);

	// Fill the outer dark rectangle
	COLORREF clrOuter = m_pSkinXP->GetMiniFrameBorderColor();
	dc.FillSolidRect(rect, clrOuter);
	
	// Fill the inner light rectangle
	rect.DeflateRect(2, 2);
	dc.FillSolidRect(rect, m_pSkinXP->GetMiniFrameLightBorderColor());

	// Draw the 4 corner points
	dc.SetPixelV(rect.TopLeft(), clrOuter);
	dc.SetPixelV(rect.right - 1, rect.top, clrOuter);
	dc.SetPixelV(rect.right - 1, rect.bottom - 1, clrOuter);
	dc.SetPixelV(rect.left, rect.bottom - 1, clrOuter);

	DrawCaption(pMiniDockFrameWnd);
}

void COXMiniFrameSkinXP::DrawCaption(COXSizableMiniDockFrameWnd* pMiniDockFrameWnd)
{
	// Get the window rectangle and the DC
	CWindowDC dc(pMiniDockFrameWnd);
	CRect rectCaption = GetCaptionRect(pMiniDockFrameWnd);

	// Draw the backbround of the caption
	dc.FillSolidRect(rectCaption, m_pSkinXP->GetMiniFrameCaptionColor());

	// Get the caption text
	CString strCaption;
	pMiniDockFrameWnd->GetWindowText(strCaption);

	// Draw the text
	CFont* pOldFont = dc.SelectObject(&m_fontCaption);
	COLORREF clrOld = dc.SetTextColor(m_pSkinXP->GetMiniFrameCaptionTextColor());
	rectCaption.DeflateRect(3, 0);
	dc.DrawText(strCaption, rectCaption, DT_SINGLELINE | DT_VCENTER);
	dc.SetTextColor(clrOld);
	dc.SelectObject(pOldFont);

	DrawCaptionButtons(pMiniDockFrameWnd);
}

// Returns the rectangle of the caption bar
CRect COXMiniFrameSkinXP::GetCaptionRect(COXSizableMiniDockFrameWnd* pMiniDockFrameWnd)
{
	CRect rect(0,0,0,0);
	pMiniDockFrameWnd->GetWindowRect(rect);
	pMiniDockFrameWnd->ScreenToClient(rect);
	CPoint ptOffset = rect.TopLeft();
	rect.OffsetRect(-ptOffset.x, -ptOffset.y);

	// Get the caption rectangle
	rect.DeflateRect(2, 2);
	CRect rectCaption;
	rectCaption.left = rect.left + 1;
	rectCaption.top = rect.top + 1;
	rectCaption.right = rect.right - 1;
	rectCaption.bottom = rectCaption.top - ptOffset.y - 5;

	return rectCaption;
}

// Draws the maximize button in Office XP style
BOOL COXMiniFrameSkinXP::DrawCaptionButtons(COXSizableMiniDockFrameWnd* pMiniDockFrameWnd)
{
	if (pMiniDockFrameWnd->GetSystemMenu(FALSE)->GetMenuItemCount() == 0)
		return TRUE; // do not draw if the button is disabled

	// Determine the button rectangle
	CRect rect = GetCaptionRect(pMiniDockFrameWnd);
	rect.left = rect.right - rect.Height();

	// Get the cursor position in window coordinates
	POINT ptCursor;
	::GetCursorPos(&ptCursor);
	pMiniDockFrameWnd->ScreenToClient(&ptCursor);
	ptCursor.x += 4;
	ptCursor.y += rect.Height() + 4;
	
	// Determine the state of the button
	bool bLeftButtonDown = (::GetKeyState(VK_LBUTTON) < 0);
	CRect rectTest(rect);
	rectTest.DeflateRect(0, 0, 1, 1);
	BOOL bMouseOnClose = rectTest.PtInRect(ptCursor);

	// Determine the colors
	COLORREF clrX;
	CBrush brush;
	brush.m_hObject = NULL;
	if (bMouseOnClose && bLeftButtonDown)
	{
		// Pressed
		clrX = ::GetSysColor(COLOR_HIGHLIGHTTEXT);
		brush.CreateSolidBrush(m_pSkinXP->GetHotSelectedItemColor());
	}
	else if (bMouseOnClose)
	{
		// Hot
		clrX = ::GetSysColor(COLOR_BTNTEXT);
		brush.CreateSolidBrush(m_pSkinXP->GetHotItemColor());
	}
	else
	{
		// Normal - just the X
		clrX = m_pSkinXP->GetMiniFrameCaptionTextColor();
	}

	// Draw to a memory dc to avoid flashing
	CWindowDC dcWindow(pMiniDockFrameWnd);
	CDC dc;
	dc.CreateCompatibleDC(&dcWindow);
	CBitmap bmpMem;
	CRect rectButton(rect);
	rectButton.OffsetRect(-rect.left, -rect.top);
	bmpMem.CreateCompatibleBitmap(&dcWindow, rectButton.Width(), rectButton.Height());
	CBitmap* pOldBmp = dc.SelectObject(&bmpMem);

	// Perform the drawing
	if (brush.m_hObject != NULL)
	{
		// Draw a frame
		CBrush* pOldBrush = dc.SelectObject(&brush);
		CPen penBorder;
		penBorder.CreatePen(PS_SOLID, 1, m_pSkinXP->GetActiveBorderColor());
		CPen* pOldPen = dc.SelectObject(&penBorder);
		dc.Rectangle(rectButton);
		dc.SelectObject(pOldPen);
		dc.SelectObject(pOldBrush);
	}
	else
		dc.FillSolidRect(rectButton, m_pSkinXP->GetMiniFrameCaptionColor());

	// Draw the "x" inside the button
	CRect rectX(rectButton);
	rectX.DeflateRect(4, 4, 5, 5);
	CPen pen;
	pen.CreatePen(PS_SOLID, 1, clrX);
	CPen* pOldPen = dc.SelectObject(&pen);
	for (int i = 0; i < 2; i++)
	{
		dc.MoveTo(rectX.left, rectX.top);
		dc.LineTo(rectX.right + 1, rectX.bottom + 1);
		dc.MoveTo(rectX.right, rectX.top);
		dc.LineTo(rectX.left - 1, rectX.bottom + 1);
		rectX.OffsetRect(1, 0);
	}

	dc.SelectObject(pOldPen);

	// Copy the memory dc to the window dc
	dcWindow.BitBlt(rect.left, rect.top, rect.Width(), rect.Height(), &dc, 0, 0, SRCCOPY);
	dc.SelectObject(pOldBmp);

	return TRUE;
}

// Floating windows are not always children of the main frame, so we need to iterate
// through all top level windows.
void COXSkinnedApp::UpdateFloatingWindows(CWnd* pMainWnd)
{
	HWND hMainWnd = pMainWnd->m_hWnd;

	// Walk through all top-level windows
	HWND hWnd = ::GetWindow(::GetDesktopWindow(), GW_CHILD);
	while (hWnd != NULL)
	{
		CWnd* pWnd = CWnd::FromHandlePermanent(hWnd);
		if (pWnd != NULL && hMainWnd != hWnd && AfxIsDescendant(hMainWnd, hWnd))
			if (pWnd->IsKindOf(RUNTIME_CLASS(COXSizableMiniDockFrameWnd)))
				UpdateChildrenRec(pWnd);

		hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
	}
}