repos_ecs/其他2015后/SkinTest_demo/SkinWin/SkinWin.cpp

// SkinWin.cpp: implementation of the CSkinWin class.
//
//		A class to enable draw windows-blind style window
//
//  ToDo:
//		how to popup system menu by my program??
//
//	History:
//		2002.11.24
//				CAN WORK NOW.			
//		2002.11.23	intial version
//
//
//		
//	AUthor:
//		szhao00@mails.tsinghua.edu.cn
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "SkinWin.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSkinWin::CSkinWin()
{
	m_bInit = FALSE;
	m_winstate = 0;

	m_barcolor = RGB(207,207,207);
	m_menucolor = RGB(207,207,207);
}

CSkinWin::~CSkinWin()
{

}

CString GetPathName( const char * filename );
CString GetFileName( const char * filename, int ext = 0);
char *next_token( char *buf, char *token, char *stopchars );

COLORREF ReadColor( CString section, CString key, CString file, COLORREF defcolor )
{
	char buf[1000];
	GetPrivateProfileString( section, key, "", buf, 1000, file );
	if ( *buf )
	{
		char token[255];
		char *p = buf;
		int r, g, b;
		p = next_token( p, token, NULL );
		r = atoi(token);
		p = next_token( p, token, NULL );
		g = atoi(token);
		p = next_token( p, token, NULL );
		b = atoi(token);
		return RGB(r, g, b );			
	}
	else
		return defcolor;
}

BOOL CSkinWin::LoadSkin( const char * skinfile )
{
	static const char * ps = "Personality";
	char buf[1000];
	CString path = GetPathName( skinfile );
	
	if ( m_bInit )
	{
		m_bmpDlg.DeleteObject();
		m_bmpTitle.DeleteObject();
		m_bmpLeft.DeleteObject();
		m_bmpRight.DeleteObject();
		m_bmpBottom.DeleteObject();
		m_bmpMaxBtn.DeleteObject();
		m_bmpRestoreBtn.DeleteObject();
		m_bmpMinBtn.DeleteObject();
		m_bmpCloseBtn.DeleteObject();

		//set deafult
		m_barcolor = RGB(207,207,207);
		m_menucolor = RGB(207,207,207);

		m_bInit = FALSE;
	}

	GetPrivateProfileString( ps, "DialogBmp", "", buf, 1000, skinfile );
	if ( *buf != 0 )
		m_bmpDlg.LoadBitmap( path + "/" + GetFileName( buf,1 ));
		

	GetPrivateProfileString( ps, "Top", "", buf, 1000, skinfile );
	if ( *buf == 0 || !m_bmpTitle.LoadBitmap( path + "/" + GetFileName( buf,1 )) )
		return FALSE;
	GetPrivateProfileString( ps, "Left", "", buf, 1000, skinfile );
	if ( *buf == 0 || !m_bmpLeft.LoadBitmap( path + "/" + GetFileName( buf,1 ) )) 
		return FALSE;
	GetPrivateProfileString( ps, "Right", "", buf, 1000, skinfile );
	if ( *buf == 0 || !m_bmpRight.LoadBitmap( path + "/" + GetFileName( buf,1 ) )) 
		return FALSE;
	GetPrivateProfileString( ps, "Bottom", "", buf, 1000, skinfile );
	if ( *buf == 0 || !m_bmpBottom.LoadBitmap( path + "/" + GetFileName( buf,1 ) )) 
		return FALSE;

	m_TitleHeight = m_bmpTitle.Height()/2;
	m_BorderLeftWidth = m_bmpLeft.Width()/2;
	m_BorderRightWidth = m_bmpRight.Width()/2;
	m_BorderBottomHeight = m_bmpBottom.Height()/2;

	m_titleoff1 = GetPrivateProfileInt( ps, "TopTopHeight", 0, skinfile );
	m_titleoff2 = m_bmpTitle.Width() - GetPrivateProfileInt( ps, "TopBotHeight", 0, skinfile );
	if ( m_titleoff2 <= m_titleoff1 )
		m_titleoff2 = m_titleoff1 + 1;
	m_leftoff1 = GetPrivateProfileInt( ps, "LeftTopHeight", 0, skinfile );
	m_leftoff2 = m_bmpLeft.Height() - GetPrivateProfileInt( ps, "LeftBotHeight", 0, skinfile );
	if ( m_leftoff2 <= m_leftoff1 )
		m_leftoff2 = m_leftoff1 + 1;

	m_rightoff1 = GetPrivateProfileInt( ps, "RightTopHeight", 0, skinfile );
	m_rightoff2 = m_bmpRight.Height() - GetPrivateProfileInt( ps, "RightBotHeight", 0, skinfile );
	if ( m_rightoff2 <= m_rightoff1 )
		m_rightoff2 = m_rightoff1 + 1;

	m_bottomoff1 = GetPrivateProfileInt( ps, "BottomTopHeight", 0, skinfile );
	m_bottomoff2 = m_bmpBottom.Width() - GetPrivateProfileInt( ps, "BottomBotHeight", 0, skinfile );
	if ( m_bottomoff2 <= m_bottomoff1 )
		m_bottomoff2 = m_bottomoff1 + 1;

	//load buttons
	int count = GetPrivateProfileInt( ps, "ButtonCount", 0, skinfile );
	int icount = GetPrivateProfileInt( ps, "ButtonImgCount", 3, skinfile );
	for ( int i = 0; i < count; i++ )
	{
		CString sec;
		sec.Format( "Button%d", i );
		GetPrivateProfileString( sec, "ButtonImage", "", buf, 1000, skinfile );
		int action = GetPrivateProfileInt( sec, "Action", 0,  skinfile );
		int x = GetPrivateProfileInt( sec, "XCoord", 0, skinfile );
		int y = GetPrivateProfileInt( sec, "YCoord", 0, skinfile );

		int state = icount;
		if ( action == 0 )
		{
			//close
			if ( !m_bmpCloseBtn.LoadBitmap( path + "/" + GetFileName( buf,1 )) ) 
				return FALSE;
			//state = m_bmpCloseBtn.Width()/m_bmpCloseBtn.Height();
			m_rectCloseBtn = CRect( x-m_bmpCloseBtn.Width()/state, y, x , y + m_bmpCloseBtn.Height() );
		}
		if ( action == 2 )
		{
			//min
			if ( !m_bmpMinBtn.LoadBitmap( path + "/" + GetFileName( buf,1 )) ) 
				return FALSE;
			//state = m_bmpMinBtn.Width()/m_bmpMinBtn.Height();
			m_rectMinBtn = CRect( x-m_bmpMinBtn.Width()/state, y, x, y + m_bmpMinBtn.Height() );
		}
		if ( action == 1 )
		{			
			if ( !m_bmpMaxBtn.GetSafeHandle() )
			{
				//max
				if ( !m_bmpMaxBtn.LoadBitmap( path + "/" + GetFileName( buf,1 )) ) 
					return FALSE;
				//state = m_bmpMaxBtn.Width()/m_bmpMaxBtn.Height();
				m_rectMaxBtn = CRect( x-m_bmpMaxBtn.Width()/state, y, x , y + m_bmpMaxBtn.Height() );
			}
			else
			{
				//restore
				if ( !m_bmpRestoreBtn.LoadBitmap( path + "/" + GetFileName( buf,1 )) ) 
					return FALSE;
				//state = m_bmpRestoreBtn.Width()/m_bmpRestoreBtn.Height();
				m_rectRestoreBtn = CRect( x-m_bmpRestoreBtn.Width()/state, y, x , y + m_bmpRestoreBtn.Height() );
			}
		}
		if ( action == 4 )
		{
		}
	}
	m_textShift = GetPrivateProfileInt( ps, "TextShift", 0, skinfile );
	m_textShiftVer = GetPrivateProfileInt( ps, "TextShiftVert", 0, skinfile );

	char * colours = "Colours";
	m_colTitle1 = ReadColor(colours, "TitleText", skinfile, GetSysColor(COLOR_CAPTIONTEXT) );
	m_colTitle2 = ReadColor(colours, "InactiveTitleText", skinfile, GetSysColor(COLOR_CAPTIONTEXT) );
	
	m_bTrans = GetPrivateProfileInt( ps, "UsesTran", 0, skinfile );
	if ( m_bTrans )
		m_colTrans = ReadColor(colours, "TransColor", skinfile, RGB(255,0,255) );


	m_barcolor = ReadColor(colours, "BarColor", skinfile, RGB(207,207,207) );
	m_menucolor = ReadColor(colours, "MenuColor", skinfile, RGB(207,207,207) );

	m_btnbgcolor = ReadColor(colours, "ButtonFace", skinfile, GetSysColor(COLOR_BTNFACE) );
	m_btntextcolor = ReadColor(colours, "ButtonText", skinfile, GetSysColor(COLOR_BTNTEXT));
	m_btnhovercolor = ReadColor(colours, "ButtonHilight", skinfile, GetSysColor(COLOR_BTNFACE) );
	m_btnfocuscolor = ReadColor(colours, "ButtonFocus", skinfile, GetSysColor(COLOR_BTNFACE) );
	

	m_bInit = TRUE;
	return TRUE;
}

BOOL CSkinWin::DrawTitle(CDC *pDC, int x, int y, int w, int state)
{
	int padding; 
	int ox = x;
	padding = ( w - m_bmpTitle.Width() )/( m_titleoff2 - m_titleoff1 ) + 1 ;
	if ( padding < 0 ) padding = 0;

	RECT sr;
	if ( state == 0 )
		sr = CRect( 0, 0, m_titleoff1, m_TitleHeight );
	else
		sr = CRect( 0, m_TitleHeight, m_titleoff1, m_bmpTitle.Height()  );	
	m_bmpTitle.Draw( pDC, x, y, &sr );
	 
	x += m_titleoff1;
	if ( state == 0 )
		sr = CRect(  m_titleoff1, 0, m_titleoff2, m_TitleHeight );
	else
		sr = CRect(  m_titleoff1, m_TitleHeight, m_titleoff2, m_bmpTitle.Height()  );	

	for ( int i = 0; i <= padding; i++, x += m_titleoff2 - m_titleoff1 )
	{
		int d = ( x + m_titleoff2 - m_titleoff1 - ox - w);
		if ( d > 0 )
			sr.right = sr.right - d;
		m_bmpTitle.Draw( pDC, x, y, &sr );
	}

	x = ox + w - ( m_bmpTitle.Width() - m_titleoff2 ) + 1 ;
	if ( state == 0 )
		sr = CRect(  m_titleoff2, 0, m_bmpTitle.Width()-1, m_TitleHeight);
	else
		sr = CRect(  m_titleoff2, m_TitleHeight, m_bmpTitle.Width()-1, m_bmpTitle.Height()  );	
	m_bmpTitle.Draw( pDC, x, y, &sr );
	return TRUE;
}

BOOL CSkinWin::DrawBottom(CDC *pDC, int x, int y, int w, int state)
{
	int padding; 
	int ox = x;
	padding = ( w - m_bmpBottom.Width() )/( m_bottomoff2 - m_bottomoff1 ) + 1 ;
	if ( padding < 0 ) padding = 0;

	RECT sr;
	if ( state == 0 )
		sr = CRect( 0, 0, m_bottomoff1, m_BorderBottomHeight);
	else
		sr = CRect( 0, m_BorderBottomHeight, m_bottomoff1, m_bmpBottom.Height()  );	
	m_bmpBottom.Draw( pDC, x, y, &sr );
	
	x += m_bottomoff1;
	if ( state == 0 )
		sr = CRect(  m_bottomoff1, 0, m_bottomoff2, m_BorderBottomHeight );
	else
		sr = CRect(  m_bottomoff1, m_BorderBottomHeight, m_bottomoff2, m_bmpBottom.Height() );	

	for ( int i = 0; i <= padding; i++, x += m_bottomoff2 - m_bottomoff1 )
	{
		int d = ( x + m_bottomoff2 - m_bottomoff1 - ox - w);
		if ( d > 0 )
			sr.right = sr.right - d;
		m_bmpBottom.Draw( pDC, x, y, &sr );
	}

	x = ox + w - ( m_bmpBottom.Width() - m_bottomoff2 );
	if ( state == 0 )
		sr = CRect(  m_bottomoff2, 0, m_bmpBottom.Width()-1, m_BorderBottomHeight );
	else
		sr = CRect(  m_bottomoff2, m_BorderBottomHeight, m_bmpBottom.Width()-1, m_bmpBottom.Height()  );	
	m_bmpBottom.Draw( pDC, x, y, &sr );
	return TRUE;
}

BOOL CSkinWin::DrawLeft(CDC *pDC, int x, int y, int h, int state)
{
	int padding; 
	int oy = y;
	padding = ( h - m_bmpLeft.Height() )/( m_leftoff2 - m_leftoff1 ) + 1 ;
	if ( padding < 0 ) padding = 0;

	RECT sr;
	if ( state == 0 )
		sr = CRect( 0, 0, m_BorderLeftWidth, m_leftoff1 );
	else
		sr = CRect( m_BorderLeftWidth, 0, m_bmpLeft.Width(), m_leftoff1  );	
	m_bmpLeft.Draw( pDC, x, y, &sr );
	
	y += m_leftoff1;
	if ( state == 0 )
		sr = CRect(  0, m_leftoff1,  m_BorderLeftWidth, m_leftoff2 );
	else
		sr = CRect(  m_BorderLeftWidth, m_leftoff1, m_bmpLeft.Width(), m_leftoff2 );	

	for ( int i = 0; i <= padding; i++, y += m_leftoff2 - m_leftoff1 )
	{
		int d = ( y + m_leftoff2 - m_leftoff1 - oy - h);
		if ( d > 0 )
			sr.bottom = sr.bottom - d;
		m_bmpLeft.Draw( pDC, x, y, &sr );
	}

	y = oy + h - ( m_bmpLeft.Height() - m_leftoff2 ) ;
	if ( state == 0 )
		sr = CRect(  0, m_leftoff2, m_BorderLeftWidth, m_bmpLeft.Height());
	else
		sr = CRect(  m_BorderLeftWidth, m_leftoff2,  m_bmpLeft.Width(), m_bmpLeft.Height()  );	
	m_bmpLeft.Draw( pDC, x, y, &sr );

	return TRUE;
}

BOOL CSkinWin::DrawRight(CDC *pDC, int x, int y, int h, int state)
{
	int padding; 
	int oy = y;
	padding = ( h - m_bmpRight.Height() )/( m_rightoff2 - m_rightoff1 ) + 1 ;
	if ( padding < 0 ) padding = 0;

	RECT sr;
	if ( state == 0 )
		sr = CRect( 0, 0, m_BorderRightWidth, m_rightoff1 );
	else
		sr = CRect( m_BorderRightWidth, 0, m_bmpRight.Width(), m_rightoff1  );	
	m_bmpRight.Draw( pDC, x, y, &sr );
	
	y += m_rightoff1;
	if ( state == 0 )
		sr = CRect(  0, m_rightoff1,  m_BorderRightWidth, m_rightoff2 );
	else
		sr = CRect(  m_BorderRightWidth, m_rightoff1, m_bmpRight.Width(), m_rightoff2 );	

	for ( int i = 0; i <= padding; i++, y += m_rightoff2 - m_rightoff1 )
	{
		int d = ( y + m_rightoff2 - m_rightoff1 - oy - h);
		if ( d > 0 )
			sr.bottom = sr.bottom - d;
		m_bmpRight.Draw( pDC, x, y, &sr );
	}

	y = oy + h - ( m_bmpRight.Height() - m_rightoff2 ) ;
	if ( state == 0 )
		sr = CRect(  0, m_rightoff2, m_BorderRightWidth, m_bmpRight.Height());
	else
		sr = CRect(  m_BorderRightWidth, m_rightoff2,  m_bmpRight.Width(), m_bmpRight.Height()  );	
	m_bmpRight.Draw( pDC, x, y, &sr );

	return TRUE;

}

BOOL CSkinWin::DrawFrame(CDC *pDC, int x, int y, int w, int h, int state, int title )
{
	if ( title )
		DrawTitle( pDC, x + m_BorderLeftWidth , y, 
   			w - m_BorderRightWidth - m_BorderLeftWidth + 1, state );
	DrawLeft( pDC, x, y, h, state );
	DrawRight( pDC, x + w - m_BorderRightWidth , y, h, state );
	DrawBottom( pDC, x + m_BorderLeftWidth, 
		y + h - m_BorderBottomHeight, w - m_BorderRightWidth - m_BorderLeftWidth, state );
	return TRUE;

}

BOOL CSkinWin::InstallSkin(CWnd *wnd)
{
	if ( !wnd  || !m_bInit ) return FALSE;
	HookWindow( (HWND)NULL);
	int r = HookWindow( wnd );

	DWORD style = GetWindowLong( m_hWnd, GWL_STYLE );
	m_sizable = style & WS_SIZEBOX;
	m_minable = style & WS_MINIMIZEBOX;
	m_maxable = style & WS_MAXIMIZEBOX;
	//m_sysmenu = style & WS_MAXIMIZEBOX;
	style &= ~(WS_MINIMIZEBOX);
	style &= ~WS_MAXIMIZEBOX;
	style &= ~WS_SYSMENU;
	SetWindowLong( m_hWnd, GWL_STYLE, style );

	return r;
}

LRESULT CSkinWin::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
{
	if ( !IsWindow(m_hWnd) )
		return 0;
	if ( !m_bInit  ) 
		return Default();
		
	switch ( msg )
	{
	case WM_SHOWWINDOW:
		//call setwindowpos to force OnNcCalcSize when hWnd is a dialog
		if ( wp )
			SetWindowPos( m_hWnd, 0, 0, 0, 400, 400, SWP_NOSIZE|SWP_NOMOVE|SWP_FRAMECHANGED );
		Default();
		return 0;
		break;
	//case WM_ERASEBKGND:
	case WM_INITMENUPOPUP:
		Default();
		return 0;
	//	return OnEraseBkgnd(CDC::FromHandle((HDC)wp) );
		/*
	case WM_INITMENU:
		//a hack, when popup sysmenu, redraw title bar
		HMENU h;
		h = (HMENU)wp;
		int c;
		h = GetSubMenu(h, 0);
		c = GetMenuItemID( h, 0 );
		if ( c == SC_RESTORE )
		{
			CRect r;
			GetClientRect( m_hWnd, r );
			OnNcPaint(0);
			r.bottom = GetSystemMetrics(SM_CYCAPTION);
			InvalidateRect( m_hWnd, r, TRUE );
			UpdateWindow( m_hWnd );
		}
		Default();
		return 0;
		*/
	case WM_SYSCOMMAND:
		OnSysCommand( wp, lp );
		//Default();
		return 0;
	case WM_SETTEXT:
		return OnSetText( wp, lp );
	case WM_NCPAINT:
		OnNcPaint( (HRGN)wp );
		return 0;
	case WM_NCCALCSIZE:
		OnNcCalcSize( (BOOL)wp, (NCCALCSIZE_PARAMS *)lp );
		return 0;
	case WM_SIZE:
		OnSize( wp, LOWORD(lp), HIWORD(lp) );
		return 0;	
	case WM_NCACTIVATE:
		return OnNcActivate( (BOOL)wp );
	case WM_NCHITTEST:
		return OnNcHitTest(CPoint(LOWORD(lp), HIWORD(lp)));
	case WM_NCLBUTTONUP:
		OnNcLButtonUp(wp, CPoint(LOWORD(lp), HIWORD(lp)));
		return 0;
	case WM_NCLBUTTONDOWN:
		OnNcLButtonDown(wp, CPoint(LOWORD(lp), HIWORD(lp)));
		return 0;
	case WM_NCLBUTTONDBLCLK:
		OnNcLButtonDblClk(wp, CPoint(LOWORD(lp), HIWORD(lp)));
		return 0;
	case WM_NCRBUTTONUP:
		OnNcRButtonUp(wp, CPoint(LOWORD(lp), HIWORD(lp)));
		return 0;
	case WM_NCRBUTTONDOWN:
		OnNcRButtonDown(wp, CPoint(LOWORD(lp), HIWORD(lp)));
		return 0;
	case WM_NCMOUSEMOVE:
		OnNcMouseMove( wp,CPoint(LOWORD(lp), HIWORD(lp)));
		return 0;
	case WM_GETMINMAXINFO:
		OnGetMinMaxInfo( (MINMAXINFO *)lp );
		return 0;
	case WM_WINDOWPOSCHANGING:
		OnWindowPosChanging((WINDOWPOS *)lp);
		return 0;
	case WM_SIZING:
		OnSizing( wp, (LPRECT)lp );
		return 0;
	case WM_ACTIVATE:
		OnActivate( wp, CWnd::FromHandle((HWND)lp), 0 );
		return 0;
	case WM_COMMAND:
		if ( !HandleSysCommand( wp, lp ) )
			Default();
		return 0;
	default:
		return Default();
	}
}

void CSkinWin::OnNcPaint(HRGN rgn1)
{	
	CWnd *pWnd = CWnd::FromHandle(m_hWnd);
	CDC * pDC = pWnd->GetWindowDC();
	CRect wr;
	pWnd->GetWindowRect( wr );

//f ( (DWORD)rgn) 
//pDC->SelectClipRgn( CRgn::FromHandle(rgn) );

	//m_bActive = GetActiveWindow() == m_hWnd;
	int state = 0;
	if ( m_bActive)
		state = 0;
	else state = 1;
	
	pDC->ExcludeClipRect(0, 0, wr.Width(),	m_TitleHeight );
	DrawFrame( pDC, 0, 0, wr.Width(), wr.Height(), state, 0 );	
	pDC->SelectClipRgn( NULL ); 

	CDC memDC, *pNewDC;
	CMyBitmap bmp;
	CBitmap  *obmp;
	memDC.CreateCompatibleDC( pDC );
	bmp.CreateCompatibleBitmap( pDC, wr.Width(), m_TitleHeight );
	obmp = memDC.SelectObject(&bmp);
	pNewDC = &memDC;
	
	DrawTitle( pNewDC, m_BorderLeftWidth , 0, 
   			wr.Width() - m_BorderRightWidth - m_BorderLeftWidth + 1, state );
	DrawLeft( pNewDC, 0, 0, m_bmpLeft.Height(), state );
	DrawRight( pNewDC, wr.Width() - m_BorderRightWidth , 0, m_bmpRight.Height(), state );

	
	CRgn newrgn;
	newrgn.CreateRectRgn( 0, 0, wr.Width(), wr.Height() );
	if ( m_bTrans )
	{
		CRgn rgn;
		rgn.CreateRectRgn( 0, m_TitleHeight, wr.Width(), wr.Height() );
		HRGN hrgn = bmp.CreateRgnFromFile( m_colTrans );
		newrgn.CombineRgn( &rgn, CRgn::FromHandle(hrgn), RGN_XOR  );
		pDC->SelectClipRgn( &newrgn ); 
	}
	else
		SetWindowRgn( m_hWnd, newrgn, FALSE );

	if ( m_downHitTest == HTCLOSE )
		DrawButton( pNewDC, 0, 1 );
	else if ( m_moveHitTest == HTCLOSE)
		DrawButton( pNewDC, 0, 2 );
	else
		DrawButton( pNewDC, 0, 0 );
	
	if ( m_downHitTest == HTMINBUTTON )
		DrawButton( pNewDC, 2, 1 );
	else if ( m_moveHitTest == HTMINBUTTON)
		DrawButton( pNewDC, 2, 2 );
	else
		DrawButton( pNewDC, 2, 0 );	

	if ( m_downHitTest == HTMAXBUTTON )
		DrawButton( pNewDC, 1, 1 );
	else if ( m_moveHitTest == HTMAXBUTTON)
		DrawButton( pNewDC, 1, 2 );
	else
		DrawButton( pNewDC, 1, 0 );		

	int cx = GetSystemMetrics(SM_CXSMICON);
	int cy = GetSystemMetrics(SM_CYSMICON);
	HICON hi = (HICON)SendMessage( m_hWnd, WM_GETICON, ICON_SMALL, 0);
	if ( !hi )
	{
#ifdef IDR_MAINFRAME
		hi = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
#endif
	}
	//draw icon
	::DrawIconEx( pNewDC->GetSafeHdc(), m_BorderLeftWidth, 5, (HICON)
		CopyImage( hi, IMAGE_ICON, 
		cx, cy, 0), cx, cy, 0, 0, DI_NORMAL);
	//draw text
	if ( m_title.IsEmpty() )
		pWnd->GetWindowText(m_title);

	if (m_bActive)
		pNewDC->SetTextColor( m_colTitle1 );
	else
		pNewDC->SetTextColor( m_colTitle2 );

	CFont font, *ofont;
	font.CreatePointFont( GetSystemMetrics(SM_CYSMCAPTION), "System" );
	ofont = pNewDC->SelectObject(&font);

	pNewDC->SetBkMode(TRANSPARENT);
	pNewDC->DrawText( m_title, CRect( m_textShift, m_textShiftVer, wr.Width() - m_bmpTitle.Width() + m_titleoff2, 
		m_TitleHeight ), DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_WORD_ELLIPSIS  );

	pNewDC->SelectObject(&font);

	pDC->BitBlt( 0, 0, wr.Width(),
		m_TitleHeight, pNewDC, 0, 0, SRCCOPY );
	memDC.SelectObject(obmp);

	pDC->SelectClipRgn(NULL);
}

void CSkinWin::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS *lpncsp)
{
	if ( bCalcValidRects )
	{
		lpncsp->rgrc[0].left = lpncsp->rgrc[0].left + m_BorderLeftWidth;
		lpncsp->rgrc[0].right = lpncsp->rgrc[0].right - m_BorderRightWidth;
		lpncsp->rgrc[0].top = lpncsp->rgrc[0].top + m_TitleHeight;
		lpncsp->rgrc[0].bottom = lpncsp->rgrc[0].bottom - m_BorderBottomHeight;
		lpncsp->rgrc[1] = lpncsp->rgrc[0];

	}
	else
	{
		Default();
	}

}

void CSkinWin::OnSizing(UINT nSide, LPRECT lpRect)
{
		//Default();
	CWnd *pWnd = CWnd::FromHandle(m_hWnd);
	CRect wr(lpRect);

	/*
	if ( m_bTrans )
		SetWindowRgn( m_hWnd, GetRegion(wr.Width(), wr.Height() ), TRUE );
	else
		SetWindowRgn( m_hWnd, NULL, TRUE );
	*/
}


void CSkinWin::OnSize(UINT nType, int cx, int cy)
{
	//Default();
	CWnd *pWnd = CWnd::FromHandle(m_hWnd);
	CRect wr;	
	Default();
	pWnd->GetWindowRect(wr);
	pWnd->Invalidate();
	OnNcPaint(0);
	
	if ( m_bTrans )
		SetWindowRgn( m_hWnd, GetRegion(wr.Width(), wr.Height() ), TRUE );
	else
		SetWindowRgn( m_hWnd, NULL, TRUE );


}

HRGN CSkinWin::GetRegion(int w, int h)
{
	CWnd *pWnd = CWnd::FromHandle(m_hWnd);
	CRect wr;
	pWnd->GetWindowRect(wr);
	
	CRgn rgn;
	if ( m_bTrans )
	{
		CDC *pDC = pWnd->GetDC();
		CDC memDC;
		CMyBitmap bmp;
		CBitmap *obmp;
		memDC.CreateCompatibleDC(pDC);
		bmp.CreateCompatibleBitmap( pDC, w, m_TitleHeight );
		obmp = memDC.SelectObject(&bmp);
		/*
		memDC.FillSolidRect( 0, 0, w, h, 0 );
		DrawFrame( &memDC, 0, 0, w, h, 0 );
		*/
		DrawTitle( &memDC, m_BorderLeftWidth , 0, 
   				wr.Width() - m_BorderRightWidth - m_BorderLeftWidth + 1, 0 );
		DrawLeft( &memDC, 0, 0, m_bmpLeft.Height(), 0 );
		DrawRight( &memDC, wr.Width() - m_BorderRightWidth , 0, m_bmpRight.Height(), 0 );
		
		memDC.SelectObject(obmp);
		pWnd->ReleaseDC( pDC );

		rgn.CreateRectRgn( 0, m_TitleHeight, wr.Width(), wr.Height() );
		HRGN hrgn = bmp.CreateRgnFromFile( m_colTrans );
		CRgn newrgn;
		newrgn.CreateRectRgn( 0, m_TitleHeight, wr.Width(), wr.Height() );
		newrgn.CombineRgn( &rgn, CRgn::FromHandle(hrgn), RGN_XOR  );
		
		return (HRGN)newrgn.Detach();
	}
	else
		rgn.CreateRectRgn( 0, 0, wr.Width(), wr.Height() );
		
	
	return (HRGN)rgn.Detach();
}


BOOL CSkinWin::OnNcActivate(BOOL bActive)
{
	m_bActive = bActive;
	OnNcPaint(0);
	if ( !bActive )
	{
		return 1;
	}
	else
		return 0;
}



UINT CSkinWin::OnNcHitTest(CPoint point)
{
	CWnd *pWnd = CWnd::FromHandle(m_hWnd);
	CRect wr;
	pWnd->GetWindowRect(wr);
	
	point.x -= wr.left;
	point.y -= wr.top;
	if ( PtInRect( GetButtonRect(0), point ) )
		return HTCLOSE;
	if ( PtInRect( GetButtonRect(2), point ) && m_minable )
		return HTMINBUTTON;
	if ( PtInRect( GetButtonRect(1), point ) && m_maxable )
		return HTMAXBUTTON;

	CRect r;
	int cx = GetSystemMetrics(SM_CXSMICON);
	int cy = GetSystemMetrics(SM_CYSMICON);
	if ( PtInRect( CRect(m_BorderLeftWidth, 5, m_BorderLeftWidth + cx, cy + 5), point ) )
		return HTSYSMENU;

	r = CRect( 0, 0, m_BorderLeftWidth, m_TitleHeight );
	if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		return HTTOPLEFT;
	r = CRect( wr.Width() - m_BorderLeftWidth, 0,  wr.Width(), m_TitleHeight  );
	if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		return HTTOPRIGHT;
	r = CRect( 0, wr.Height() - m_BorderBottomHeight, m_BorderLeftWidth, wr.Height() );
	if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		return HTBOTTOMLEFT;
	r = CRect( wr.Width()-m_BorderRightWidth, wr.Height() - m_BorderBottomHeight,  wr.Width(), wr.Height() );
	if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		return HTBOTTOMRIGHT;
	r = CRect( 0, m_TitleHeight,  m_BorderLeftWidth, wr.Height() - m_BorderBottomHeight  );
	if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		return HTLEFT;
	r = CRect( wr.Width()-m_BorderRightWidth, m_TitleHeight,  wr.Width(), wr.Height() - m_BorderBottomHeight  );
	if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		return HTRIGHT;
	r = CRect( m_BorderLeftWidth, wr.Height() - m_BorderBottomHeight,  wr.Width()-m_BorderRightWidth, wr.Height() );
	if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		return HTBOTTOM;
	r = CRect( m_BorderLeftWidth, 0,  wr.Width()-m_BorderRightWidth, m_BorderBottomHeight );
	if ( PtInRect( r, point ) && m_sizable && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		return HTTOP;
	//set to boder 5
	r = CRect( m_BorderLeftWidth, 5 , wr.Width()-m_BorderRightWidth, m_TitleHeight );
	if ( PtInRect( r, point ) )
		return HTCAPTION;



	return HTCLIENT;
}

void CSkinWin::OnNcLButtonDblClk(UINT nHitTest, CPoint point)
{
	if ( nHitTest == HTCAPTION && m_sizable )
	{
		if ( m_winstate == 1 )
			Restore();
		else
			Maximize(); //ShowWindow(m_hWnd, SW_MAXIMIZE);
		m_downHitTest = 0;
		m_moveHitTest = 0;
		OnNcPaint(0);
	}
}

void CSkinWin::OnNcLButtonDown(UINT nHitTest, CPoint point)
{
	m_downHitTest = nHitTest;
	m_moveHitTest = m_downHitTest;

	OnNcPaint(0);	
	if ( nHitTest >= HTLEFT && nHitTest <= HTBOTTOMRIGHT || 
		nHitTest == HTCAPTION && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		Default();
	else if ( nHitTest == HTSYSMENU )
	{
		PopupSysMenu(point);
		/*
		CWnd * pWnd = CWnd::FromHandle(m_hWnd);
		//a tricky hack
		pWnd->ModifyStyle( 0, WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX );			
		Default();
		pWnd->ModifyStyle( WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, 0 );			
		*/
	}
}

void CSkinWin::OnNcLButtonUp(UINT nHitTest, CPoint point)
{
	if ( nHitTest == HTCLOSE )
	{
		SendMessage(m_hWnd, WM_CLOSE, 0, 0);
		return;
	}
	else if ( nHitTest == HTMINBUTTON )
		Minimize();
	else if ( nHitTest == HTMAXBUTTON )
	{
		if ( m_winstate == 1 ) // IsZoomed(m_hWnd) )
			Restore(); //ShowWindow(m_hWnd, SW_RESTORE);
		else
			Maximize(); //ShowWindow(m_hWnd, SW_MAXIMIZE);
	}
	else
		return;
	m_downHitTest = 0;
	m_moveHitTest = 0;
	OnNcPaint(0);

}

void CSkinWin::OnNcMouseMove(UINT nHitTest, CPoint point)
{
	if ( nHitTest >= HTLEFT && nHitTest <= HTBOTTOMRIGHT || 
		 nHitTest == HTCAPTION && m_winstate != 1 )  //!IsZoomed(m_hWnd) )
		Default();
	
	m_moveHitTest = nHitTest;
	m_downHitTest = 0;
	if ( m_oldHitTest != nHitTest )
	{
		/*
		CRect r;
		r = GetButtonRect(0);
		r.UnionRect( r, GetButtonRect(1) );
		r.UnionRect( r, GetButtonRect(2) );
		CRgn rgn;
		rgn.CreateRectRgn( r.left, r.top, r.right, r.bottom );
		*/
		OnNcPaint(0);
		m_oldHitTest = nHitTest;
	}
	
}

void CSkinWin::OnNcRButtonDown(UINT nHitTest, CPoint point)
{
	if ( nHitTest == HTCAPTION )
	{
		/*
		CWnd * pWnd = CWnd::FromHandle(m_hWnd);
		pWnd->ModifyStyle( 0, WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX );			
		Default();
		pWnd->ModifyStyle( WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, 0 );			
		*/
		PopupSysMenu(point);
	}
}

void CSkinWin::OnNcRButtonUp(UINT nHitTest, CPoint point)
{


}

CRect CSkinWin::GetButtonRect(int i)
{
	CWnd *pWnd = CWnd::FromHandle(m_hWnd);
	CRect wr;
	pWnd->GetWindowRect(wr);

	CRect r;
	if ( i == 0 && m_bmpCloseBtn.GetSafeHandle() )
	{
		//close
		r = m_rectCloseBtn;
		r.left = wr.Width() - m_rectCloseBtn.right;
		r.right = wr.Width() - m_rectCloseBtn.left;
	}
	if ( i == 1 && m_bmpMaxBtn.GetSafeHandle())
	{
		//max
		
		if ( m_winstate != 1 || !m_bmpRestoreBtn.GetSafeHandle() )
		{
			r = m_rectMaxBtn;
			r.left = wr.Width() - m_rectMaxBtn.right;
			r.right = wr.Width() - m_rectMaxBtn.left;
		}
		else
		{
			r = m_rectRestoreBtn;
			r.left = wr.Width() - m_rectRestoreBtn.right;
			r.right = wr.Width() - m_rectRestoreBtn.left;
		}
			
	}
	if ( i == 2 && m_bmpMinBtn.GetSafeHandle())
	{
		//min
		r = m_rectMinBtn;
		r.left = wr.Width() - m_rectMinBtn.right;
		r.right = wr.Width() - m_rectMinBtn.left;
	}

	return r;

}

BOOL CSkinWin::DrawButton( CDC * pDC, int i, int state)
{
	if ( i == 0 )
	{
		if ( m_bmpCloseBtn.GetSafeHandle() )
		{
			CRect r = GetButtonRect(0);
			m_bmpCloseBtn.Draw( pDC, r.left, r.top, 
				CRect( state * r.Width(), 0, (state + 1 ) * r.Width(), m_bmpCloseBtn.Height() ), m_colTrans, m_bTrans );
		}
	}
	if ( i == 1 )
	{
		CRect r = GetButtonRect(1);
		if ( m_maxable && m_bmpMaxBtn.GetSafeHandle() )
			if ( m_winstate == 1&& m_bmpRestoreBtn.GetSafeHandle() )
				m_bmpRestoreBtn.Draw( pDC, r.left, r.top, 
					CRect( state * r.Width(), 0, (state + 1 ) * r.Width(), m_bmpCloseBtn.Height() ), m_colTrans, m_bTrans );
			else
				m_bmpMaxBtn.Draw( pDC, r.left, r.top, 
					CRect( state * r.Width(), 0, (state + 1 ) * r.Width(), m_bmpCloseBtn.Height() ) , m_colTrans, m_bTrans);
	}
	if ( i == 2 )
	{
		if ( m_minable && m_bmpMinBtn.GetSafeHandle() )
		{
			CRect r = GetButtonRect(2);
			m_bmpMinBtn.Draw( pDC, r.left, r.top, 
				CRect( state * r.Width(), 0, (state + 1 ) * r.Width(), m_bmpCloseBtn.Height() ) , m_colTrans, m_bTrans);

		}
	}
	return TRUE;
	
}

void CSkinWin::OnGetMinMaxInfo(MINMAXINFO *lpMMI)
{
	lpMMI->ptMinTrackSize = CPoint( m_bmpTitle.Width() + m_bmpLeft.Width() +
		m_bmpRight.Width(),  m_bmpLeft.Height() + 20 );
}


void CSkinWin::OnWindowPosChanging(WINDOWPOS *lpwndpos)
{
}


BOOL CSkinWin::OnEraseBkgnd(CDC *pDC)
{
	if ( m_bmpDlg.GetSafeHandle() )
	{
		CRect r;
		GetClientRect( m_hWnd, r);
		for ( int i = 0; i < r.Width()/m_bmpDlg.Width() + 1; i++ )
			for ( int j = 0; j < r.Height()/m_bmpDlg.Height() + 1; j++ )
			{
				m_bmpDlg.Draw( pDC, CRect( i *  m_bmpDlg.Width(), j * m_bmpDlg.Height(),
					i *  m_bmpDlg.Width() + m_bmpDlg.Width(), j * m_bmpDlg.Height() + m_bmpDlg.Height() ) );
			}

		return TRUE;
	}
	else
		return FALSE;
}

CRect CSkinWin::GetMaximizeRect()
{
	CRect r;
	SystemParametersInfo(SPI_GETWORKAREA, 0, r, 0);
	
	return r;
}

BOOL CSkinWin::Maximize()
{
	CRect r = GetMaximizeRect();
	GetWindowRect( m_hWnd, m_rectRestoreWin );
	m_winstate = 1;
	::MoveWindow( m_hWnd, r.left, r.top, r.Width(), r.Height(), TRUE  );
	UpdateWindow( m_hWnd );
	return TRUE;
}

BOOL CSkinWin::Minimize()
{
	m_oldwinstate = m_winstate;
	m_winstate = 2;
	ShowWindow(m_hWnd, SW_MINIMIZE);
	return TRUE;
}

BOOL CSkinWin::Restore()
{
	if ( m_winstate == 1 )
	{
		::MoveWindow( m_hWnd, m_rectRestoreWin.left, m_rectRestoreWin.top,
			m_rectRestoreWin.Width(), m_rectRestoreWin.Height(), TRUE  );
		m_winstate = 0;
		UpdateWindow( m_hWnd );
	}
	return TRUE;
}

//void OnActivate(UINT nState,CWnd* pWndOther, BOOL bMinimized );

void CSkinWin::OnActivate(UINT nState, CWnd *pWndOther, BOOL bMinimized)
{
	//Default();
	m_bActive = ( nState == WA_ACTIVE || nState == WA_CLICKACTIVE );
	OnNcActivate(m_bActive);
}

LRESULT CSkinWin::OnSetText(WPARAM wp, LPARAM lp)
{
	char * str = ( char *)lp;

	Default();
	m_title = str;
	OnNcPaint(0);
	return 0;
}



void CSkinWin::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ( nID == SC_MAXIMIZE )
		Maximize();
	else if ( nID == SC_RESTORE && m_winstate == 1 )
		Restore();
	else if ( nID == SC_RESTORE && m_winstate == 2 )
	{
		ShowWindow( m_hWnd, SW_RESTORE );
		m_winstate = m_oldwinstate;
		OnNcPaint(0);
	}
	else 
		Default();
}

BOOL CSkinWin::PopupSysMenu(CPoint point)
{
	CWnd * pWnd = CWnd::FromHandle(m_hWnd);
	CMenu SysMenu;
	SysMenu.Attach( GetSystemMenu(m_hWnd, FALSE) );




/*
  when gray menuitem, a strange line appears!!
  
	if ( m_winstate == 0 )
	{
		SysMenu.EnableMenuItem( SC_MINIMIZE, MF_BYCOMMAND|MF_ENABLED );
		SysMenu.EnableMenuItem( SC_MAXIMIZE, MF_BYCOMMAND|MF_ENABLED );
		SysMenu.EnableMenuItem( SC_RESTORE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED );
	}	
	else if ( m_winstate == 1 )
	{
		SysMenu.EnableMenuItem( SC_MAXIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED );
		SysMenu.EnableMenuItem( SC_RESTORE, MF_BYCOMMAND|MF_ENABLED );
	}
	else if ( m_winstate == 2 )
	{
		SysMenu.EnableMenuItem( SC_MINIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED );
		SysMenu.EnableMenuItem( SC_RESTORE, MF_BYCOMMAND|MF_ENABLED );
	}
*/
	
	SysMenu.TrackPopupMenu( 0, point.x, point.y, pWnd  );		
	SysMenu.Detach();
	return TRUE;
}

BOOL CSkinWin::HandleSysCommand(WPARAM wp, LPARAM lp)
{
	if ( lp == 0 )
	{
		int i = 0;
		CMenu SysMenu;
		SysMenu.Attach( GetSystemMenu(m_hWnd, FALSE) );
		int count = SysMenu.GetMenuItemCount();
		for(  i = 0; i < count ; i++ )
			if ( SysMenu.GetMenuItemID(i) == wp )
				break;
		SysMenu.Detach();
		if ( i >= count )
			return FALSE;
		if ( wp == SC_MAXIMIZE )
			Maximize();
		else if ( wp == SC_MINIMIZE )
			Minimize();
		else if ( wp == SC_RESTORE && m_winstate == 1 )
			Restore();
		else if ( wp == SC_RESTORE && m_winstate == 2 )
		{
			ShowWindow( m_hWnd, SW_RESTORE );
			m_winstate = m_oldwinstate;
			OnNcPaint(0);
		}
		else 
			SendMessage( m_hWnd, WM_SYSCOMMAND, wp, lp );
		return TRUE;
	}

	return FALSE;
}