repos_ecs/其他2015后/SkinST/SkinBuilder/SPPPropertyGridItem.cpp

/********************************************
** 工作室：S&P工作室
** 作者	 ：张东斌
** 日期  ：2007年6月
*********************************************/

#include "StdAfx.h"
#include "SPVC80Helpers.h"
#include "SPDrawHelpers.h"

#include "SPPropertyGridInplaceEdit.h"
#include "SPPropertyGridInplaceButton.h"
#include "SPPropertyGridInplaceList.h"
#include "SPPropertyGridItem.h"
#include "SPPropertyGrid.h"
#include "SPPropertyGridDefines.h"


#define SAFE_CALLPTR(p, f) if (p) p->f

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

/////////////////////////////////////////////////////////////////////////////
// CSPPropertyGridItem

IMPLEMENT_DYNAMIC( CSPPropertyGridItem , CCmdTarget )

CSPPropertyGridItem::CSPPropertyGridItem( CString strCaption , LPCTSTR strValue , CString * pBindString )
{
	Init();
	SetPrompt( strCaption );
	m_strValue = strValue;

	BindToString( pBindString );
}


CSPPropertyGridItem::CSPPropertyGridItem( UINT nID , LPCTSTR strValue , CString * pBindString )
{
	Init();
	m_nID = nID;

	CString	strPrompt;
	if ( strPrompt.LoadString( nID ) )
	{
		SetPrompt( strPrompt );
	}

	m_strValue = strValue;
	BindToString( pBindString );
}

CSPPropertyGridItem::~CSPPropertyGridItem()
{
	if ( m_pGrid && m_pGrid->m_pSelected == this )
	{
		m_pGrid->m_pSelected = NULL;
	}

	m_pChilds->Clear();

	if ( GetInplaceButton().m_pItem == this )
	{
		GetInplaceButton().DestroyItem();
	}
	if ( GetInplaceList().m_pItem == this )
	{
		GetInplaceList().DestroyItem();
	}
	if ( GetInplaceEdit().m_pItem == this )
	{
		GetInplaceEdit().DestroyItem();
	}

	m_pChilds->InternalRelease();

	m_pConstraints->m_pItem = NULL;
	m_pConstraints->InternalRelease();
}

void CSPPropertyGridItem::SetPrompt( CString strText )
{
	int	nIndex	= strText.Find( '\n' );
	if ( nIndex == -1 )
	{
		m_strCaption = strText;
	}
	else
	{
		m_strCaption = strText.Left( nIndex );
		m_strDescription = strText.Mid( nIndex + 1 );
	}
}


void CSPPropertyGridItem::Init()
{
	m_bExpanded = FALSE;
	m_nIndex = -1;
	m_bVisible = FALSE;
	m_pParent = 0;
	m_pGrid = 0;
	m_nIndent = 0;
	m_strValue = "";
	m_bReadOnly = FALSE;
	m_bCategory = FALSE;
	m_nID = 0;
	m_nFlags = SPGridItemHasEdit;
	m_pConstraints = new CSPPropertyGridItemConstraints( this );
	m_pConstraints->SetCurrent( -1 );
	m_pBindString = 0;
	m_bConstraintEdit = FALSE;


	m_bUseMask = FALSE;
	m_bPassword = FALSE;
	m_chPrompt = _T( '*' );

	m_dwData = 0;

	EnableAutomation();



	m_pChilds = new CSPPropertyGridItems();
}

CSPPropertyGridItem * CSPPropertyGridItem::AddChildItem( CSPPropertyGridItem * pItem )
{
	return InsertChildItem( m_pChilds->GetCount(),pItem );
}

CSPPropertyGridItem * CSPPropertyGridItem::InsertChildItem( int nIndex , CSPPropertyGridItem * pItem )
{
	ASSERT( !pItem->IsCategory() || IsCategory() );

	if ( nIndex < 0 || nIndex > m_pChilds->GetCount() )
	{
		nIndex = m_pChilds->GetCount();
	}

	m_pChilds->InsertAt( nIndex,pItem );
	pItem->m_pGrid = pItem->m_pChilds->m_pGrid = m_pGrid;

	ASSERT( pItem->m_pParent == NULL );
	pItem->m_pParent = this;
	pItem->m_nIndent = m_nIndent + 1;

	pItem->OnAddChildItem();

	if ( m_bVisible )
	{
		if ( m_bExpanded )
		{
			m_pGrid->SetPropertySort( m_pGrid->m_properetySort,TRUE );
		}
		else if ( m_pGrid->GetSafeHwnd() && m_pChilds->GetCount() == 1 )
		{
			m_pGrid->Invalidate( FALSE );
		}
	}

	return pItem;
}

void CSPPropertyGridItem::Collapse()
{
	if ( !m_bExpanded )
	{
		return;
	}

	if ( m_pGrid->m_nLockUpdate == 0 )
	{
		if ( m_pGrid->GetSafeHwnd() && m_bVisible )
		{
			m_pGrid->_DoCollapse( this );
			m_pGrid->OnSelectionChanged();
		}
	}

	m_bExpanded = FALSE;

	if ( m_pGrid->GetSafeHwnd() )
	{
		m_pGrid->GetParent()->GetOwner()->SendMessage( SPWM_PROPERTYGRID_NOTIFY,SP_PGN_ITEMEXPANDCHANGED,( LPARAM )this );
	}
}

void CSPPropertyGridItem::Expand()
{
	if ( m_bExpanded )
	{
		return;
	}

	if ( m_pGrid->m_nLockUpdate == 0 )
	{
		if ( m_pGrid->GetSafeHwnd() && m_bVisible )
		{
			m_pGrid->_DoExpand( this,m_nIndex );
			m_pGrid->_RefreshIndexes();
			m_pGrid->OnSelectionChanged();
		}
	}

	m_bExpanded = TRUE;

	if ( m_pGrid->GetSafeHwnd() )
	{
		m_pGrid->GetParent()->GetOwner()->SendMessage( SPWM_PROPERTYGRID_NOTIFY,SP_PGN_ITEMEXPANDCHANGED,( LPARAM )this );
	}
}

BOOL CSPPropertyGridItem::HasParent( CSPPropertyGridItem * pParent )
{
	if ( m_pParent == NULL )
	{
		return FALSE;
	}
	if ( m_pParent == pParent )
	{
		return TRUE;
	}
	return m_pParent->HasParent( pParent );
}

void CSPPropertyGridItem::Select()
{
	ASSERT( m_pGrid );

	if ( m_bVisible )
	{
		m_pGrid->SetCurSel( m_nIndex );
		m_pGrid->OnSelectionChanged();
	}
}

void CSPPropertyGridItem::OnDeselect()
{
	GetInplaceButton().HideWindow();
	OnValidateEdit();
}

void CSPPropertyGridItem::OnValidateEdit()
{
	GetInplaceEdit().HideWindow();

	if ( GetInplaceEdit().GetSafeHwnd() && GetInplaceEdit().m_pItem == this )
	{
		CString	strValue;
		GetInplaceEdit().GetWindowText( strValue );

		if ( m_strValue != strValue )
		{
			OnValueChanged( strValue );
		}
	}
}

void CSPPropertyGridItem::SetEditText( CString str )
{
	if ( !m_pGrid )
	{
		return;
	}

	if ( GetInplaceEdit().GetSafeHwnd() && GetInplaceEdit().m_pItem == this )
	{
		GetInplaceEdit().SetWindowText( str );
	}
}

void CSPPropertyGridItem::SetValue( CString strValue )
{
	m_strValue = strValue;

	if ( m_pBindString )
	{
		*m_pBindString = strValue;
	}

	SetEditText( m_strValue );

	if ( m_pGrid && m_pGrid->m_hWnd )
	{
		m_pGrid->Invalidate( FALSE );
	}
}

void CSPPropertyGridItem::OnValueChanged( CString strValue )
{
	SetValue( strValue );
	m_pGrid->Invalidate( FALSE );
	m_pGrid->GetParent()->GetOwner()->SendMessage( SPWM_PROPERTYGRID_NOTIFY,SP_PGN_ITEMVALUE_CHANGED,( LPARAM )this );
}

void CSPPropertyGridItem::OnSelect()
{
	ASSERT( m_bVisible );

	if ( !m_bReadOnly && ( m_nFlags & ( SPGridItemHasComboButton | SPGridItemHasExpandButton ) ) )
	{
		GetInplaceButton().Create( this,GetItemRect() );
	}
	else
	{
		GetInplaceButton().HideWindow();
	}


	if ( m_nFlags & SPGridItemHasEdit )
	{
		GetInplaceEdit().SetValue( m_strValue );
		GetInplaceEdit().Create( this,GetValueRect() );
		GetInplaceEdit().SetReadOnly( m_bReadOnly );
	}
	else
	{
		GetInplaceEdit().HideWindow();
	}
}

void CSPPropertyGridItem::OnInplaceButtonDown()
{
	if ( GetReadOnly() )
	{
		return;
	}

	if ( m_pGrid->GetParent()->GetOwner()->SendMessage( SPWM_PROPERTYGRID_NOTIFY,SP_PGN_INPLACEBUTTONDOWN,( LPARAM )this ) == TRUE )
	{
		return;
	}

	if ( ( m_nFlags & SPGridItemHasComboButton ) && !m_pConstraints->IsEmpty() )
	{
		GetInplaceList().Create( this,GetItemRect() );
		m_pGrid->Invalidate( FALSE );
	}
}

CRect CSPPropertyGridItem::GetValueRect()
{
	ASSERT( m_bVisible );
	CRect	rc		= GetItemRect();
	CRect	rcValue	( m_pGrid->GetDividerPos() + 1,rc.top + 1,rc.right,rc.bottom - 1 );
	if ( m_nFlags & ( SPGridItemHasComboButton | SPGridItemHasExpandButton ) )
	{
		if ( GetInplaceButton().m_pItem == this && GetInplaceButton().GetStyle() & WS_VISIBLE )
		{
			rcValue.right -= GetSystemMetrics( SM_CXHTHUMB );
		}
	}

	return rcValue;
}

CRect CSPPropertyGridItem::GetItemRect()
{
	CRect	rc;
	m_pGrid->GetItemRect( m_nIndex,rc );
	return rc;
}

BOOL CSPPropertyGridItem::OnChar( UINT nChar )
{
	ASSERT( nChar != VK_TAB );

	if ( m_nFlags & SPGridItemHasEdit )
	{
		OnSelect();
		GetInplaceEdit().SetFocus();
		GetInplaceEdit().SetSel( 0,-1 );
		if ( nChar != VK_TAB )
			GetInplaceEdit().SendMessage( WM_CHAR,nChar );
		return TRUE;
	}
	else if ( nChar == VK_TAB )
	{
		CSPPropertyGridInplaceButton& wndButton	= GetInplaceButton();
		if ( wndButton.GetSafeHwnd() && wndButton.IsWindowVisible() && wndButton.GetItem() == this )
		{
			wndButton.SetFocus();
		}
	}
	return FALSE;
}

void CSPPropertyGridItem::OnLButtonDblClk()
{
	if ( HasChilds() )
	{
		if ( m_bExpanded )
		{
			Collapse();
		}
		else
		{
			Expand();
		}
	}
	else
	{
		OnSelect();
		if ( m_nFlags & SPGridItemHasEdit )
		{
			if ( !GetReadOnly() && GetInplaceEdit().SelectConstraint( +1,TRUE ) )
			{
				OnValidateEdit();
			}
			else
			{
				GetInplaceEdit().SetFocus();
				GetInplaceEdit().SetSel( 0,-1 );
			}
		}
		else if ( !GetReadOnly() )
		{
			CSPPropertyGridItemConstraints *pList	= GetConstraints();
			if ( pList->IsEmpty() )
				return ;

			int	nIndex	= pList->FindConstraint( m_strValue );

			nIndex += +1;
			if ( nIndex >= pList->GetCount() )
				nIndex = 0;
			if ( nIndex < 0 )
				nIndex = ( ULONG ) pList->GetCount() - 1;

			pList->SetCurrent( nIndex );
			OnValueChanged( pList->GetAt( nIndex ) );
		}
	}
}

BOOL CSPPropertyGridItem::OnLButtonDown( UINT , CPoint point )
{
	Select();

	int	nOffset	= ( m_nIndent - ( IsCategory() ? 0 : 1 ) ) * SP_PGI_EXPAND_BORDER;

	if ( point.x >= nOffset && point.x <= SP_PGI_EXPAND_BORDER + nOffset )
	{
		if ( m_bExpanded )
		{
			Collapse();
		}
		else
		{
			Expand();
		}
	}

	CRect	rc	= GetValueRect();
	if ( ( m_nFlags & SPGridItemHasEdit ) && rc.PtInRect( point ) )
	{
		mouse_event( GetSystemMetrics( SM_SWAPBUTTON ) ? MOUSEEVENTF_RIGHTDOWN : MOUSEEVENTF_LEFTDOWN,0,0,0,0 );
	}

	return TRUE;
}

void CSPPropertyGridItem::BindToString( CString * pBindString )
{
	m_pBindString = pBindString;
	if ( m_pBindString )
	{
		*m_pBindString = m_strValue;
	}
}

void CSPPropertyGridItem::OnBeforeInsert()
{
	if ( m_pBindString && *m_pBindString != m_strValue )
	{
		m_strValue = *m_pBindString;
	}
}

CSPPropertyGridInplaceEdit & CSPPropertyGridItem::GetInplaceEdit()
{
	if ( m_pGrid )
	{
		return m_pGrid->m_wndEdit;
	}

	static CSPPropertyGridInplaceEdit	wndEdit;
	return wndEdit;
}
CSPPropertyGridInplaceButton & CSPPropertyGridItem::GetInplaceButton()
{
	if ( m_pGrid )
	{
		return m_pGrid->m_wndButton;
	}

	static CSPPropertyGridInplaceButton	wndButton;
	return wndButton;
}
CSPPropertyGridInplaceList & CSPPropertyGridItem::GetInplaceList()
{
	if ( m_pGrid )
	{
		return m_pGrid->m_wndListBox;
	}

	static CSPPropertyGridInplaceList	wndListBox;
	return wndListBox;
}



// Deletes the item.
void CSPPropertyGridItem::Remove()
{
	CSPPropertyGridItems *	pItems	= GetParentItem() == 0 ? m_pGrid->m_pCategories : GetParentItem()->m_pChilds;
	ASSERT( pItems );

	pItems->m_arrItems.RemoveAt( pItems->Find( this ) );
	m_pGrid->Refresh();

	InternalRelease();
}

BOOL CSPPropertyGridItem::IsSelected()
{
	return m_pGrid && m_pGrid->GetSelectedItem() == this;
}

void CSPPropertyGridItem::Refresh( BOOL bInvalidate /*= TRUE*/ )
{
	if ( m_pGrid && m_pGrid->GetSafeHwnd() )
	{
		if ( IsSelected() )
		{
			OnDeselect();
			OnSelect();
		}
		if ( bInvalidate )
		{
			m_pGrid->Invalidate( FALSE );
		}
	}
}

void CSPPropertyGridItem::SetReadOnly( BOOL bReadOnly )
{
	if ( m_bReadOnly != bReadOnly )
	{
		m_bReadOnly = bReadOnly;
		Refresh( TRUE );
	}
}

void CSPPropertyGridItem::SetMask( LPCTSTR strMask , LPCTSTR strLiteral , TCHAR chPrompt /*= _T('_')*/ )
{
	m_bUseMask = TRUE;
	m_strMask = strMask;
	m_strLiteral = strLiteral;
	m_chPrompt = chPrompt;
	Refresh( FALSE );
}

CString CSPPropertyGridItem::GetViewValue()
{
	CString	str	= GetValue();
	if ( m_bPassword )
	{
		return CString( m_chPrompt,str.GetLength() );
	}
	return str;
}

CString CSPPropertyGridItem::GetMaskedText()
{
	if ( m_bUseMask )
	{
		int		nLength	= m_strValue.GetLength();

		CString	strBuffer;
		for ( int i = 0; i < nLength; ++i )
		{
			if ( m_strLiteral[i] == m_chPrompt )
			{
				strBuffer += m_strValue.GetAt( i );
			}
		}

		return strBuffer;
	}
	else
	{
		return m_strValue;
	}
}

void CSPPropertyGridItem::SetMaskedText( LPCTSTR lpszMaskedText )
{
	CString	strMaskedText	= lpszMaskedText;

	if ( m_bUseMask )
	{
		int	nLen	= strMaskedText.GetLength();
		int	x		= 0;

		m_strValue = m_strLiteral;

		for ( int i = 0; ( i < m_strValue.GetLength() ) && ( x < nLen ); i++ )
		{
			if ( strMaskedText[x] == m_strValue[i] )
			{
				x ++;
			}
			else if ( m_strValue[i] == m_chPrompt )
			{
				m_strValue.SetAt( i,strMaskedText[x] );
				x ++;
			}
		}
	}
	else
	{
		m_strValue = strMaskedText;
	}

	SetValue( m_strValue );
}

void CSPPropertyGridItem::SetDescription( LPCTSTR lpszDescription )
{
	m_strDescription = lpszDescription;
	if ( IsSelected() )
	{
		GetGrid()->GetParent()->Invalidate( FALSE );
	}
}



/////////////////////////////////////////////////////////////////////////////
// CSPPropertyGridItems

CSPPropertyGridItems::CSPPropertyGridItems()
{
	m_pGrid = 0;
}

void CSPPropertyGridItems::Clear()
{
	if ( m_pGrid )
	{
		if ( m_pGrid->m_nLockUpdate == 0 )
			m_pGrid->ResetContent();
		m_pGrid->m_nLockUpdate++;
	}

	for ( int i = 0; i < GetCount(); i++ )
	{
		m_arrItems[i]->InternalRelease();
	}
	m_arrItems.RemoveAll();

	if ( m_pGrid )
	{
		m_pGrid->m_nLockUpdate--;
		if ( m_pGrid->m_nLockUpdate == 0 )
			m_pGrid->Refresh();
	}
}

CSPPropertyGridItem * CSPPropertyGridItems::GetAt( int nIndex )
{
	if ( nIndex >= 0 && nIndex < GetCount() )
	{
		return m_arrItems.GetAt( nIndex );
	}
	return 0;
}

void CSPPropertyGridItems::RemoveAt( int nIndex )
{
	ASSERT( m_pGrid );

	CSPPropertyGridItem *	pItem	= GetAt( nIndex );

	if ( pItem )
	{
		m_arrItems.RemoveAt( nIndex );
		m_pGrid->Refresh();

		pItem->InternalRelease();
	}
}

int CSPPropertyGridItems::Find( CSPPropertyGridItem * pItem )
{
	for ( int i = 0; i < GetCount(); i++ )
	{
		if ( m_arrItems[i] == pItem )
		{
			return i;
		}
	}
	return -1;
}


void CSPPropertyGridItems::AddTail( CSPPropertyGridItems * pItems )
{
	ASSERT( this != pItems );

	for ( int i = 0; i < pItems->GetCount(); i++ )
	{
		AddTail( pItems->GetAt( i ) );
	}
}

int CSPPropertyGridItems::CompareFunc( const CSPPropertyGridItem ** ppItem1 , const CSPPropertyGridItem ** ppItem2 )
{
	return ( *ppItem1 )->GetCaption().Compare( ( *ppItem2 )->GetCaption() );
}

void CSPPropertyGridItems::Sort()
{
	typedef int ( _cdecl *GENERICCOMPAREFUNC )( const void * , const void * );

	qsort( m_arrItems.GetData(),m_arrItems.GetSize(),sizeof( CSPPropertyGridItem * ),( GENERICCOMPAREFUNC ) CompareFunc );
}

CSPPropertyGridItem * CSPPropertyGridItems::FindItem( CString strCaption )
{
	for ( int i = 0; i < GetCount(); i++ )
	{
		CSPPropertyGridItem *	pItem	= GetAt( i );
		if ( pItem->GetCaption() == strCaption )
			return pItem;

		CSPPropertyGridItem *	pChild	= pItem->m_pChilds->FindItem( strCaption );
		if ( pChild )
			return pChild;
	}
	return NULL;
}

CSPPropertyGridItem * CSPPropertyGridItems::FindItem( UINT nID )
{
	for ( int i = 0; i < GetCount(); i++ )
	{
		CSPPropertyGridItem *	pItem	= GetAt( i );
		if ( pItem->GetID() == nID )
			return pItem;

		CSPPropertyGridItem *	pChild	= pItem->m_pChilds->FindItem( nID );
		if ( pChild )
			return pChild;
	}
	return NULL;
}



//////////////////////////////////////////////////////////////////////////
// CSPPropertyGridItemConstraint
CSPPropertyGridItemConstraint::CSPPropertyGridItemConstraint()
{
	m_nIndex = 0;
	m_dwData = 0;
}
/////////////////////////////////////////////////////////////////////////////
// CSPPropertyGridItemConstraints

// Summary: Constructs a CSPPropertyGridItemConstraints object
CSPPropertyGridItemConstraints::CSPPropertyGridItemConstraints( CSPPropertyGridItem * pItem )
{
	m_pItem = pItem;
}

CSPPropertyGridItemConstraints::~CSPPropertyGridItemConstraints()
{
	RemoveAll();
}

CSPPropertyGridItemConstraint * CSPPropertyGridItemConstraints::AddConstraint( CString str , DWORD dwData )
{
	CSPPropertyGridItemConstraint *	pConstaint	= new CSPPropertyGridItemConstraint();

	pConstaint->m_strConstraint = str;
	pConstaint->m_dwData = dwData;
	pConstaint->m_nIndex = ( int ) m_arrConstraints.Add( pConstaint );

	SAFE_CALLPTR( m_pItem,OnConstraintsChanged() );

	return pConstaint;
}

CString CSPPropertyGridItemConstraints::GetAt( int nIndex )
{
	return nIndex >= 0 && nIndex < GetCount() ? m_arrConstraints.GetAt( nIndex )->m_strConstraint : _T( "" );
}

void CSPPropertyGridItemConstraints::RemoveAll()
{
	for ( int i = 0; i < GetCount(); i++ )
	{
		m_arrConstraints[i]->InternalRelease();
	}
	m_arrConstraints.RemoveAll();

	SAFE_CALLPTR( m_pItem,OnConstraintsChanged() );
}

void CSPPropertyGridItemConstraints::RemoveAt( int nIndex )
{
	m_arrConstraints[nIndex]->InternalRelease();
	m_arrConstraints.RemoveAt( nIndex );

	for ( int i = nIndex; i < GetCount(); i++ )
	{
		m_arrConstraints[i]->m_nIndex = i;
	}

	SAFE_CALLPTR( m_pItem,OnConstraintsChanged() );
}

int CSPPropertyGridItemConstraints::FindConstraint( CString str )
{
	for ( int i = 0; i < GetCount(); i++ )
	{
		if ( str == GetAt( i ) )
		{
			return i;
		}
	}
	return -1;
}

int CSPPropertyGridItemConstraints::FindConstraint( DWORD dwData )
{
	for ( int i = 0; i < GetCount(); i++ )
	{
		if ( dwData == GetConstraintAt( i )->m_dwData )
		{
			return i;
		}
	}
	return -1;
}

CSPPropertyGridItemConstraint * CSPPropertyGridItemConstraints::GetConstraintAt( int nIndex )
{
	return m_arrConstraints[nIndex];
}

int CSPPropertyGridItemConstraints::CompareFunc( const CSPPropertyGridItemConstraint ** ppConstraint1 , const CSPPropertyGridItemConstraint ** ppConstraint2 )
{
	return ( *ppConstraint1 )->m_strConstraint.Compare( ( *ppConstraint2 )->m_strConstraint );
}

void CSPPropertyGridItemConstraints::Sort()
{
	typedef int ( _cdecl *GENERICCOMPAREFUNC )( const void * , const void * );

	qsort( m_arrConstraints.GetData(),( size_t ) m_arrConstraints.GetSize(),sizeof( CSPPropertyGridItemConstraint * ),( GENERICCOMPAREFUNC ) CompareFunc );
}


//////////////////////////////////////////////////////////////////////////
// CSPPropertyGridItemCategory

CSPPropertyGridItemCategory::CSPPropertyGridItemCategory( CString strCaption ) : CSPPropertyGridItem( strCaption )
{
	m_bCategory = TRUE;
	m_nFlags = 0;
}

CSPPropertyGridItemCategory::CSPPropertyGridItemCategory( UINT nID ) : CSPPropertyGridItem( nID )
{
	m_bCategory = TRUE;
	m_nFlags = 0;
}





///////////////////////////////////////////////////////////////////////////////////
//  Acteve X Methods
//