coolmenu.cpp

p2p软件

//
// CoolMenu.cpp
//
// Copyright (c) Shareaza Development Team, 2002-2004.
// This file is part of SHAREAZA (www.shareaza.com)
//
// Shareaza is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Shareaza is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Shareaza; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//

#include "StdAfx.h"
#include "Shareaza.h"
#include "CoolInterface.h"
#include "CoolMenu.h"
#include "Skin.h"

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

#define CM_DISABLEDBLEND	ILD_BLEND25
#define CM_ICONWIDTH		16
#define CM_ICONHEIGHT		16

CCoolMenu CoolMenu;


//////////////////////////////////////////////////////////////////////
// CCoolMenu construction

CCoolMenu::CCoolMenu()
{
	m_nCheckIcon	= 0;
	m_bEnable		= TRUE;
	m_bUnhook		= FALSE;
}

CCoolMenu::~CCoolMenu()
{
	SetWatermark( NULL );
	if ( m_bUnhook ) EnableHook( FALSE );
}

//////////////////////////////////////////////////////////////////////
// CCoolMenu modern version check

BOOL CCoolMenu::IsModernVersion()
{
	OSVERSIONINFO pVersion;
	pVersion.dwOSVersionInfoSize = sizeof(pVersion);
	GetVersionEx( &pVersion );
	
	return theApp.GetProfileInt( _T(""), _T("CoolMenuEnable"), TRUE ) &&
		( pVersion.dwMajorVersion >= 5 ||
		( pVersion.dwMajorVersion == 4 && pVersion.dwMinorVersion >= 10 ) );
}

//////////////////////////////////////////////////////////////////////
// CCoolMenu add menu

BOOL CCoolMenu::AddMenu(CMenu* pMenu, BOOL bChild)
{
	if ( ! m_bEnable ) return FALSE;
	
	for ( int i = 0 ; i < (int)pMenu->GetMenuItemCount() ; i++ )
	{
		TCHAR szBuffer[128];
		MENUITEMINFO mii;
		
		ZeroMemory( &mii, sizeof(mii) );
		mii.cbSize		= sizeof(mii);
		mii.fMask		= MIIM_DATA|MIIM_ID|MIIM_TYPE|MIIM_SUBMENU;
		mii.dwTypeData	= szBuffer;
		mii.cch			= 128;
		
		GetMenuItemInfo( pMenu->GetSafeHmenu(), i, MF_BYPOSITION, &mii );
		
		if ( mii.fType & (MF_OWNERDRAW|MF_SEPARATOR) )
		{
			mii.fType |= MF_OWNERDRAW;
			if ( mii.fType & MF_SEPARATOR ) mii.dwItemData = 0;
			SetMenuItemInfo( pMenu->GetSafeHmenu(), i, MF_BYPOSITION, &mii );
			continue;
		}
		
		mii.fType		|= MF_OWNERDRAW;
		mii.dwItemData	= ( (DWORD)pMenu->GetSafeHmenu() << 16 ) | ( mii.wID & 0xFFFF );
		
		CString strText = szBuffer;
		m_pStrings.SetAt( mii.dwItemData, strText );
		
		if ( bChild ) SetMenuItemInfo( pMenu->GetSafeHmenu(), i, MF_BYPOSITION, &mii );
		
		if ( mii.hSubMenu != NULL ) AddMenu( pMenu->GetSubMenu( i ), TRUE );
	}
	
	return TRUE;
}

//////////////////////////////////////////////////////////////////////
// CCoolMenu watermark

void CCoolMenu::SetWatermark(HBITMAP hBitmap)
{
	if ( m_bmWatermark.m_hObject != NULL )
	{
		m_dcWatermark.SelectObject( CBitmap::FromHandle( m_hOldMark ) );
		m_bmWatermark.DeleteObject();
		m_dcWatermark.DeleteDC();
	}
	
	if ( hBitmap != NULL )
	{
		CDC dc;		  
		dc.Attach( GetDC( 0 ) );
		m_dcWatermark.CreateCompatibleDC( &dc );
		ReleaseDC( 0, dc.Detach() );
		
		m_bmWatermark.Attach( hBitmap );
		m_hOldMark = (HBITMAP)m_dcWatermark.SelectObject( &m_bmWatermark )->GetSafeHandle();
		
		BITMAP pInfo;
		m_bmWatermark.GetBitmap( &pInfo );
		m_czWatermark.cx = pInfo.bmWidth;
		m_czWatermark.cy = pInfo.bmHeight;
	}
}

//////////////////////////////////////////////////////////////////////
// CCoolMenu measure item

void CCoolMenu::OnMeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
{
	if ( lpMeasureItemStruct->itemID == ID_SEPARATOR )
	{
		lpMeasureItemStruct->itemWidth	= 16;
		lpMeasureItemStruct->itemHeight	= 2;
	}
	else
	{
		CString strText;
		CDC dc;
		
		m_pStrings.Lookup( lpMeasureItemStruct->itemData, strText );
		
		dc.Attach( GetDC( 0 ) );
		
		CFont* pOld = (CFont*)dc.SelectObject( &CoolInterface.m_fntNormal );
		CSize sz = dc.GetTextExtent( strText );
		dc.SelectObject( pOld );
		
		ReleaseDC( 0, dc.Detach() );
		
		lpMeasureItemStruct->itemWidth	= sz.cx + 32;
		lpMeasureItemStruct->itemHeight	= 23;
	}
	
	if ( m_hMsgHook == NULL ) lpMeasureItemStruct->itemHeight ++;
}

//////////////////////////////////////////////////////////////////////
// CCoolMenu draw item

void CCoolMenu::OnDrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct) 
{
	CRect rcItem, rcText;
	CString strText;
	int nIcon = -1;
	CDC dc;
	
	BOOL	bSelected	= lpDrawItemStruct->itemState & ODS_SELECTED;
	BOOL	bChecked	= lpDrawItemStruct->itemState & ODS_CHECKED;
	BOOL	bDisabled	= lpDrawItemStruct->itemState & ODS_GRAYED;
	BOOL	bKeyboard	= FALSE;
	BOOL	bEdge		= TRUE;
	
	dc.Attach( lpDrawItemStruct->hDC );
	
	if ( CWnd* pWnd = dc.GetWindow() )
	{
		CRect rcScreen( &lpDrawItemStruct->rcItem );
		CPoint ptCursor;
		
		GetCursorPos( &ptCursor );
		pWnd->ClientToScreen( &rcScreen );
		
		bKeyboard = ! rcScreen.PtInRect( ptCursor );
	}
	
	rcItem.CopyRect( &lpDrawItemStruct->rcItem );
	rcItem.OffsetRect( -rcItem.left, -rcItem.top );
	if ( m_hMsgHook != NULL ) rcItem.bottom += ( bEdge = m_bPrinted );
	
	rcText.CopyRect( &rcItem );
	rcText.left += 32;
	rcText.right -= 2;
	
	CDC* pDC = CoolInterface.GetBuffer( dc, rcItem.Size() );
	
	if ( m_bmWatermark.m_hObject != NULL )
	{
		DrawWatermark( pDC, &rcItem, lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top );
	}
	else
	{
		pDC->FillSolidRect( rcItem.left, rcItem.top, 24, rcItem.Height(), CoolInterface.m_crMargin );
		pDC->FillSolidRect( rcItem.left + 24, rcItem.top, rcItem.Width() - 24, rcItem.Height(), CoolInterface.m_crBackNormal );
	}
	
	if ( m_pStrings.Lookup( lpDrawItemStruct->itemData, strText ) == FALSE )
	{
		int nMiddle = rcText.top + 1;
		
		pDC->FillSolidRect( rcText.left, nMiddle, rcText.Width() + 2, 1, CoolInterface.m_crDisabled );
		
		dc.BitBlt( lpDrawItemStruct->rcItem.left, lpDrawItemStruct->rcItem.top,
			rcItem.Width(), rcItem.Height(), pDC, 0, 0, SRCCOPY );
		dc.Detach();
		
		return;
	}
	
	if ( bSelected )
	{
		if ( ! bDisabled )
		{
			pDC->Draw3dRect( rcItem.left + 1, rcItem.top + 1,
				rcItem.Width() - 2, rcItem.Height() - 1 - bEdge,
				CoolInterface.m_crBorder, CoolInterface.m_crBorder );
			pDC->FillSolidRect( rcItem.left + 2, rcItem.top + 2,
				rcItem.Width() - 4, rcItem.Height() - 3 - bEdge,
				CoolInterface.m_crBackSel );
			
			pDC->SetBkColor( CoolInterface.m_crBackSel );
		}
		else if ( bKeyboard )
		{
			pDC->Draw3dRect( rcItem.left + 1, rcItem.top + 1,
				rcItem.Width() - 2, rcItem.Height() - 1 - bEdge,
				CoolInterface.m_crBorder, CoolInterface.m_crBorder );
			pDC->FillSolidRect( rcItem.left + 2, rcItem.top + 2,
				rcItem.Width() - 4, rcItem.Height() - 3 - bEdge,
				CoolInterface.m_crBackNormal );
			
			pDC->SetBkColor( CoolInterface.m_crBackNormal );
		}
	}
	else
	{
		pDC->SetBkColor( CoolInterface.m_crBackNormal );
	}
	
	if ( bChecked )
	{
		pDC->Draw3dRect( rcItem.left + 2, rcItem.top + 2, 20, rcItem.Height() - 3 - bEdge,
			CoolInterface.m_crBorder, CoolInterface.m_crBorder );
		pDC->FillSolidRect( rcItem.left + 3, rcItem.top + 3, 18, rcItem.Height() - 5 - bEdge,