wndmonitor.cpp

p2p软件

	{
		float nPosition = m_nMediaSeek >= 0 ? m_nMediaSeek : ( CMediaFrame::g_pMediaFrame != NULL ? CMediaFrame::g_pMediaFrame->GetPosition() : 0 );
		CRect rcTrack( &m_rcsMediaSeekTrack ), rcPart;
		
		if ( m_bsMediaSeekTab )
		{
			rcPart.CopyRect( &m_rcsMediaSeekTab );
			
			if ( m_bMediaSeek || m_nMediaSeek >= 0 )
				rcPart.OffsetRect( rcPart.Width(), 0 );
			
			m_rcMediaSeekTab.left	= rcTrack.left + (int)( nPosition * ( rcTrack.Width() - rcPart.Width() ) );
			m_rcMediaSeekTab.right	= m_rcMediaSeekTab.left + rcPart.Width();
			m_rcMediaSeekTab.top	= rcTrack.top;
			m_rcMediaSeekTab.bottom	= rcTrack.top + rcPart.Height();
			
			pDC->BitBlt( m_rcMediaSeekTab.left, m_rcMediaSeekTab.top, m_rcMediaSeekTab.Width(),
				m_rcMediaSeekTab.Height(), &m_pSkin->m_dcSkin, rcPart.left, rcPart.top, SRCCOPY );
			pDC->ExcludeClipRect( &m_rcMediaSeekTab );
			
			rcTrack.right = m_rcMediaSeekTab.left;
		}
		
		if ( m_bsMediaSeekBar )
		{
			rcPart.CopyRect( &m_rcsMediaSeekBar );
			CRect rcBar( &rcTrack );
			
			while ( rcBar.left < rcBar.right )
			{
				pDC->BitBlt( rcBar.left, rcBar.top, min( rcBar.Width(), rcPart.Width() ),
					rcPart.Height(), &m_pSkin->m_dcSkin, rcPart.left, rcPart.top, SRCCOPY );
				rcBar.left += rcPart.Width();
			}
		}
	}
	
	if ( m_bsMediaVolTrack )
	{
		float nPosition = (float)Settings.MediaPlayer.Volume;
		CRect rcTrack( &m_rcsMediaVolTrack ), rcPart;
		
		if ( m_bsMediaVolTab )
		{
			rcPart.CopyRect( &m_rcsMediaVolTab );
			
			if ( m_bMediaVol || m_nMediaVol >= 0 )
				rcPart.OffsetRect( rcPart.Width(), 0 );
			
			m_rcMediaVolTab.left	= rcTrack.left + (int)( nPosition * ( rcTrack.Width() - rcPart.Width() ) );
			m_rcMediaVolTab.right	= m_rcMediaVolTab.left + rcPart.Width();
			m_rcMediaVolTab.top		= rcTrack.top;
			m_rcMediaVolTab.bottom	= rcTrack.top + rcPart.Height();
			
			pDC->BitBlt( m_rcMediaVolTab.left, m_rcMediaVolTab.top, m_rcMediaVolTab.Width(),
				m_rcMediaVolTab.Height(), &m_pSkin->m_dcSkin, rcPart.left, rcPart.top, SRCCOPY );
			pDC->ExcludeClipRect( &m_rcMediaVolTab );
			
			rcTrack.right = m_rcMediaVolTab.left;
		}
		
		if ( m_bsMediaVolBar )
		{
			rcPart.CopyRect( &m_rcsMediaVolBar );
			rcTrack.right = min( rcTrack.right, rcTrack.left + rcPart.Width() );
			pDC->BitBlt( rcTrack.left, rcTrack.top, rcTrack.Width(),
				rcPart.Height(), &m_pSkin->m_dcSkin, rcPart.left, rcPart.top, SRCCOPY );
		}
	}
	
	if ( m_bsStatusText && CMediaFrame::g_pMediaFrame != NULL && ! m_bStatus )
	{
		m_bStatus |= CMediaFrame::g_pMediaFrame->PaintStatusMicro( *pDC, m_rcsStatusText );
	}
	
	if ( CMediaFrame::g_pMediaFrame != NULL )
	{
		MediaState nState = CMediaFrame::g_pMediaFrame->GetState();
		int nImage = 0;
		
		if ( nState >= smsPlaying )
			nImage = 1;
		else if ( nState >= smsPaused )
			nImage = 2;
		
		if ( m_bsMediaStates[0][nImage] && m_bsMediaStates[1][nImage] )
		{
			CRect* prcAnchor = &m_rcsMediaStates[0][nImage];
			CRect* prcPart = &m_rcsMediaStates[1][nImage];
			
			pDC->BitBlt( prcAnchor->left, prcAnchor->top,
				prcAnchor->Width(), prcAnchor->Height(), &m_pSkin->m_dcSkin,
				prcPart->left, prcPart->top, SRCCOPY );
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
// CRemoteWnd paint status functionality

void CRemoteWnd::PaintStatus(CDC* pDC)
{
	if ( m_bsStatusText && ! m_bStatus )
	{
		pDC->DrawText( m_sStatus, &m_rcsStatusText, DT_SINGLELINE|DT_CENTER|DT_VCENTER|DT_NOPREFIX|DT_END_ELLIPSIS );
	}
}

/////////////////////////////////////////////////////////////////////////////
// CRemoteWnd mouse interaction

void CRemoteWnd::OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp)
{
}

UINT CRemoteWnd::OnNcHitTest(CPoint point)
{
	return HTCLIENT;
}

BOOL CRemoteWnd::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
{
	CPoint point;
	GetCursorPos( &point );
	ScreenToClient( &point );
	
	BOOL bAvailable = CMediaFrame::g_pMediaFrame != NULL;
	
	if ( m_bsScalerTrack && m_rcScalerTab.PtInRect( point ) )
	{
		if ( ! m_bScaler ) Invalidate();
		m_bScaler = TRUE;
	}
	else if ( bAvailable && m_bsMediaSeekTrack && m_rcMediaSeekTab.PtInRect( point ) )
	{
		if ( ! m_bMediaSeek ) Invalidate();
		m_bMediaSeek = TRUE;
	}
	else if ( bAvailable && m_bsMediaVolTrack && m_rcMediaVolTab.PtInRect( point ) )
	{
		if ( ! m_bMediaVol ) Invalidate();
		m_bMediaVol = TRUE;
	}
	else if ( m_bScaler || m_bMediaSeek || m_bMediaVol )
	{
		m_bScaler = m_bMediaSeek = m_bMediaVol = FALSE;
		Invalidate();
	}
	
	if ( HitTestButtons( point ) != NULL )
	{
		SetCursor( AfxGetApp()->LoadCursor( IDC_HAND ) );
		return TRUE;
	}
	else if ( m_bsScalerTrack && m_rcsScalerTrack.PtInRect( point ) )
	{
		SetCursor( AfxGetApp()->LoadCursor( IDC_HAND ) );
		return TRUE;
	}
	else if ( bAvailable && m_bsMediaSeekTrack && m_rcsMediaSeekTrack.PtInRect( point ) )
	{
		SetCursor( AfxGetApp()->LoadCursor( IDC_HAND ) );
		return TRUE;
	}
	else if ( bAvailable && m_bsMediaVolTrack && m_rcsMediaVolTrack.PtInRect( point ) )
	{
		SetCursor( AfxGetApp()->LoadCursor( IDC_HAND ) );
		return TRUE;
	}
    else
	{
		SetCursor( AfxGetApp()->LoadStandardCursor( IDC_ARROW ) );
		return TRUE;
	}
}

void CRemoteWnd::OnMouseMove(UINT nFlags, CPoint point)
{
	CmdButton* pButton = HitTestButtons( point );
	
	if ( m_pCmdHover != pButton )
	{
		m_pCmdHover = pButton;
		Invalidate();
	}
	
	if ( m_pCmdDown == NULL ) CWnd::OnMouseMove(nFlags, point);
}

void CRemoteWnd::OnLButtonDown(UINT nFlags, CPoint point)
{
	SetActiveWindow();
	SetFocus();
	
	if ( CmdButton* pButton = HitTestButtons( point ) )
	{
		m_pCmdDown = m_pCmdHover = pButton;
		Invalidate();
		SetCapture();
	}
	else if ( m_bsScalerTrack && m_rcsScalerTrack.PtInRect( point ) )
	{
		TrackScaler();
	}
	else if ( m_bsMediaSeekTrack && m_rcsMediaSeekTrack.PtInRect( point ) )
	{
		TrackSeek();
	}
	else if ( m_bsMediaVolTrack && m_rcsMediaVolTrack.PtInRect( point ) )
	{
		TrackVol();
	}
	else
	{
		ClientToScreen( &point );
		SendMessage( WM_NCLBUTTONDOWN, HTCAPTION, MAKELONG( point.x, point.y ) );
	}
}

void CRemoteWnd::OnLButtonUp(UINT nFlags, CPoint point)
{
	if ( m_pCmdDown != NULL )
	{
		BOOL bOK = ( m_pCmdDown == m_pCmdHover );
		
		m_pCmdDown = NULL;
		Invalidate();
		ReleaseCapture();
		
		if ( bOK )
		{
			UpdateWindow();
			m_pCmdHover->Execute( (CFrameWnd*)AfxGetMainWnd() );
			UpdateCmdButtons();
		}
	}
	else
	{
		ClientToScreen( &point );
		SendMessage( WM_NCLBUTTONUP, HTCAPTION, MAKELONG( point.x, point.y ) );
	}
}

void CRemoteWnd::OnNcLButtonDblClk(UINT nFlags, CPoint point)
{
	if ( m_bsHistoryDest && m_rcsHistoryDest.PtInRect( point ) )
	{
		AfxGetMainWnd()->PostMessage( WM_COMMAND, ID_TAB_HOME );
	}
	else if ( m_bsStatusText && m_rcsStatusText.PtInRect( point ) )
	{
		AfxGetMainWnd()->PostMessage( WM_COMMAND, ID_TAB_MEDIA );
	}
	else
	{
		AfxGetMainWnd()->PostMessage( WM_COMMAND, ID_TRAY_OPEN );
	}
}

void CRemoteWnd::OnRButtonDown(UINT nFlags, CPoint point)
{
	CMenu* pMenu = Skin.GetMenu( _T("CRemoteWnd") );
	if ( pMenu == NULL ) pMenu = Skin.GetMenu( _T("CMainWnd.Tray") );
	if ( pMenu == NULL ) return;
	
	MENUITEMINFO pInfo;
	pInfo.cbSize	= sizeof(pInfo);
	pInfo.fMask		= MIIM_STATE;
	GetMenuItemInfo( pMenu->GetSafeHmenu(), ID_TRAY_OPEN, FALSE, &pInfo );
	pInfo.fState	|= MFS_DEFAULT;
	SetMenuItemInfo( pMenu->GetSafeHmenu(), ID_TRAY_OPEN, FALSE, &pInfo );
	
	ClientToScreen( &point );
	pMenu->TrackPopupMenu( TPM_CENTERALIGN|TPM_TOPALIGN|TPM_RIGHTBUTTON,
		point.x, point.y, AfxGetMainWnd(), NULL );
}

INT_PTR CRemoteWnd::OnToolHitTest(CPoint point, TOOLINFO* pTI) const
{
	if ( CmdButton* pButton = HitTestButtons( point ) )
	{
		CString strTip;
		
		if ( LoadString( strTip, pButton->m_nID ) )
		{
			if ( LPCTSTR pszBreak = _tcschr( strTip, '\n' ) )
			{
				pTI->lpszText = _tcsdup( pszBreak + 1 );
			}
			else
			{
				strTip = strTip.SpanExcluding( _T(".") );
				pTI->lpszText = _tcsdup( strTip );
			}
		}
		
		pTI->hwnd		= GetSafeHwnd();
		pTI->uId		= pButton->m_nID;
		pTI->uFlags		= pTI->uFlags & ~TTF_IDISHWND;
		pTI->rect		= pButton->m_rc;
		
		return pTI->uId;
	}
	
	return CWnd::OnToolHitTest( point, pTI );
}

/////////////////////////////////////////////////////////////////////////////
// CRemoteWnd trackers

void CRemoteWnd::TrackScaler()
{
	MSG* pMsg = &AfxGetThreadState()->m_msgCur;
	CRect rcTrack( &m_rcsScalerTrack );
	CPoint point;
	
	ClientToScreen( &rcTrack );
	ClipCursor( &rcTrack );
	ScreenToClient( &rcTrack );
	SetCapture();
	
	rcTrack.DeflateRect( m_rcScalerTab.Width() / 2, 0 );
	
	while ( GetAsyncKeyState( VK_LBUTTON ) & 0x8000 )
	{
		while ( ::PeekMessage( pMsg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ) );
		
		if ( ! AfxGetThread()->PumpMessage() )
		{
			AfxPostQuitMessage( 0 );
			break;
		}
		
		GetCursorPos( &point );
		ScreenToClient( &point );
		
		int nPosition = (int)( 105.0f * (float)( point.x - rcTrack.left ) / (float)rcTrack.Width() );
		if ( nPosition < 0 ) nPosition = 0;
		else if ( nPosition >= 102 ) nPosition = 101;
		else if ( nPosition >= 100 ) nPosition = 100;
		
		if ( nPosition != (int)Settings.Live.BandwidthScale )
		{
			Settings.Live.BandwidthScale = (DWORD)nPosition;
			Invalidate();
		}
	}
	
	ReleaseCapture();
	ClipCursor( NULL );
	Invalidate();
}

void CRemoteWnd::TrackSeek()
{
	MSG* pMsg = &AfxGetThreadState()->m_msgCur;
	CRect rcTrack( &m_rcsMediaSeekTrack );
	CPoint point;
	
	if ( CMediaFrame::g_pMediaFrame == NULL ) return;
	
	ClientToScreen( &rcTrack );
	ClipCursor( &rcTrack );
	ScreenToClient( &rcTrack );
	SetCapture();
	
	rcTrack.DeflateRect( m_rcMediaSeekTab.Width() / 2, 0 );
	
	while ( GetAsyncKeyState( VK_LBUTTON ) & 0x8000 )
	{
		while ( ::PeekMessage( pMsg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ) );
		
		if ( ! AfxGetThread()->PumpMessage() )
		{
			AfxPostQuitMessage( 0 );
			break;
		}
		
		GetCursorPos( &point );
		ScreenToClient( &point );
		
		float nPosition = (float)( point.x - rcTrack.left ) / (float)rcTrack.Width();
		if ( nPosition < 0.0f ) nPosition = 0.0f;
		if ( nPosition > 1.0f ) nPosition = 1.0f;
		
		if ( nPosition != m_nMediaSeek )
		{
			m_nMediaSeek = nPosition;
			Invalidate();
		}
	}
	
	ReleaseCapture();
	ClipCursor( NULL );
	
	CMediaFrame::g_pMediaFrame->SeekTo( m_nMediaSeek );
	m_nMediaSeek = -1;
	Invalidate();
}

void CRemoteWnd::TrackVol()
{
	MSG* pMsg = &AfxGetThreadState()->m_msgCur;
	CRect rcTrack( &m_rcsMediaVolTrack );
	CPoint point;
	
	if ( CMediaFrame::g_pMediaFrame == NULL ) return;
	
	ClientToScreen( &rcTrack );
	ClipCursor( &rcTrack );
	ScreenToClient( &rcTrack );
	SetCapture();
	
	rcTrack.DeflateRect( m_rcMediaVolTab.Width() / 2, 0 );
	
	while ( GetAsyncKeyState( VK_LBUTTON ) & 0x8000 )
	{
		while ( ::PeekMessage( pMsg, NULL, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE ) );
		
		if ( ! AfxGetThread()->PumpMessage() )
		{
			AfxPostQuitMessage( 0 );
			break;
		}
		
		GetCursorPos( &point );
		ScreenToClient( &point );
		
		float nPosition = (float)( point.x - rcTrack.left ) / (float)rcTrack.Width();
		if ( nPosition < 0.0f ) nPosition = 0.0f;
		if ( nPosition > 1.0f ) nPosition = 1.0f;
		
		if ( nPosition != m_nMediaVol )
		{
			m_nMediaVol = nPosition;
			CMediaFrame::g_pMediaFrame->SetVolume( m_nMediaVol );
			Invalidate();
		}
	}
	
	ReleaseCapture();
	ClipCursor( NULL );
	
	m_nMediaVol = -1;
	Invalidate();
}


/////////////////////////////////////////////////////////////////////////////
// CRemoteWnd::CmdButton construction

CRemoteWnd::CmdButton::CmdButton(LPCTSTR pszName) : m_rc( 0, 0, 0, 0 )
{
	m_nID		= CoolInterface.NameToID( pszName + 1 );
	m_sName		= pszName;
	m_bVisible	= TRUE;
	m_bEnabled	= TRUE;
	m_bChecked	= FALSE;
	if ( m_nID == 0 ) m_nID = 1;
}

BOOL CRemoteWnd::CmdButton::HitTest(const CPoint& point, BOOL bAll) const
{
	return ( bAll || m_bEnabled ) && m_rc.PtInRect( point );
}

void CRemoteWnd::CmdButton::Show(BOOL bShow)
{
	if ( m_bVisible == bShow ) return;
	m_bVisible = bShow;
	m_bChanged = TRUE;
}

void CRemoteWnd::CmdButton::Enable(BOOL bOn)
{
	m_bEnableChanged = TRUE;
	if ( m_bEnabled == bOn ) return;
	m_bEnabled = bOn;
	m_bChanged = TRUE;
}

void CRemoteWnd::CmdButton::SetCheck(int nCheck)
{
	if ( m_bChecked == ( nCheck != 0 ) ) return;
	m_bChecked = ( nCheck != 0 );
	m_bChanged = TRUE;
}

void CRemoteWnd::CmdButton::Execute(CFrameWnd* pTarget)
{
	if ( m_bVisible && m_bEnabled )
	{
		pTarget->SendMessage( WM_COMMAND, m_nID );
	}
}

void CRemoteWnd::CmdButton::Paint(CDC* pdcWindow, CRect& rcWindow, CSkinWindow* pSkin, CmdButton* pHover, CmdButton* pDown)
{
	ASSERT( pSkin != NULL );
	pSkin->GetAnchor( m_sName, m_rc );
	
	if ( ! m_bVisible )
	{
		return;
	}
	else if ( m_bChecked )
	{
		if ( ! pSkin->PaintPartOnAnchor( pdcWindow, rcWindow, m_sName + _T(".Checked"), m_sName ) )
			pSkin->PaintPartOnAnchor( pdcWindow, rcWindow, m_sName + _T(".Down"), m_sName );
	}
	else if ( ! m_bEnabled )
	{
		pSkin->PaintPartOnAnchor( pdcWindow, rcWindow, m_sName + _T(".Disabled"), m_sName );
	}
	else if ( pHover == this && pDown == this )
	{
		pSkin->PaintPartOnAnchor( pdcWindow, rcWindow, m_sName + _T(".Down"), m_sName );
	}
	else if ( ( pHover == this && pDown == NULL ) || ( pDown == this ) )
	{
		pSkin->PaintPartOnAnchor( pdcWindow, rcWindow, m_sName + _T(".Hover"), m_sName );
	}
	else
	{
		pSkin->PaintPartOnAnchor( pdcWindow, rcWindow, m_sName + _T(".Up"), m_sName );
	}
}