ctrllibraryheaderpanel.cpp

p2p软件

//
// CtrlLibraryHeaderPanel.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 "Settings.h"
#include "Library.h"
#include "AlbumFolder.h"
#include "Schema.h"
#include "XML.h"

#include "ShellIcons.h"
#include "CoolInterface.h"
#include "Skin.h"

#include "CtrlLibraryFrame.h"
#include "CtrlLibraryTree.h"
#include "CtrlLibraryHeaderPanel.h"

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

BEGIN_MESSAGE_MAP(CLibraryHeaderPanel, CWnd)
	//{{AFX_MSG_MAP(CLibraryHeaderPanel)
	ON_WM_SIZE()
	ON_WM_PAINT()
	ON_WM_SETCURSOR()
	ON_WM_LBUTTONUP()
	ON_WM_CREATE()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CLibraryHeaderPanel construction

CLibraryHeaderPanel::CLibraryHeaderPanel()
{
}

CLibraryHeaderPanel::~CLibraryHeaderPanel()
{
}

/////////////////////////////////////////////////////////////////////////////
// CLibraryHeaderPanel operations

BOOL CLibraryHeaderPanel::Create(CWnd* pParentWnd)
{
	CRect rect( 0, 0, 0, 0 );
	return CWnd::Create( NULL, _T("CLibraryHeaderPanel"), WS_CHILD, rect,
		pParentWnd, ID_LIBRARY_HEADER, NULL );
}

int CLibraryHeaderPanel::Update()
{
	CAlbumFolder* pFolder = GetSelectedAlbum();
	if ( pFolder == NULL || pFolder->m_pSchema == NULL ) return 0;
	
	m_nIcon32	= pFolder->m_pSchema->m_nIcon32;
	m_nIcon48	= pFolder->m_pSchema->m_nIcon48;
	
	m_sTitle	= pFolder->m_pSchema->m_sHeaderTitle;
	m_sSubtitle	= pFolder->m_pSchema->m_sHeaderSubtitle;
	
	if ( pFolder->m_pParent == NULL )
	{
		QWORD nTotalVolume;
		DWORD nTotalFiles;
		CString str;

		LibraryMaps.GetStatistics( &nTotalFiles, &nTotalVolume );
		str.Format( _T("%lu"), nTotalFiles );
		Replace( m_sSubtitle, _T("{totalFiles}"), str );
		str = Settings.SmartVolume( nTotalVolume, TRUE );
		Replace( m_sSubtitle, _T("{totalVolume}"), str );
	}

	pFolder->m_pSchema->ResolveTokens( m_sTitle, pFolder->m_pXML );
	pFolder->m_pSchema->ResolveTokens( m_sSubtitle, pFolder->m_pXML );

	if ( m_sTitle.IsEmpty() ) m_sTitle = pFolder->m_sName;

	m_pMetadata.Setup( pFolder->m_pSchema );
	m_pMetadata.Remove( pFolder->m_pSchema->GetFirstMemberName() );

	m_pMetadata.Combine( pFolder->m_pXML );
	
	m_pMetadata.CreateLinks();
	m_pMetadata.Clean( 54 );
	
	if ( m_pMetadata.GetCount() )
	{
		CClientDC dc( this );
		CFont* pFont = (CFont*)dc.SelectObject( &CoolInterface.m_fntNormal );
		m_nKeyWidth = m_nMetaWidth = 0;
		m_pMetadata.ComputeWidth( &dc, m_nKeyWidth, m_nMetaWidth );
		if ( m_nKeyWidth ) m_nKeyWidth += 8;
		m_nMetaWidth += m_nKeyWidth;
		dc.SelectObject( pFont );
	}
	
	Invalidate();

	int nHeight = m_pMetadata.GetCount() * 12 + 8;

	if ( pFolder->m_pParent != NULL )
	{
		nHeight = max( 64, nHeight );
	}
	else
	{
		nHeight = max( 56, nHeight );
	}

	return min( 80, nHeight );
}

void CLibraryHeaderPanel::OnSkinChange()
{
	if ( m_bmWatermark.m_hObject != NULL ) m_bmWatermark.DeleteObject();
	
	if ( HBITMAP hMark = Skin.GetWatermark( _T("CLibraryHeaderPanel") ) )
	{
		m_bmWatermark.Attach( hMark );
	}
	else if ( Skin.m_crBannerBack == RGB( 122, 161, 230 ) )
	{
		m_bmWatermark.LoadBitmap( IDB_BANNER_MARK );
	}
}

CAlbumFolder* CLibraryHeaderPanel::GetSelectedAlbum() const
{
	CLibraryFrame* pFrame = (CLibraryFrame*)GetOwner();
	ASSERT_KINDOF(CLibraryFrame, pFrame );

	CLibraryTreeItem* pItem	= pFrame->m_pFolderSelection;
	if ( pItem == NULL ) return Library.GetAlbumRoot();
	if ( pItem->m_pSelNext != NULL ) return NULL;
	
	return pItem->m_pVirtual;
}

/////////////////////////////////////////////////////////////////////////////
// CLibraryHeaderPanel message handlers

int CLibraryHeaderPanel::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if ( CWnd::OnCreate( lpCreateStruct ) == -1 ) return -1;
	
	m_szBuffer = CSize( 0, 0 );
	OnSkinChange();
	
	return 0;
}

void CLibraryHeaderPanel::OnDestroy() 
{
	CWnd::OnDestroy();
	
	if ( m_bmBuffer.m_hObject != NULL )
	{
		m_dcBuffer.SelectObject( m_hBuffer );
		m_dcBuffer.DeleteDC();
		m_bmBuffer.DeleteObject();
	}
}

void CLibraryHeaderPanel::OnSize(UINT nType, int cx, int cy) 
{
	CWnd::OnSize( nType, cx, cy );
	Invalidate();
}

void CLibraryHeaderPanel::OnPaint() 
{
	CPaintDC dc( this );
	CRect rcClient;
	
	GetClientRect( &rcClient );
	if ( rcClient.IsRectEmpty() ) return;
	
	if ( rcClient.Width() > m_szBuffer.cx || rcClient.Height() > m_szBuffer.cy )
	{
		if ( m_bmBuffer.m_hObject != NULL )
		{
			m_dcBuffer.SelectObject( m_hBuffer );
			m_dcBuffer.DeleteDC();
			m_bmBuffer.DeleteObject();
		}
		
		m_szBuffer = rcClient.Size();
		m_bmBuffer.CreateCompatibleBitmap( &dc, m_szBuffer.cx, m_szBuffer.cy );
		m_dcBuffer.CreateCompatibleDC( &dc );
		m_hBuffer = (HBITMAP)m_dcBuffer.SelectObject( &m_bmBuffer )->m_hObject;
	}
	
	if ( ! CoolInterface.DrawWatermark( &m_dcBuffer, &rcClient, &m_bmWatermark, 0, 0 ) )
	{
		m_dcBuffer.FillSolidRect( &rcClient, Skin.m_crBannerBack );
	}
	
	DoPaint( &m_dcBuffer, rcClient );
	
	dc.BitBlt( rcClient.left, rcClient.top, rcClient.Width(),
		rcClient.Height(), &m_dcBuffer, 0, 0, SRCCOPY );
}

void CLibraryHeaderPanel::DoPaint(CDC* pDC, CRect& rcClient)
{
	CFont* pOldFont = pDC->GetCurrentFont();
	
	CPoint ptIcon( 8, ( rcClient.top + rcClient.bottom ) / 2 - 24 );
	
	if ( m_nIcon48 >= 0 )
	{
		ShellIcons.Draw( pDC, m_nIcon48, 48, ptIcon.x, ptIcon.y );
	}
	else if ( m_nIcon32 >= 0 )
	{
		ptIcon.x += 8; ptIcon.y += 8;
		ShellIcons.Draw( pDC, m_nIcon32, 32, ptIcon.x, ptIcon.y );
	}
	
	pDC->SetTextColor( Skin.m_crBannerText );
	pDC->SetBkMode( TRANSPARENT );
	
	CRect rcWork( &rcClient );
	rcWork.DeflateRect( 8, 4 );
	rcWork.left += 48 + 16;
	
	if ( m_pMetadata.GetCount() )
	{
		CRect rcMeta( &rcWork );
		rcMeta.left		= rcWork.right - m_nMetaWidth;
		rcWork.right	= rcMeta.left - 8;
		
		int nY = rcMeta.top;
		
		for ( POSITION pos = m_pMetadata.GetIterator() ; pos && nY + 12 < rcMeta.bottom ; nY += 12 )
		{
			CMetaItem* pItem = m_pMetadata.GetNext( pos );
			
			pDC->SelectObject( &CoolInterface.m_fntNormal );
			DrawText( pDC, rcMeta.left, nY, pItem->m_sKey + ':' );
			
			if ( pItem->m_bLink ) pDC->SelectObject( &CoolInterface.m_fntUnder );
			DrawText( pDC, rcMeta.left + m_nKeyWidth, nY, pItem->m_sValue );
			
			pItem->SetRect( rcMeta.left + m_nKeyWidth, nY, rcMeta.right, nY + 12 );
		}
	}
	
	rcWork.DeflateRect( 0, 4 );
	
	pDC->SelectObject( &CoolInterface.m_fntCaption );
	Skin.DrawWrappedText( pDC, &rcWork, m_sTitle, FALSE );
	pDC->SelectObject( &CoolInterface.m_fntNormal );
	Skin.DrawWrappedText( pDC, &rcWork, m_sSubtitle, FALSE );
	
	pDC->SelectObject( pOldFont );
}

void CLibraryHeaderPanel::DrawText(CDC* pDC, int nX, int nY, LPCTSTR pszText)
{
	CSize sz = pDC->GetTextExtent( pszText, _tcslen( pszText ) );
	
	CRect rc( nX - 2, nY - 2, nX + sz.cx + 2, nY + sz.cy + 2 );
	
	pDC->ExtTextOut( nX, nY, ETO_CLIPPED /*|ETO_OPAQUE*/, &rc, pszText, _tcslen( pszText ), NULL );
	// pDC->ExcludeClipRect( &rc );
}

BOOL CLibraryHeaderPanel::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	if ( m_pMetadata.OnSetCursor( this ) ) return TRUE;
	
	return CWnd::OnSetCursor( pWnd, nHitTest, message );
}

void CLibraryHeaderPanel::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if ( CMetaItem* pItem = m_pMetadata.HitTest( point, TRUE ) )
	{
		if ( CAlbumFolder* pFolder = pItem->GetLinkTarget() )
		{
			CLibraryFrame* pFrame = (CLibraryFrame*)GetOwner();
			ASSERT_KINDOF(CLibraryFrame, pFrame );
			pFrame->Display( pFolder );
		}
	}
	
	CWnd::OnLButtonUp( nFlags, point );
}