ctrlwndtabbar.cpp

p2p软件

			rcItem.OffsetRect( rcItem.Width() + 3, 0 );
		}
		
		if ( pDC == pOutDC ) pDC->FillSolidRect( &rc, CoolInterface.m_crMidtone );
	}
	else
	{
		CSize  sz = pDC->GetTextExtent( m_sMessage );
		CPoint pt = rc.CenterPoint();
		pt.x -= sz.cx / 2; pt.y -= sz.cy / 2 + 1;
		
		pDC->SetBkColor( CoolInterface.m_crMidtone );
		pDC->SetTextColor( CoolInterface.m_crDisabled );
		
		if ( pDC == pOutDC )
		{
			pDC->SetBkMode( OPAQUE );
			pDC->ExtTextOut( pt.x, pt.y, ETO_CLIPPED|ETO_OPAQUE, &rc, m_sMessage, NULL );
		}
		else
		{
			pDC->SetBkMode( TRANSPARENT );
			pDC->ExtTextOut( pt.x, pt.y, ETO_CLIPPED, &rc, m_sMessage, NULL );
		}

		m_rcMessage.SetRect( pt.x, pt.y, pt.x + sz.cx, pt.y + sz.cy );
	}
	
	pDC->SelectObject( pOldFont );
	
	if ( pDC != pOutDC )
	{
		GetClientRect( &rc );
		pOutDC->BitBlt( 0, 0, rc.Width(), rc.Height(), pDC, 0, 0, SRCCOPY );
		pDC->SelectClipRgn( NULL );
	}
}

void CWndTabBar::OnMouseMove(UINT nFlags, CPoint point) 
{
	TabItem* pItem = HitTest( point );

	if ( pItem != m_pHot )
	{
		m_pHot = pItem;
		Invalidate();
	}

	if ( ! m_bTimer && m_pHot )
	{
		SetTimer( 1, 100, NULL );
		m_bTimer = TRUE;
	}
	else if ( m_bTimer && ! m_pHot )
	{
		KillTimer( 1 );
		m_bTimer = FALSE;
	}

	CControlBar::OnMouseMove( nFlags, point );
}

void CWndTabBar::OnTimer(UINT nIDEvent) 
{
	if ( nIDEvent == 1 )
	{
		CRect rcWindow;
		CPoint point;

		GetClientRect( &rcWindow );
		ClientToScreen( &rcWindow );
		GetCursorPos( &point );

		if ( ! rcWindow.PtInRect( point ) )
		{
			KillTimer( nIDEvent );
			m_pHot		= NULL;
			m_bTimer	= FALSE;
			Invalidate();
		}
	}

	CControlBar::OnTimer( nIDEvent );
}

BOOL CWndTabBar::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	if ( m_pItems.GetCount() == 0 && m_nMessage == IDS_TABBAR_CONNECTED  )
	{
		CPoint point;
		GetCursorPos( &point );
		ScreenToClient( &point );
		
		if ( m_rcMessage.PtInRect( point ) )
		{
			SetCursor( theApp.LoadCursor( IDC_HAND ) );
			return TRUE;
		}
	}
	
	return CControlBar::OnSetCursor( pWnd, nHitTest, message );
}

void CWndTabBar::OnLButtonDown(UINT nFlags, CPoint point) 
{
	CRect rc;
	
	if ( TabItem* pItem = HitTest( point, &rc ) )
	{
		CChildWnd* pChild = (CChildWnd*)CWnd::FromHandle( pItem->m_hWnd );
		
        if ( m_pSelected == pItem &&
			 Settings.General.GUIMode != GUI_WINDOWED &&
			 point.x >= rc.right - 18 )
		{
			pChild->PostMessage( WM_SYSCOMMAND, SC_CLOSE, 0 );
			return;
		}
		else if ( pChild->IsIconic() )
		{
			pChild->ShowWindow( SW_SHOWNORMAL );
		}
		else if ( m_pSelected == pItem && ! pChild->m_bPanelMode )
		{
			pChild->ShowWindow( SW_HIDE );
			pChild->ShowWindow( SW_MINIMIZE );
			return;
		}
		
		pChild->MDIActivate();
		
		return;
	}
	else if ( m_nMessage == IDS_TABBAR_CONNECTED )
	{
		if ( m_pItems.GetCount() == 0 && m_rcMessage.PtInRect( point ) )
		{
			return;
		}
	}
	
	CControlBar::OnLButtonDown( nFlags, point );
}

void CWndTabBar::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	/*
	if ( TabItem* pItem = HitTest( point ) )
	{
		CMDIChildWnd* pChild = (CMDIChildWnd*)CWnd::FromHandle( pItem->m_hWnd );
		pChild->PostMessage( WM_SYSCOMMAND, pChild->IsZoomed() ? SC_RESTORE : SC_MAXIMIZE );
		return;
	}
	*/
	
	OnLButtonDown( nFlags, point );
}

void CWndTabBar::OnLButtonUp(UINT nFlags, CPoint point) 
{
	CRect rc;
	
	if ( TabItem* pItem = HitTest( point, &rc ) )
	{
	}
	else if ( m_nMessage == IDS_TABBAR_CONNECTED )
	{
		if ( m_pItems.GetCount() == 0 && m_rcMessage.PtInRect( point ) )
		{
			GetOwner()->PostMessage( WM_COMMAND, ID_NETWORK_SEARCH );
		}
	}
	
	CControlBar::OnLButtonUp( nFlags, point );
}

void CWndTabBar::OnMButtonUp(UINT nFlags, CPoint point) 
{
	if ( TabItem* pItem = HitTest( point ) )
	{
		CChildWnd* pChild = (CChildWnd*)CWnd::FromHandle( pItem->m_hWnd );
		pChild->PostMessage( WM_SYSCOMMAND, SC_CLOSE, 0 );
	}
	
	CControlBar::OnMButtonUp( nFlags, point );
}

void CWndTabBar::OnRButtonUp(UINT nFlags, CPoint point) 
{
	CRect rcItem;
	
	if ( TabItem* pItem = HitTest( point, &rcItem ) )
	{
		CChildWnd* pChild = (CChildWnd*)CWnd::FromHandle( pItem->m_hWnd );
		if ( pChild->IsWindowVisible() ) pChild->MDIActivate();
		
		ClientToScreen( &rcItem );
		
		CMenu* pMenu = m_mnuChild.GetSubMenu( pChild->m_bPanelMode ? 1 : 0 );
		
		BOOL bCanRestore	= pChild->IsIconic() || pChild->IsZoomed();
		UINT nCommand		= 0;
		
		/*
		MENUITEMINFO pInfo;
		pInfo.cbSize	= sizeof(pInfo);
		pInfo.fMask		= MIIM_STATE;
		GetMenuItemInfo( pMenu->GetSafeHmenu(), ID_CHILD_RESTORE, FALSE, &pInfo );
		pInfo.fState = ( pInfo.fState & (~MFS_DEFAULT) ) | ( bCanRestore ? MFS_DEFAULT : 0 );
		SetMenuItemInfo( pMenu->GetSafeHmenu(), ID_CHILD_RESTORE, FALSE, &pInfo );
		*/
		
		pMenu->EnableMenuItem( ID_CHILD_RESTORE, MF_BYCOMMAND |
			( bCanRestore ? 0 : MF_GRAYED ) );
		pMenu->EnableMenuItem( ID_CHILD_MINIMISE, MF_BYCOMMAND |
			( pChild->IsIconic() ? MF_GRAYED : 0 ) );
		pMenu->EnableMenuItem( ID_CHILD_MAXIMISE, MF_BYCOMMAND |
			( pChild->IsZoomed() ? MF_GRAYED : 0 ) );
		
		m_bMenuGray = TRUE;
		Invalidate();
		
		if ( rcItem.bottom > GetSystemMetrics( SM_CYSCREEN ) / 2 )
		{
			nCommand = pMenu->TrackPopupMenu( TPM_RETURNCMD|TPM_RIGHTBUTTON|
				TPM_LEFTALIGN|TPM_BOTTOMALIGN, rcItem.left, rcItem.top + 1, this, NULL );
		}
		else
		{
			CoolMenu.RegisterEdge( rcItem.left, rcItem.bottom - 1, rcItem.Width() );
			nCommand = pMenu->TrackPopupMenu( TPM_RETURNCMD|TPM_RIGHTBUTTON|
				TPM_LEFTALIGN|TPM_TOPALIGN, rcItem.left, rcItem.bottom - 1, this, NULL );
		}
		
		m_bMenuGray = FALSE;
		Invalidate();
		
		switch ( nCommand )
		{
		case ID_CHILD_RESTORE:
			pChild->PostMessage( WM_SYSCOMMAND, SC_RESTORE, 0 );
			break;
		case ID_CHILD_MINIMISE:
			pChild->PostMessage( WM_SYSCOMMAND, SC_MINIMIZE, 0 );
			break;
		case ID_CHILD_MAXIMISE:
			pChild->PostMessage( WM_SYSCOMMAND, SC_MAXIMIZE, 0 );
			break;
		case ID_CHILD_CLOSE:
			pChild->PostMessage( WM_SYSCOMMAND, SC_CLOSE, 0 );
			break;
		}
		
		return;
	}
	
	CControlBar::OnRButtonUp( nFlags, point );
}

void CWndTabBar::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
{
	CoolMenu.OnMeasureItem( lpMeasureItemStruct );
}

void CWndTabBar::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct) 
{
	CoolMenu.OnDrawItem( lpDrawItemStruct );
}


/////////////////////////////////////////////////////////////////////////////
// CWndTabBar::TabItem construction

CWndTabBar::TabItem::TabItem(CChildWnd* pWnd, DWORD nCookie, LPCTSTR pszCaption)
{
	m_hWnd		= pWnd->GetSafeHwnd();
	m_pClass	= pWnd->GetRuntimeClass();
	m_nImage	= -1;
	m_bVisible	= pWnd->IsWindowVisible();
	m_bAlert	= pWnd->m_bAlert;
	m_nCookie	= nCookie;

	if ( pszCaption != NULL )
		m_sCaption = pszCaption;
	else
		pWnd->GetWindowText( m_sCaption );
}

CWndTabBar::TabItem::~TabItem()
{
}

/////////////////////////////////////////////////////////////////////////////
// CWndTabBar::TabItem paint

void CWndTabBar::TabItem::Paint(CWndTabBar* pBar, CDC* pDC, CRect* pRect, BOOL bSelected, BOOL bHot, BOOL bTransparent)
{
	CRect rc( pRect );
	COLORREF crBack;
	
	if ( bSelected && pBar->m_bMenuGray )
	{
		crBack = CoolInterface.m_crBackNormal;
		pDC->Draw3dRect( &rc, CoolInterface.m_crDisabled, CoolInterface.m_crDisabled );
	}
	else if ( bHot || ( bSelected && m_bVisible ) )
	{
		crBack = ( bHot && bSelected ) ? CoolInterface.m_crBackCheckSel : CoolInterface.m_crBackSel;
		pDC->Draw3dRect( &rc, CoolInterface.m_crBorder, CoolInterface.m_crBorder );
	}
	else
	{
		crBack = bTransparent ? CLR_NONE : CoolInterface.m_crMidtone;
		if ( crBack != CLR_NONE ) pDC->Draw3dRect( &rc, crBack, crBack );
	}

	rc.DeflateRect( 1, 1 );
	if ( crBack != CLR_NONE ) pDC->SetBkColor( crBack );

	CPoint ptImage( rc.left + 2, rc.top + 1 );

	if ( bSelected )
	{
		ImageList_DrawEx( pBar->m_pImages.GetSafeHandle(), m_nImage, pDC->GetSafeHdc(),
			ptImage.x, ptImage.y, 0, 0, crBack, CLR_NONE, ILD_NORMAL );
		pDC->ExcludeClipRect( ptImage.x, ptImage.y, ptImage.x + 16, ptImage.y + 16 );
	}
	else if ( bHot )
	{
		ptImage.Offset( -1, -1 );

		if ( crBack != CLR_NONE )
		{
			pDC->FillSolidRect( ptImage.x, ptImage.y, 18, 2, crBack );
			pDC->FillSolidRect( ptImage.x, ptImage.y + 2, 2, 16, crBack );
		}

		ptImage.Offset( 2, 2 );
		pDC->SetTextColor( CoolInterface.m_crShadow );
		ImageList_DrawEx( pBar->m_pImages.GetSafeHandle(), m_nImage, pDC->GetSafeHdc(),
			ptImage.x, ptImage.y, 0, 0, crBack, CLR_NONE, ILD_MASK );

		ptImage.Offset( -2, -2 );
		ImageList_DrawEx( pBar->m_pImages.GetSafeHandle(), m_nImage, pDC->GetSafeHdc(),
			ptImage.x, ptImage.y, 0, 0, CLR_NONE, CLR_NONE, ILD_NORMAL );

		pDC->ExcludeClipRect( ptImage.x, ptImage.y, ptImage.x + 18, ptImage.y + 18 );

		ptImage.Offset( 1, 1 );
	}
	else
	{
		ImageList_DrawEx( pBar->m_pImages.GetSafeHandle(), m_nImage, pDC->GetSafeHdc(),
			ptImage.x, ptImage.y, 0, 0, crBack, CoolInterface.m_crShadow, ILD_BLEND50 );
		pDC->ExcludeClipRect( ptImage.x, ptImage.y, ptImage.x + 16, ptImage.y + 16 );
	}
	
	rc.left += 20;
	
	if ( bSelected && Settings.General.GUIMode != GUI_WINDOWED )
	{
		ptImage.x = rc.right - 18;
		ImageList_DrawEx( CoolInterface.m_pImages, pBar->m_nCloseImage,
			pDC->GetSafeHdc(), ptImage.x, ptImage.y, 0, 0, crBack, CoolInterface.m_crShadow,
			ILD_BLEND50 );
		pDC->ExcludeClipRect( ptImage.x, ptImage.y, ptImage.x + 16, ptImage.y + 16 );
		rc.right -= 20;
		if ( crBack != CLR_NONE ) pDC->FillSolidRect( rc.right, rc.top, 20, rc.Height(), crBack );
	}
	
	CString strText = m_sCaption;
	
	if ( pDC->GetTextExtent( strText ).cx > rc.Width() )
	{
		while ( pDC->GetTextExtent( strText + _T("