wndpacket.cpp

著名的下载软件核心Shareaza

//
// WndPacket.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 "Network.h"
#include "Neighbours.h"
#include "Neighbour.h"
#include "G1Packet.h"
#include "G2Packet.h"
#include "EDPacket.h"
#include "WndPacket.h"
#include "CoolMenu.h"
#include "LiveList.h"
#include "Skin.h"

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

IMPLEMENT_SERIAL(CPacketWnd, CPanelWnd, 0)

BEGIN_MESSAGE_MAP(CPacketWnd, CPanelWnd)
	//{{AFX_MSG_MAP(CPacketWnd)
	ON_WM_CREATE()
	ON_WM_SIZE()
	ON_NOTIFY(NM_CUSTOMDRAW, IDC_PACKETS, OnCustomDrawList)
	ON_WM_CONTEXTMENU()
	ON_WM_MEASUREITEM()
	ON_WM_DRAWITEM()
	ON_UPDATE_COMMAND_UI(ID_SYSTEM_CLEAR, OnUpdateSystemClear)
	ON_WM_DESTROY()
	ON_WM_TIMER()
	//}}AFX_MSG_MAP
	ON_UPDATE_COMMAND_UI_RANGE(1, 3200, OnUpdateBlocker)
END_MESSAGE_MAP()

LPCSTR CPacketWnd::m_pszG2[] = { "PI", "PO", "LNI", "KHL", "HAW", "QKR", "QKA", "Q1", "QH1", "Q2", "QH2", "QA", "QHT", "PUSH", "UPROC", "UPROD", NULL };


/////////////////////////////////////////////////////////////////////////////
// CPacketWnd construction

CPacketWnd::CPacketWnd(CChildWnd* pOwner)
{
	m_pOwner	= pOwner;
	m_bPaused	= TRUE;
	Create( IDR_PACKETFRAME );
}

CPacketWnd::~CPacketWnd()
{
}

/////////////////////////////////////////////////////////////////////////////
// CPacketWnd create

int CPacketWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if ( CPanelWnd::OnCreate( lpCreateStruct ) == -1 ) return -1;
	
	m_wndList.Create( WS_VISIBLE|LVS_ICON|LVS_AUTOARRANGE|LVS_REPORT,
		rectDefault, this, IDC_PACKETS );

	m_pSizer.Attach( &m_wndList );
	
	m_wndList.SendMessage( LVM_SETEXTENDEDLISTVIEWSTYLE,
		LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_LABELTIP,
		LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP|LVS_EX_LABELTIP );
	
	m_wndList.InsertColumn( 0, _T("Address"), LVCFMT_LEFT, 100, -1 );
	m_wndList.InsertColumn( 1, _T("Protocol"), LVCFMT_CENTER, 40, 0 );
    m_wndList.InsertColumn( 2, _T("Type"), LVCFMT_CENTER, 45, 1 );
	m_wndList.InsertColumn( 3, _T("T/H"), LVCFMT_CENTER, 40, 2 );
	m_wndList.InsertColumn( 4, _T("Hex"), LVCFMT_LEFT, 200, 3 );
	m_wndList.InsertColumn( 5, _T("ASCII"), LVCFMT_LEFT, 120, 4 );
	m_wndList.InsertColumn( 6, _T("G1-ID"), LVCFMT_LEFT, 0, 5 );
	// 210 for full width ID column
	
	Settings.LoadList( _T("CPacketWnd"), &m_wndList );

	m_pFont.CreateFont( -10, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
		DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
		DEFAULT_PITCH|FF_DONTCARE, _T("Lucida Console") );

	m_wndList.SetFont( &m_pFont );

	CWnd* pWnd = CWnd::FromHandle( (HWND)m_wndList.SendMessage( LVM_GETHEADER ) );
	pWnd->SetFont( &theApp.m_gdiFont );
	
	LoadState( _T("CPacketWnd"), TRUE );

	m_pCoolMenu		= NULL;
	m_nInputFilter	= 0;
	m_nOutputFilter	= 0;
	m_bPaused		= FALSE;

	for ( int nType = 0 ; nType < G1_PACKTYPE_MAX ; nType++ ) m_bTypeG1[ nType ] = TRUE;
	for ( nType = 0 ; nType < 16 ; nType++ ) m_bTypeG2[ nType ] = TRUE;

	SetTimer( 2, 500, NULL );

	return 0;
}

void CPacketWnd::OnDestroy() 
{
	KillTimer( 2 );

	CSingleLock pLock( &m_pSection, TRUE );
	m_bPaused = TRUE;

	for ( POSITION pos = m_pQueue.GetHeadPosition() ; pos ; )
	{
		delete (CLiveItem*)m_pQueue.GetNext( pos );
	}
	m_pQueue.RemoveAll();

	pLock.Unlock();

	Settings.SaveList( _T("CPacketWnd"), &m_wndList );
	SaveState( _T("CPacketWnd") );

	CPanelWnd::OnDestroy();
}

/////////////////////////////////////////////////////////////////////////////
// CPacketWnd operations

void CPacketWnd::Process(const CNeighbour* pNeighbour, const IN_ADDR* pUDP, BOOL bOutgoing, const CPacket* pPacket)
{
	if ( m_bPaused || m_hWnd == NULL ) return;

	if ( pNeighbour )
	{
		if ( bOutgoing )
		{
			if ( m_nOutputFilter && m_nOutputFilter != pNeighbour->m_nUnique ) return;
		}
		else
		{
			if ( m_nInputFilter && m_nInputFilter != pNeighbour->m_nUnique ) return;
		}
	}
	else
	{
		if ( bOutgoing )
		{
			if ( m_nOutputFilter ) return;
		}
		else
		{
			if ( m_nInputFilter ) return;
		}
	}

	CG1Packet* pPacketG1 = ( pPacket->m_nProtocol == PROTOCOL_G1 ) ? (CG1Packet*)pPacket : NULL;
	CG2Packet* pPacketG2 = ( pPacket->m_nProtocol == PROTOCOL_G2 ) ? (CG2Packet*)pPacket : NULL;
	CEDPacket* pPacketED = ( pPacket->m_nProtocol == PROTOCOL_ED2K ) ? (CEDPacket*)pPacket : NULL;

	if ( pPacketG1 )
	{
		if ( ! m_bTypeG1[ pPacketG1->m_nTypeIndex ] ) return;
	}
	else if ( pPacketG2 )
	{
		for ( int nType = 0 ; m_pszG2[ nType ] ; nType++ )
		{
			if ( strcmp( pPacketG2->m_sType, m_pszG2[ nType ] ) == 0 )
			{
				if ( ! m_bTypeG2[ nType ] ) return;
				break;
			}
		}
	}
	else if ( pPacketED )
	{
		// TODO: Filter ED2K packets
	}
	
	CSingleLock pLock( &m_pSection, TRUE );
	
	if ( m_bPaused ) return;
	
	CLiveItem* pItem = new CLiveItem( 7, 0 );
	
	pItem->m_nParam = bOutgoing;
	
	if ( pNeighbour )
	{
		pItem->Set( 0, pNeighbour->m_sAddress );
	}
	else
	{
		pItem->Set( 0, _T("(") + CString( inet_ntoa( *pUDP ) ) + _T(")") );
	}
	
	if ( pPacketG2 )
		pItem->Set( 1, _T("G2") );
	else if ( pPacketG1 )
		pItem->Set( 1, _T("G1") );
	else if ( pPacketED )
		pItem->Set( 1, _T("ED2K") );
	
	pItem->Set( 2, pPacket->GetType() );
	pItem->Set( 4, pPacket->ToHex() );
	pItem->Set( 5, pPacket->ToASCII() );
	
	if ( pPacketG1 )
	{
		pItem->Format( 3, _T("%i/%i"), pPacketG1->m_nTTL, pPacketG1->m_nHops );
		pItem->Set( 6, pPacketG1->GetGUID() );
	}
	
	m_pQueue.AddTail( pItem );
}

void CPacketWnd::OnTimer(UINT nIDEvent) 
{
	if ( nIDEvent != 2 ) return;

	BOOL bScroll = m_wndList.GetTopIndex() + m_wndList.GetCountPerPage() >= m_wndList.GetItemCount();

	CSingleLock pLock( &m_pSection );
	BOOL bAny = FALSE;

	while ( TRUE )
	{
		pLock.Lock();

		if ( m_pQueue.GetCount() == 0 ) break;
		CLiveItem* pItem = (CLiveItem*)m_pQueue.RemoveHead();

		pLock.Unlock();

		if ( ! bAny )
		{
			bAny = TRUE;
			m_wndList.ModifyStyle( WS_VISIBLE , 0);
		}

		if ( (DWORD)m_wndList.GetItemCount() >= Settings.Search.MonitorQueue && Settings.Search.MonitorQueue > 0 )
		{
			m_wndList.DeleteItem( 0 );
		}

		int nItem = pItem->Add( &m_wndList, -1, 7 );

		delete pItem;
	}

	if ( bAny )
	{
		if ( bScroll ) m_wndList.EnsureVisible( m_wndList.GetItemCount() - 1, FALSE );
		m_wndList.ShowWindow( SW_SHOW );
	}
}

/////////////////////////////////////////////////////////////////////////////
// CPacketWnd message handlers

void CPacketWnd::OnSize(UINT nType, int cx, int cy) 
{
	CPanelWnd::OnSize( nType, cx, cy );
	m_pSizer.Resize( cx );
	m_wndList.SetWindowPos( NULL, 0, 0, cx, cy, SWP_NOZORDER );
}

void CPacketWnd::OnCustomDrawList(NMHDR* pNMHDR, LRESULT* pResult)
{
	NMLVCUSTOMDRAW* pDraw = (NMLVCUSTOMDRAW*)pNMHDR;

	if ( pDraw->nmcd.dwDrawStage == CDDS_PREPAINT )
	{
		*pResult = CDRF_NOTIFYITEMDRAW;
	}
	else if ( pDraw->nmcd.dwDrawStage == CDDS_ITEMPREPAINT )
	{
		if ( m_nInputFilter != 1 && m_nOutputFilter != 1 )
		{
			if ( pDraw->nmcd.lItemlParam )
				pDraw->clrText = RGB( 127, 0, 0 );
			else
				pDraw->clrText = RGB( 0, 0, 127 );
		}
		*pResult = CDRF_DODEFAULT;
	}
}

void CPacketWnd::OnContextMenu(CWnd* pWnd, CPoint point) 
{
	CSingleLock pLock( &Network.m_pSection, TRUE );

	CMenu pMenu, pHosts[2], pTypes1, pTypes2;

	for ( int nGroup = 0 ; nGroup < 2 ; nGroup++ )
	{
		UINT nID = nGroup ? 2000 : 1000;

		pHosts[nGroup].CreatePopupMenu();

		AddNeighbour( pHosts, nGroup, nID++, 1, _T("Disable") );
		AddNeighbour( pHosts, nGroup, nID++, 0, _T("Any Neighbour") );
		pHosts[nGroup].AppendMenu( MF_SEPARATOR, ID_SEPARATOR );

		for ( POSITION pos = Neighbours.GetIterator() ; pos ; nID++ )
		{
			CNeighbour* pNeighbour = Neighbours.GetNext( pos );
			if ( pNeighbour->m_nState < nrsConnected ) continue;
			AddNeighbour( pHosts, nGroup, nID, pNeighbour->m_nUnique, pNeighbour->m_sAddress );
		}

		if ( ( nID % 1000 ) == 2 )
			pHosts[nGroup].AppendMenu( MF_STRING|MF_GRAYED, 999, _T("No Neighbours") );
	}
	
	pTypes1.CreatePopupMenu();

	for ( int nType = 0 ; nType < G1_PACKTYPE_MAX ; nType++ )
	{
		if ( m_bTypeG1[ nType ] )
			pTypes1.AppendMenu( MF_STRING|MF_CHECKED, 3000 + nType, CG1Packet::m_pszPackets[ nType ] );
		else
			pTypes1.AppendMenu( MF_STRING, 3000 + nType, CG1Packet::m_pszPackets[ nType ] );
	}

	pTypes2.CreatePopupMenu();

	for ( nType = 0 ; m_pszG2[ nType ] ; nType++ )
	{
		if ( m_bTypeG2[ nType ] )
			pTypes2.AppendMenu( MF_STRING|MF_CHECKED, 3100 + nType, CString( m_pszG2[ nType ] ) );
		else
			pTypes2.AppendMenu( MF_STRING, 3100 + nType, CString( m_pszG2[ nType ] ) );
	}

	pMenu.CreatePopupMenu();
	pMenu.AppendMenu( MF_STRING|MF_POPUP, (UINT)pHosts[0].GetSafeHmenu(), _T("Incoming") );
	pMenu.AppendMenu( MF_STRING|MF_POPUP, (UINT)pHosts[1].GetSafeHmenu(), _T("Outgoing") );
	pMenu.AppendMenu( MF_STRING|MF_POPUP, (UINT)pTypes1.GetSafeHmenu(), _T("G1 Types") );
	pMenu.AppendMenu( MF_STRING|MF_POPUP, (UINT)pTypes2.GetSafeHmenu(), _T("G2 Types") );
	pMenu.AppendMenu( MF_SEPARATOR, ID_SEPARATOR );
	pMenu.AppendMenu( MF_STRING | ( m_bPaused ? MF_CHECKED : 0 ), 1, _T("&Pause Display") );
	pMenu.AppendMenu( MF_STRING, ID_SYSTEM_CLEAR, _T("&Clear Buffer") );

	m_pCoolMenu = new CCoolMenu();
	m_pCoolMenu->AddMenu( &pMenu, TRUE );
	m_pCoolMenu->SetWatermark( Skin.GetWatermark( _T("CCoolMenu") ) );

	pLock.Unlock();

	UINT nCmd = pMenu.TrackPopupMenu( TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_RIGHTBUTTON|TPM_RETURNCMD,
		point.x, point.y, this );

	delete m_pCoolMenu;
	m_pCoolMenu = NULL;

	DWORD* pModify = NULL;

	if ( nCmd == 1 )
	{
		m_bPaused = ! m_bPaused;
		return;
	}
	else if ( nCmd == ID_SYSTEM_CLEAR )
	{
		m_wndList.DeleteAllItems();
		return;
	}
	else if ( nCmd >= 3000 && nCmd < 3000 + G1_PACKTYPE_MAX )
	{
		nCmd -= 3000;

		if ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 )
		{
			for ( int nType = 0 ; nType < G1_PACKTYPE_MAX ; nType++ )
			{
				m_bTypeG1[ nType ] = ( nCmd == (UINT)nType ) ? TRUE : FALSE;
			}
		}
		else
		{
			m_bTypeG1[ nCmd ] = ! m_bTypeG1[ nCmd ];
		}

		return;
	}
	else if ( nCmd >= 3100 && nCmd < 3100 + 16 )
	{
		nCmd -= 3100;

		if ( GetAsyncKeyState( VK_SHIFT ) & 0x8000 )
		{
			for ( int nType = 0 ; nType < 16 ; nType++ )
			{
				m_bTypeG2[ nType ] = ( nCmd == (UINT)nType ) ? TRUE : FALSE;
			}
		}
		else
		{
			m_bTypeG2[ nCmd ] = ! m_bTypeG2[ nCmd ];
		}

		return;
	}
	else if ( nCmd >= 1000 && nCmd < 2000 )
	{
		pModify = &m_nInputFilter;
		nCmd -= 1000;
	}
	else if ( nCmd >= 2000 && nCmd < 3000 )
	{
		pModify = &m_nOutputFilter;
		nCmd -= 2000;
	}
	else
	{
		return;
	}

	if ( nCmd == 0 )
	{
		*pModify = 1;
	}
	else if ( nCmd == 1 )
	{
		*pModify = 0;
	}
	else
	{
		pLock.Lock();
		nCmd -= 2;

		for ( POSITION pos = Neighbours.GetIterator() ; pos ; nCmd-- )
		{
			CNeighbour* pNeighbour = Neighbours.GetNext( pos );
			if ( ! nCmd )
			{
				*pModify = pNeighbour->m_nUnique;
				break;
			}
		}
	}

	Invalidate();
}

void CPacketWnd::AddNeighbour(CMenu* pMenus, int nGroup, UINT nID, DWORD nTarget, LPCTSTR pszText)
{
	UINT nChecked = ( ( nGroup == 1 && m_nOutputFilter == nTarget ) ||
		 ( nGroup == 0 && m_nInputFilter == nTarget ) )
		 ? MF_CHECKED : 0;

	pMenus[nGroup].AppendMenu( MF_STRING|nChecked, nID, pszText );
}

void CPacketWnd::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct) 
{
	if ( m_pCoolMenu ) m_pCoolMenu->OnMeasureItem( lpMeasureItemStruct );
}

void CPacketWnd::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct) 
{
	if ( m_pCoolMenu ) m_pCoolMenu->OnDrawItem( lpDrawItemStruct );
}

void CPacketWnd::OnUpdateBlocker(CCmdUI* pCmdUI)
{
	if ( m_pCoolMenu ) pCmdUI->Enable( pCmdUI->m_nID != 999 );
	else pCmdUI->ContinueRouting();
}

void CPacketWnd::OnUpdateSystemClear(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable( TRUE );	
}