Smart Grid

// ManageData.cpp : Implementation of CManageData
#include "stdafx.h"
#include "AlxGrd.h"
#include "SmartGrid.h"
#include "ManageData.h"
#include "Common.h"

/////////////////////////////////
//	CSmartEdit
/////////////////////////////////
CSmartEdit::CSmartEdit( CManageData* pManageData ) : 
					m_wndEditWindow( _T("EDIT"), this, 1 )
{
	m_pManageData = pManageData;
}

void 
CSmartEdit::SetText( CComBSTR& bstrText )
{
	_ASSERTE( m_wndEditWindow.IsWindow() );

	USES_CONVERSION;
	
	m_wndEditWindow.SetWindowText( OLE2T( bstrText ) );
}

CComBSTR 
CSmartEdit::GetText()
{
	CComBSTR bstrText;
	m_wndEditWindow.GetWindowText( bstrText.m_str );
	return bstrText;
}

LRESULT 
CSmartEdit::OnRButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	POINT ptMouse = { LOWORD( lParam ), HIWORD( lParam ) };

	RECT rcClient;
	GetClientRect( &rcClient );

	if( ::PtInRect(  &rcClient, ptMouse ) )
		bHandled = FALSE;

	return 0;
}

LRESULT 
CSmartEdit::OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	POINT ptMouse = { LOWORD( lParam ), HIWORD( lParam ) };

	RECT rcClient;
	GetClientRect( &rcClient );

	_ASSERTE( GetCapture() == m_wndEditWindow.m_hWnd );

	if( !::PtInRect(  &rcClient, ptMouse ) )
	{
		HWND hWndParent = GetParent();
		ClientToScreen( &ptMouse );
		::ScreenToClient( hWndParent, &ptMouse );

		ReleaseCapture();
	}

	return 0;
}

LRESULT 
CSmartEdit::OnRButtonDblClk(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	POINT ptMouse = { LOWORD( lParam ), HIWORD( lParam ) };

	RECT rcClient;
	GetClientRect( &rcClient );

	if( ::PtInRect(  &rcClient, ptMouse ) )
		bHandled = FALSE;

	return 0;
}

LRESULT 
CSmartEdit::OnLButtonDblClk(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	POINT ptMouse = { LOWORD( lParam ), HIWORD( lParam ) };

	/*
	RECT rcClient;
	GetClientRect( &rcClient );

	if( ::PtInRect(  &rcClient, ptMouse ) )
		bHandled = FALSE;
	*/

	return 0;
}

LRESULT 
CSmartEdit::OnCaptureChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{	
	ATLTRACE( _T("Capture changed\n" ) );
	m_pManageData->UpdateChanges();
	return 0;
}

LRESULT 
CSmartEdit::OnCtlColorEdit(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{	
	static HBRUSH hBrush = NULL;
	if( hBrush != NULL )
	{
		::DeleteObject( hBrush );
		hBrush = NULL;
	}

	OLE_COLOR clrTmp = RGB(255,255,255);
	m_pManageData->m_pSmartGrid->get_ContentBkColor( &clrTmp );

	hBrush = ::CreateSolidBrush( clrTmp );

	return reinterpret_cast< LRESULT >( hBrush );
}

LRESULT 
CSmartEdit::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	bHandled = FALSE;
	return 0;
}

LRESULT 
CSmartEdit::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	RECT rcClient;
	GetClientRect( &rcClient );
	rcClient.right -= rcClient.left;
	rcClient.bottom -= rcClient.top;
	m_wndEditWindow.Create( m_hWnd, rcClient, NULL, WS_CHILD | ES_AUTOHSCROLL | WS_VISIBLE, WS_EX_CLIENTEDGE );
	m_wndEditWindow.SetFocus();
	m_wndEditWindow.SetCapture();

	// Set properties of the edit control

	CComPtr< IFontDisp > m_spFontDisp = static_cast< IFontDisp* >( NULL );	
	m_pManageData->m_pSmartGrid->get_Font( &m_spFontDisp );
	HFONT hFont = NULL;
	CComQIPtr< IFont >( m_spFontDisp )->get_hFont( &hFont );
	m_wndEditWindow.SendMessage( WM_SETFONT, reinterpret_cast< WPARAM >( hFont ), 0 );

	return 0;
}

BOOL 
CSmartEdit::PreTranslateAccelerator(LPMSG pMsg, HRESULT& hRet)
{
	if(pMsg->message == WM_KEYDOWN && 
		(pMsg->wParam == VK_LEFT || 
		pMsg->wParam == VK_RIGHT ||
		pMsg->wParam == VK_UP ||
		pMsg->wParam == VK_DOWN))
	{
		hRet = S_FALSE;
		return TRUE;
	}
	
	//TODO: Add your additional accelerator handling code here

	return FALSE;
}


LRESULT 
CSmartEdit::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	RECT rcClient;
	GetClientRect( &rcClient );
	m_wndEditWindow.MoveWindow( &rcClient );
	return 0;
}

LRESULT 
CSmartEdit::OnKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	HWND hParent = GetParent();

	switch( wParam )
	{
	case VK_UP:
	case VK_DOWN:
		
		{			
			m_pManageData->UpdateChanges();
			::PostMessage( hParent, uMsg, wParam, lParam );	
		}
		break;
	
	case VK_RETURN:		
		{			
			m_pManageData->UpdateChanges();
		}
		break;

	case VK_TAB:
		{			
			m_pManageData->UpdateChanges();
			if( GetKeyState( VK_SHIFT ) & 0x8000 )
				::PostMessage( hParent, WM_KEYDOWN, VK_LEFT, 0 );
			else
				::PostMessage( hParent, WM_KEYDOWN, VK_RIGHT, 0 );
		}
		break;

	case VK_ESCAPE:
		{
			//ReleaseCapture();
			m_pManageData->CancelEditing();
		}
		break;

	default:
		{
			m_wndEditWindow.DefWindowProc( uMsg, wParam, lParam );			
		}
		break;
	
	}

	return 0;
}


/////////////////////////////////
//	CSmartChoice
/////////////////////////////////
CSmartChoice::CSmartChoice( CManageData* pManageData, BOOL bStrict ) : 
					m_wndEditWindow( _T("COMBOBOX"), this, 1 )
{
	m_bStrict = bStrict;
	m_pManageData = pManageData;
}

void 
CSmartChoice::SetText( CComBSTR& bstrText )
{
	_ASSERTE( m_wndEditWindow.IsWindow() );

	USES_CONVERSION;
	
	m_wndEditWindow.SetWindowText( OLE2T( bstrText ) );
}

void 
CSmartChoice::AddItem( CComBSTR& bstrItem )
{
	_ASSERTE( m_wndEditWindow.IsWindow() );

	USES_CONVERSION;
	
	m_wndEditWindow.SendMessage( CB_ADDSTRING, 0, reinterpret_cast< LPARAM >( const_cast< TCHAR* >( OLE2T( bstrItem ) ) ) );
}


void 
CSmartChoice::SelectItem( CComBSTR& bstrText )
{
	_ASSERTE( m_wndEditWindow.IsWindow() );

	USES_CONVERSION;
	
	m_wndEditWindow.SendMessage( CB_SELECTSTRING, -1, reinterpret_cast< LPARAM >( const_cast< TCHAR* >( OLE2T( bstrText ) ) ) );
}

void 
CSmartChoice::ShowDropDown( BOOL bShow )
{
	m_wndEditWindow.SendMessage( CB_SHOWDROPDOWN, bShow );
}

CComBSTR 
CSmartChoice::GetText()
{
	CComBSTR bstrText;
	m_wndEditWindow.GetWindowText( bstrText.m_str );
	return bstrText;
}

LRESULT 
CSmartChoice::OnRButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	POINT ptMouse = { LOWORD( lParam ), HIWORD( lParam ) };

	RECT rcClient;
	GetClientRect( &rcClient );

	if( ::PtInRect(  &rcClient, ptMouse ) )
		bHandled = FALSE;

	return 0;
}

LRESULT 
CSmartChoice::OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	POINT ptMouse = { LOWORD( lParam ), HIWORD( lParam ) };

	RECT rcClient;
	GetClientRect( &rcClient );

	//_ASSERTE( GetCapture() == m_wndEditWindow.m_hWnd );
	m_wndEditWindow.SetCapture();

	if( !::PtInRect(  &rcClient, ptMouse ) )
	{
		HWND hWndParent = GetParent();
		ClientToScreen( &ptMouse );
		::ScreenToClient( hWndParent, &ptMouse );

		ReleaseCapture();
	}

	return 0;
}

LRESULT 
CSmartChoice::OnRButtonDblClk(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	POINT ptMouse = { LOWORD( lParam ), HIWORD( lParam ) };

	RECT rcClient;
	GetClientRect( &rcClient );

	if( ::PtInRect(  &rcClient, ptMouse ) )
		bHandled = FALSE;

	return 0;
}

LRESULT 
CSmartChoice::OnLButtonDblClk(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	POINT ptMouse = { LOWORD( lParam ), HIWORD( lParam ) };

	/*
	RECT rcClient;
	GetClientRect( &rcClient );

	if( ::PtInRect(  &rcClient, ptMouse ) )
		bHandled = FALSE;
	*/

	return 0;
}

LRESULT 
CSmartChoice::OnCaptureChanged(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{				
	return 0;
}

LRESULT 
CSmartChoice::OnEraseBkgnd(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{				
	HDC hDC = reinterpret_cast< HDC >( wParam );

	OLE_COLOR clrTmp;
	m_pManageData->m_pSmartGrid->get_ActiveRowColor( &clrTmp );

	CGDIObject< HBRUSH > gdiBrush( ::CreateSolidBrush( clrTmp ) );

	CSaveDC ctxDC( hDC );

	RECT rcClient;
	GetClientRect( &rcClient );
	::FillRect( hDC, &rcClient, gdiBrush );

	return 0;
}

LRESULT 
CSmartChoice::OnCtlColorEdit(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{	
	static HBRUSH hBrush = NULL;
	if( hBrush != NULL )
	{
		::DeleteObject( hBrush );
		hBrush = NULL;
	}

	OLE_COLOR clrTmp = RGB(255,255,255);
	m_pManageData->m_pSmartGrid->get_ContentBkColor( &clrTmp );

	hBrush = ::CreateSolidBrush( clrTmp );

	return reinterpret_cast< LRESULT >( hBrush );
}

LRESULT 
CSmartChoice::OnCtlColorListBox(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{	
	static HBRUSH hBrush = NULL;
	if( hBrush != NULL )
	{
		::DeleteObject( hBrush );
		hBrush = NULL;
	}

	OLE_COLOR clrTmp = RGB(255,255,255);
	m_pManageData->m_pSmartGrid->get_ContentBkColor( &clrTmp );

	hBrush = ::CreateSolidBrush( clrTmp );

	return reinterpret_cast< LRESULT >( hBrush );
}


LRESULT 
CSmartChoice::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	bHandled = FALSE;
	return 0;
}

LRESULT 
CSmartChoice::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	RECT rcClient;
	GetClientRect( &rcClient );
	rcClient.right -= rcClient.left;
	rcClient.bottom -= rcClient.top;
	m_wndEditWindow.Create( m_hWnd, rcClient, NULL, WS_CHILD | WS_VISIBLE | WS_VSCROLL | CBS_AUTOHSCROLL | ( m_bStrict?CBS_DROPDOWNLIST:CBS_DROPDOWN ) );
	m_wndEditWindow.SetFocus();
	m_wndEditWindow.SetCapture();

	// Set properties of the edit control

	CComPtr< IFontDisp > m_spFontDisp = static_cast< IFontDisp* >( NULL );	
	m_pManageData->m_pSmartGrid->get_Font( &m_spFontDisp );
	HFONT hFont = NULL;
	CComQIPtr< IFont >( m_spFontDisp )->get_hFont( &hFont );
	m_wndEditWindow.SendMessage( WM_SETFONT, reinterpret_cast< WPARAM >( hFont ), 0 );

	return 0;
}

BOOL 
CSmartChoice::PreTranslateAccelerator(LPMSG pMsg, HRESULT& hRet)
{
	if(pMsg->message == WM_KEYDOWN && 
		(pMsg->wParam == VK_LEFT || 
		pMsg->wParam == VK_RIGHT ||
		pMsg->wParam == VK_UP ||
		pMsg->wParam == VK_DOWN))
	{
		hRet = S_FALSE;
		return TRUE;
	}
	
	//TODO: Add your additional accelerator handling code here

	return FALSE;
}


LRESULT 
CSmartChoice::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	RECT rcClient;
	GetClientRect( &rcClient );
	rcClient.bottom = rcClient.top + 100;
	m_wndEditWindow.MoveWindow( &rcClient );
	return 0;
}

LRESULT 
CSmartChoice::OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	if( lParam == reinterpret_cast< LPARAM >( m_wndEditWindow.m_hWnd ) )
	{
		switch( HIWORD( wParam ) )
		{
		case CBN_SELENDOK:
			{
				long nIndex = m_wndEditWindow.SendMessage( CB_GETCURSEL );
				if( nIndex != CB_ERR )
					m_wndEditWindow.SendMessage( CB_SETCURSEL, nIndex );
				m_pManageData->UpdateChanges();
				return 0;
			}
		case CBN_SELENDCANCEL:
			{
				m_pManageData->CancelEditing();
			}
		}
	}

	bHandled = FALSE;

	return 0;
}


LRESULT 
CSmartChoice::OnKeyDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
	HWND hParent = GetParent();

	switch( wParam )
	{	
	case VK_RETURN:		
		{			
			m_pManageData->UpdateChanges();
		}
		break;

	case VK_TAB:
		{	
			m_pManageData->UpdateChanges();
			if( GetKeyState( VK_SHIFT ) & 0x8000 )
				::PostMessage( hParent, WM_KEYDOWN, VK_LEFT, 0 );
			else
				::PostMessage( hParent, WM_KEYDOWN, VK_RIGHT, 0 );
		}
		break;

	case VK_ESCAPE:
		{			
			m_pManageData->CancelEditing();
		}
		break;

	default:
		{
			m_wndEditWindow.DefWindowProc( uMsg, wParam, lParam );			
		}
		break;
	
	}

	return 0;
}


/////////////////////////////////////////////////////////////////////////////
// CManageData

long CManageData::m_nImageWidth = 10;
long CManageData::m_nImageHeight = 10;

CManageData::CManageData() :
	m_wndSmartEdit( this ), m_wndOption( this ), m_wndStrictOption( this, TRUE )
{
	m_hbmpChk_Checked = m_hbmpChk_UnChecked = NULL;
	m_pSmartGrid = NULL;

	m_hbmpChk_Checked = static_cast< HBITMAP >( ::LoadImage( _Module.GetResourceInstance(), MAKEINTRESOURCE( IDB_CHK_CHECKED ), IMAGE_BITMAP, m_nImageWidth, m_nImageHeight, 0 ) );
	m_hbmpChk_UnChecked = static_cast< HBITMAP >( ::LoadImage( _Module.GetResourceInstance(), MAKEINTRESOURCE( IDB_CHK_UNCHECKED ), IMAGE_BITMAP, m_nImageWidth, m_nImageHeight, 0 ) );
	m_hbmpUnknown = static_cast< HBITMAP >( ::LoadImage( _Module.GetResourceInstance(), MAKEINTRESOURCE( IDB_DT_UNKNOWN ), IMAGE_BITMAP, m_nImageWidth, m_nImageHeight, 0 ) );
	m_hbmpNull = static_cast< HBITMAP >( ::LoadImage( _Module.GetResourceInstance(), MAKEINTRESOURCE( IDB_DT_NULL ), IMAGE_BITMAP, m_nImageWidth, m_nImageHeight, 0 ) );
	m_hbmpObject = static_cast< HBITMAP >( ::LoadImage( _Module.GetResourceInstance(), MAKEINTRESOURCE( IDB_DT_OBJECT ), IMAGE_BITMAP, m_nImageWidth, m_nImageHeight, 0 ) );
}

CManageData::~CManageData()
{
	if( m_hbmpChk_Checked )
		::DeleteObject( m_hbmpChk_Checked );
	if( m_hbmpChk_UnChecked )
		::DeleteObject( m_hbmpChk_UnChecked );
	if( m_hbmpUnknown )
		::DeleteObject( m_hbmpUnknown );
	if( m_hbmpNull )
		::DeleteObject( m_hbmpNull );
	if( m_hbmpObject )
		::DeleteObject( m_hbmpObject );
}

void 
CManageData::UpdateChanges()
{
	if( m_pEditFunction != NULL )
	{
		( this->*m_pEditFunction )( EditState_Update );
		m_pEditFunction = NULL;

		m_pSmartGrid->Event_EndCellEdit( m_pSmartGrid->m_posEditedCell.first, m_pSmartGrid->m_posEditedCell.second );

		m_pSmartGrid->Event_CellUpdated( m_pSmartGrid->m_posEditedCell.first, m_pSmartGrid->m_posEditedCell.second );	
	}

	ATLTRACE( _T("UpdateChanges\n") );
}

void 
CManageData::CancelEditing()
{
	if( m_pEditFunction != NULL )
	{
		( this->*m_pEditFunction)( EditState_Cancel );
		m_pEditFunction = NULL;

		m_pSmartGrid->Event_EndCellEdit( m_pSmartGrid->m_posEditedCell.first, m_pSmartGrid->m_posEditedCell.second );
	}	

	ATLTRACE( _T("CancelEditing\n") );
}

void
CManageData::Draw_Bool( unsigned char val, HDC hDC, RECT& rcBounds )
{
	CGDIObject< HDC > gdiTmpDC( ::CreateCompatibleDC( hDC ) );

	CSaveDC ctxTmpDC( gdiTmpDC );

	::SelectObject( gdiTmpDC, ( val?m_hbmpChk_Checked:m_hbmpChk_UnChecked ) );
	::BitBlt( hDC, ( rcBounds.left + rcBounds.right - m_nImageWidth ) / 2, ( rcBounds.top + rcBounds.bottom - m_nImageHeight ) / 2, m_nImageWidth, m_nImageHeight, gdiTmpDC, 0, 0, SRCCOPY );
}

void
CManageData::Draw_Integer( long val, HDC hDC, RECT& rcBounds )
{
	CSaveDC ctxDC( hDC );
	
	::SetTextColor( hDC, RGB(0,0,0) );

	static TCHAR szBuffer[256];
	wsprintf( szBuffer, _T("%d"), val );

	::DrawText( hDC, szBuffer, -1, &rcBounds, DT_SINGLELINE | DT_VCENTER | DT_RIGHT );
}

void
CManageData::Draw_Real( long double val, HDC hDC, RECT& rcBounds )
{
	USES_CONVERSION;

	CSaveDC ctxDC( hDC );
	
	::SetTextColor( hDC, RGB(0,0,0) );

	static char szBuffer[256];
	sprintf( szBuffer, _T("%lf"), val );

	::DrawText( hDC, A2T(szBuffer), -1, &rcBounds, DT_SINGLELINE | DT_VCENTER | DT_RIGHT );
}

void
CManageData::Draw_Code( long val, HDC hDC, RECT& rcBounds )
{
	USES_CONVERSION;

	CSaveDC ctxDC( hDC );
	
	::SetTextColor( hDC, RGB(0,0,0) );

	static char szBuffer[256];
	sprintf( szBuffer, _T("%d"), val );

	::DrawText( hDC, A2T(szBuffer), -1, &rcBounds, DT_SINGLELINE | DT_VCENTER | DT_RIGHT );
}

void
CManageData::Draw_Currency( CY val, HDC hDC, RECT& rcBounds )
{
	USES_CONVERSION;

	CSaveDC ctxDC( hDC );
	
	::SetTextColor( hDC, RGB(0,0,0) );

	CComVariant varTmp( val );
	varTmp.ChangeType( VT_R8 );

	static TCHAR szBuffer[256];
	sprintf( szBuffer, "%.4lf", varTmp.dblVal );
	string strTmp( szBuffer );
	strcpy( szBuffer, strTmp.c_str() );
	::DrawText( hDC, A2T( szBuffer ), -1, &rcBounds, DT_SINGLELINE | DT_VCENTER | DT_RIGHT );
}

void
CManageData::Draw_Date( DATE val, HDC hDC, RECT& rcBounds )
{
	USES_CONVERSION;

	struct tm t;
	
	::OleDate2Tm( val, t );

	char szBuffer[256];

	if( t.tm_hour != 0 || t.tm_min != 0 || t.tm_sec != 0 )		
		sprintf( szBuffer, "%d/%d/%d %d:%d:%d", t.tm_mday, t.tm_mon, t.tm_year, t.tm_hour, t.tm_min, t.tm_sec );
	else
		sprintf( szBuffer, "%d/%d/%d", t.tm_mday, t.tm_mon, t.tm_year );

	CSaveDC ctxDC( hDC );
	
	::SetTextColor( hDC, RGB(0,0,0) );
	
	::DrawText( hDC, A2T( szBuffer ), -1, &rcBounds, DT_SINGLELINE | DT_VCENTER | DT_RIGHT );
}

void
CManageData::Draw_String( BSTR val, HDC hDC, RECT& rcBounds )
{
	USES_CONVERSION;

	CSaveDC ctxDC( hDC );
	
	::SetTextColor( hDC, RGB(0,0,0) );

	::DrawText( hDC, OLE2T( val ), -1, &rcBounds, DT_SINGLELINE | DT_VCENTER | DT_LEFT );
}

void
CManageData::Draw_Object( CComPtr< IUnknown > val, HDC hDC, RECT& rcBounds )
{	
	CGDIObject< HDC > gdiTmpDC( ::CreateCompatibleDC( hDC ) );

	CSaveDC ctxTmpDC( gdiTmpDC );

	::SelectObject( gdiTmpDC, m_hbmpObject );
	::BitBlt( hDC, ( rcBounds.left + rcBounds.right - m_nImageWidth ) / 2, ( rcBounds.top + rcBounds.bottom - m_nImageHeight ) / 2, m_nImageWidth, m_nImageHeight, gdiTmpDC, 0, 0, SRCCOPY );
}


void
CManageData::Draw_Option( BSTR val, HDC hDC, RECT& rcBounds )
{
	USES_CONVERSION;

	CSaveDC ctxDC( hDC );
	
	::SetTextColor( hDC, RGB(0,0,0) );

	::DrawText( hDC, OLE2T( val ), -1, &rcBounds, DT_SINGLELINE | DT_VCENTER | DT_LEFT );
}

void
CManageData::Draw_StrictOption( BSTR val, HDC hDC, RECT& rcBounds )
{
	USES_CONVERSION;

	CSaveDC ctxDC( hDC );
	
	::SetTextColor( hDC, RGB(0,0,0) );

	::DrawText( hDC, OLE2T( val ), -1, &rcBounds, DT_SINGLELINE | DT_VCENTER | DT_LEFT );
}


void
CManageData::Draw_Null( VARIANT val, HDC hDC, RECT& rcBounds )
{
	CGDIObject< HDC > gdiTmpDC( ::CreateCompatibleDC( hDC ) );

	CSaveDC ctxTmpDC( gdiTmpDC );

	::SelectObject( gdiTmpDC, m_hbmpNull );
	::BitBlt( hDC, ( rcBounds.left + rcBounds.right - m_nImageWidth ) / 2, ( rcBounds.top + rcBounds.bottom - m_nImageHeight ) / 2, m_nImageWidth, m_nImageHeight, gdiTmpDC, 0, 0, SRCCOPY );
}

void
CManageData::Draw_Unknown( VARIANT val, HDC hDC, RECT& rcBounds )
{
	CGDIObject< HDC > gdiTmpDC( ::CreateCompatibleDC( hDC ) );

	CSaveDC ctxTmpDC( gdiTmpDC );

	::SelectObject( gdiTmpDC, m_hbmpUnknown );
	::BitBlt( hDC, ( rcBounds.left + rcBounds.right - m_nImageWidth ) / 2, ( rcBounds.top + rcBounds.bottom - m_nImageHeight ) / 2, m_nImageWidth, m_nImageHeight, gdiTmpDC, 0, 0, SRCCOPY );
}


void
CManageData::Edit_Bool( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{
	switch( state )
	{
	
	case EditState_Begin:

		if( val->vt == VT_NULL )
		{
			val->vt =  vtType;
			val->bVal = FALSE;
		}else
		{
			switch( val->vt )
			{
				
			case VT_UI1:
				val->bVal = !( val->bVal );
				break;
			case VT_BOOL:
				val->boolVal = !( val->boolVal );
				break;
			}

			::VariantChangeType( val, val, 0, vtType );
		}

	}

	m_pEditFunction = NULL;
}

void
CManageData::Edit_Integer( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{
	static VARIANT* pVal = NULL;
	static VARTYPE vtSave = VT_NULL;
	static ColumnDefinition* pSaveDefinition = NULL;

	USES_CONVERSION;

	switch( state )
	{
	case EditState_Begin:
		{
			_ASSERTE( val != NULL );
			_ASSERTE( hWnd != NULL );
			_ASSERTE( prcBounds != NULL );			
			
			pVal = val;
			if( pVal->vt == VT_NULL )
			{
				pVal->vt =  vtType;
				pVal->lVal = 0;
			}
			vtSave = vtType;
			pSaveDefinition = pDefinition;
			
			_ASSERTE( m_wndSmartEdit.m_hWnd == NULL );
			if( m_wndSmartEdit.m_hWnd != NULL )
				m_wndSmartEdit.DestroyWindow();
			m_wndSmartEdit.Create( hWnd, *prcBounds, NULL, WS_CHILD );

			CComVariant varTmp = *pVal;
			varTmp.ChangeType( VT_BSTR );

			m_wndSmartEdit.SetText( CComBSTR( varTmp.bstrVal ) );

			m_wndSmartEdit.MoveWindow( prcBounds );
			m_wndSmartEdit.ShowWindow( SW_SHOW );
		}
		break;

	case EditState_Update:
		{
			CComBSTR bstrVal = m_wndSmartEdit.GetText();
			
			CComVariant v( bstrVal );
			if( SUCCEEDED( v.ChangeType( vtSave ) ) )
			{
				// Range checking
				// Check to see if there is a range specification
				BOOL bOK = TRUE;
				long nMin = 0, nMax = 0;
				if( pSaveDefinition && pSaveDefinition->m_bstrRange != NULL )
				{
					if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), "%d,%d", &nMin, &nMax ) == 2 )
					{
						if( v.lVal < nMin || nMax < v.lVal )
							bOK = FALSE;
					}
					else
						if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), "%d,", &nMin ) == 1 )
						{
							if( v.lVal < nMin )
								bOK = FALSE;
						}
						else
							if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), ",%d", &nMax ) == 1 )
							{
								if( nMax < v.lVal )
									bOK = FALSE;
							}
				}

				if( bOK )
				{
					::VariantClear( pVal );
					::VariantCopy( pVal, &v );
				}else
					m_pSmartGrid->Event_ValueNotInRange( m_pSmartGrid->m_posEditedCell.first, m_pSmartGrid->m_posEditedCell.second );

			}

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();
		}
		break;
	
	case EditState_Cancel:
		{
			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();
		}
		break;

	default:
		_ASSERTE( FALSE );
	}
}

void
CManageData::Edit_Real( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{
	static VARIANT* pVal = NULL;
	static VARTYPE vtSave = VT_NULL;
	static ColumnDefinition* pSaveDefinition = NULL;

	USES_CONVERSION;

	switch( state )
	{
	case EditState_Begin:
		{
			_ASSERTE( val != NULL );
			_ASSERTE( hWnd != NULL );
			_ASSERTE( prcBounds != NULL );			

			pVal = val;
			if( pVal->vt == VT_NULL )
			{
				pVal->vt =  vtType;
				pVal->dblVal = 0;
			}
			vtSave = vtType;
			pSaveDefinition = pDefinition;
			
			_ASSERTE( m_wndSmartEdit.m_hWnd == NULL );
			if( m_wndSmartEdit.m_hWnd != NULL )
				m_wndSmartEdit.DestroyWindow();
			m_wndSmartEdit.Create( hWnd, *prcBounds, NULL, WS_CHILD );
		
			CComVariant varTmp( *pVal );
			varTmp.ChangeType( VT_BSTR );
			m_wndSmartEdit.SetText( CComBSTR( varTmp.bstrVal ) );
			
			m_wndSmartEdit.MoveWindow( prcBounds );
			m_wndSmartEdit.ShowWindow( SW_SHOW );
		}
		break;

	case EditState_Update:
		{
			CComBSTR bstrVal = m_wndSmartEdit.GetText();

			CComVariant v( bstrVal );
			if( SUCCEEDED( v.ChangeType( vtSave ) ) )
			{
				// Range checking
				// Check to see if there is a range specification
				BOOL bOK = TRUE;
				double dMin = 0, dMax = 0;
				if( pSaveDefinition && pSaveDefinition->m_bstrRange != NULL )
				{
					if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), "%le,%le", &dMin, &dMax ) == 2 )
					{
						if( v.dblVal < dMin || dMax < v.dblVal )
							bOK = FALSE;
					}
					else
						if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), "%le,", &dMin ) == 1 )
						{
							if( v.dblVal < dMin )
								bOK = FALSE;
						}
						else
							if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), ",%le", &dMax ) == 1 )
							{
								if( dMax < v.dblVal )
									bOK = FALSE;
							}
				}

				if( bOK )
				{
					::VariantClear( pVal );
					::VariantCopy( pVal, &v );
				}else
					m_pSmartGrid->Event_ValueNotInRange( m_pSmartGrid->m_posEditedCell.first, m_pSmartGrid->m_posEditedCell.second );
			}

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();
		}
		break;
	
	case EditState_Cancel:
		{

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();		
		}
		break;

	default:
		_ASSERTE( FALSE );
	}
}

void
CManageData::Edit_Code( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{
	static VARIANT* pVal = NULL;
	static VARTYPE vtSave = VT_NULL;
	static ColumnDefinition* pSaveDefinition = NULL;

	USES_CONVERSION;

	switch( state )
	{
	case EditState_Begin:
		{
			_ASSERTE( val != NULL );
			_ASSERTE( hWnd != NULL );
			_ASSERTE( prcBounds != NULL );			

			pVal = val;
			if( pVal->vt == VT_NULL )
			{
				pVal->vt =  vtType;
				pVal->cVal = 0;
			}
			vtSave = vtType;
			pSaveDefinition = pDefinition;
			
			_ASSERTE( m_wndSmartEdit.m_hWnd == NULL );
			if( m_wndSmartEdit.m_hWnd != NULL )
				m_wndSmartEdit.DestroyWindow();
			m_wndSmartEdit.Create( hWnd, *prcBounds, NULL, WS_CHILD );

			CComVariant varTmp = *pVal;
			varTmp.ChangeType( VT_BSTR );

			m_wndSmartEdit.SetText( CComBSTR( varTmp.bstrVal ) );

			m_wndSmartEdit.MoveWindow( prcBounds );
			m_wndSmartEdit.ShowWindow( SW_SHOW );
		}
		break;

	case EditState_Update:
		{
			CComBSTR bstrVal = m_wndSmartEdit.GetText();

			CComVariant v( bstrVal );
			if( SUCCEEDED( v.ChangeType( vtSave ) ) )
			{
				::VariantClear( pVal );
				::VariantCopy( pVal, &v );
			}

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();
		}
		break;
	
	case EditState_Cancel:
		{

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();		
		}
		break;

	default:
		_ASSERTE( FALSE );
	}
}

void
CManageData::Edit_Currency( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{
	static VARIANT* pVal = NULL;
	static VARTYPE vtSave = VT_NULL;
	static ColumnDefinition* pSaveDefinition = NULL;

	USES_CONVERSION;

	switch( state )
	{
	case EditState_Begin:
		{
			_ASSERTE( val != NULL );
			_ASSERTE( hWnd != NULL );
			_ASSERTE( prcBounds != NULL );			

			pVal = val;
			vtSave = vtType;
			pSaveDefinition = pDefinition;
			
			_ASSERTE( m_wndSmartEdit.m_hWnd == NULL );
			if( m_wndSmartEdit.m_hWnd != NULL )
				m_wndSmartEdit.DestroyWindow();
			m_wndSmartEdit.Create( hWnd, *prcBounds, NULL, WS_CHILD );
		
			if( pVal->vt == VT_CY )
			{
				CComVariant varTmp( *pVal );
				varTmp.ChangeType( VT_BSTR );
				m_wndSmartEdit.SetText( CComBSTR( varTmp.bstrVal ) );
			}else
				m_wndSmartEdit.SetText( CComBSTR( _T("0") ) );
			
			m_wndSmartEdit.MoveWindow( prcBounds );
			m_wndSmartEdit.ShowWindow( SW_SHOW );
		}
		break;

	case EditState_Update:
		{
			CComBSTR bstrVal = m_wndSmartEdit.GetText();

			CComVariant v( bstrVal );
			if( SUCCEEDED( v.ChangeType( VT_CY ) ) )
			{
				CComVariant v1( v );
				v1.ChangeType( VT_R8 );
				// Range checking
				// Check to see if there is a range specification
				BOOL bOK = TRUE;
				double dMin = 0, dMax = 0;
				if( pSaveDefinition && pSaveDefinition->m_bstrRange != NULL )
				{
					if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), "%le,%le", &dMin, &dMax ) == 2 )
					{
						if( v1.dblVal < dMin || dMax < v1.dblVal )
							bOK = FALSE;
					}
					else
						if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), "%le,", &dMin ) == 1 )
						{
							if( v1.dblVal < dMin )
								bOK = FALSE;
						}
						else
							if( ::sscanf( OLE2A( pSaveDefinition->m_bstrRange ), ",%le", &dMax ) == 1 )
							{
								if( dMax < v1.dblVal )
									bOK = FALSE;
							}
				}

				if( bOK )
				{
					::VariantClear( pVal );
					::VariantCopy( pVal, &v );
				}else
					m_pSmartGrid->Event_ValueNotInRange( m_pSmartGrid->m_posEditedCell.first, m_pSmartGrid->m_posEditedCell.second );
			}

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();
		}
		break;
	
	case EditState_Cancel:
		{

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();		
		}
		break;

	default:
		_ASSERTE( FALSE );
	}
}

void
CManageData::Edit_Date( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{
	static VARIANT* pVal = NULL;
	static VARTYPE vtSave = VT_NULL;
	static ColumnDefinition* pSaveDefinition = NULL;

	USES_CONVERSION;

	switch( state )
	{
	case EditState_Begin:
		{
			_ASSERTE( val != NULL );
			_ASSERTE( hWnd != NULL );
			_ASSERTE( prcBounds != NULL );			

			pVal = val;
			vtSave = vtType;
			pSaveDefinition = pDefinition;
			
			_ASSERTE( m_wndSmartEdit.m_hWnd == NULL );
			if( m_wndSmartEdit.m_hWnd != NULL )
				m_wndSmartEdit.DestroyWindow();
			m_wndSmartEdit.Create( hWnd, *prcBounds, NULL, WS_CHILD );

			struct tm t;
			DATE d = 0;

			char szBuffer[256] = _T("");
			if( pVal->vt == VT_DATE )
			{
				::OleDate2Tm( pVal->date, t );				
			
				if( t.tm_hour != 0 || t.tm_min != 0 || t.tm_sec != 0 )		
					sprintf( szBuffer, "%d/%d/%d %d:%d:%d", t.tm_mday, t.tm_mon, t.tm_year, t.tm_hour, t.tm_min, t.tm_sec );
				else
					sprintf( szBuffer, "%d/%d/%d", t.tm_mday, t.tm_mon, t.tm_year );
			}
		
			m_wndSmartEdit.SetText( CComBSTR( szBuffer ) );
			
			m_wndSmartEdit.MoveWindow( prcBounds );
			m_wndSmartEdit.ShowWindow( SW_SHOW );

		}
		break;

	case EditState_Update:
		{
			CComBSTR bstrVal = m_wndSmartEdit.GetText();

			struct tm t;
			::ZeroMemory( &t, sizeof( t ) );
			sscanf( OLE2T( bstrVal ), "%d/%d/%d %d:%d:%d", &t.tm_mday, &t.tm_mon, &t.tm_year, &t.tm_hour, &t.tm_min, &t.tm_sec );

			::VariantClear( pVal );
			pVal->vt = VT_DATE;
			::Tm2OleDate( t, pVal->date );
	
			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();
		}
		break;
	
	case EditState_Cancel:
		{
			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();		
		}
		break;

	default:
		_ASSERTE( FALSE );
	}
}

void
CManageData::Edit_String( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{	
	static VARIANT* pVal = NULL;
	static VARTYPE vtSave = VT_NULL;
	static ColumnDefinition* pSaveDefinition = NULL;

	USES_CONVERSION;

	switch( state )
	{
	case EditState_Begin:
		{
			_ASSERTE( val != NULL );
			_ASSERTE( hWnd != NULL );
			_ASSERTE( prcBounds != NULL );			

			pVal = val;
			vtSave = vtType;
			/*
			if( pVal->vt == VT_NULL || pVal->vt == VT_EMPTY )
			{
				pVal->vt =  vtType;
				pVal->bstrVal = ::SysAllocString( T2BSTR( _T("") ) );
			}
			*/			
			pSaveDefinition = pDefinition;
			
			_ASSERTE( m_wndSmartEdit.m_hWnd == NULL );
			if( m_wndSmartEdit.m_hWnd != NULL )
				m_wndSmartEdit.DestroyWindow();
			m_wndSmartEdit.Create( hWnd, *prcBounds, NULL, WS_CHILD );
			
			if( pVal->vt == VT_BSTR && pVal->bstrVal != NULL  )
				m_wndSmartEdit.SetText( CComBSTR( pVal->bstrVal ) );
			else
				m_wndSmartEdit.SetText( CComBSTR( _T("") ) );

			m_wndSmartEdit.MoveWindow( prcBounds );
			m_wndSmartEdit.ShowWindow( SW_SHOW );
		}
		break;

	case EditState_Update:
		{
			CComBSTR bstrVal = m_wndSmartEdit.GetText();

			CComVariant v( bstrVal );
			if( SUCCEEDED( v.ChangeType( vtSave ) ) )
			{
				::VariantClear( pVal );
				::VariantCopy( pVal, &v );
			}

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();
		}
		break;
	
	case EditState_Cancel:
		{

			pVal = NULL;
			m_wndSmartEdit.DestroyWindow();		
		}
		break;

	default:
		_ASSERTE( FALSE );
	}
}

void
CManageData::Edit_Option( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{	
	static VARIANT* pVal = NULL;
	static VARTYPE vtSave = VT_NULL;
	static ColumnDefinition* pSaveDefinition = NULL;

	USES_CONVERSION;	

	switch( state )
	{
	case EditState_Begin:
		{
			_ASSERTE( val != NULL );
			_ASSERTE( hWnd != NULL );
			_ASSERTE( prcBounds != NULL );			

			pVal = val;
			vtSave = vtType;
			pSaveDefinition = pDefinition;
			/*
			if( pVal->vt == VT_NULL || pVal->vt == VT_EMPTY )
			{
				pVal->vt =  vtType;
				pVal->bstrVal = ::SysAllocString( T2BSTR( _T("") ) );
			}
			*/			
			
			_ASSERTE( m_wndOption.m_hWnd == NULL );
			if( m_wndOption.m_hWnd != NULL )
				m_wndOption.DestroyWindow();
			m_wndOption.Create( hWnd, *prcBounds, NULL, WS_CHILD );

			// Add options
			if( pDefinition->m_bstrRange != NULL )
			{
				OLECHAR* pIterator = pDefinition->m_bstrRange;
				OLECHAR* pLast = pIterator;
				while( true )
				{
					if( *pIterator == '|' || *pIterator == '\0' )
					{
						basic_string< TCHAR > strOption;
						while( pLast != pIterator )
						{
							strOption += (TCHAR)(*pLast);
							pLast++;
						}

						m_wndOption.AddItem( CComBSTR( strOption.c_str() ) );

						if( *pIterator == '\0' )
							break;

						pIterator++;
						pLast = pIterator;

					}else
						pIterator++;
				}
			}			

			if( pVal->vt == VT_BSTR && pVal->bstrVal != NULL )
			{
				basic_string< TCHAR > strText( OLE2T( pVal->bstrVal ) );
				m_wndOption.SelectItem( CComBSTR( strText.c_str() ) );
			}
			
			if( pVal->vt == VT_BSTR && pVal->bstrVal != NULL )
				m_wndOption.SetText( CComBSTR( pVal->bstrVal ) );
			else
				m_wndOption.SetText( CComBSTR( _T("") ) );

			m_wndOption.MoveWindow( prcBounds );
			m_wndOption.ShowWindow( SW_SHOW );

			m_wndOption.ShowDropDown( TRUE );
		}
		break;

	case EditState_Update:
		{
			CComBSTR bstrVal = m_wndOption.GetText();

			CComVariant v( bstrVal );
			if( SUCCEEDED( v.ChangeType( vtSave ) ) )
			{
				::VariantClear( pVal );
				::VariantCopy( pVal, &v );
			}

			pVal = NULL;
			m_wndOption.DestroyWindow();
		}
		break;
	
	case EditState_Cancel:
		{
			pVal = NULL;
			m_wndOption.DestroyWindow();		
		}
		break;

	default:
		_ASSERTE( FALSE );
	}	
}

void
CManageData::Edit_StrictOption( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{	
	static VARIANT* pVal = NULL;
	static VARTYPE vtSave = VT_NULL;
	static ColumnDefinition* pSaveDefinition = NULL;

	USES_CONVERSION;	

	switch( state )
	{
	case EditState_Begin:
		{
			_ASSERTE( val != NULL );
			_ASSERTE( hWnd != NULL );
			_ASSERTE( prcBounds != NULL );			

			pVal = val;
			vtSave = vtType;
			pSaveDefinition = pDefinition;

			/*
			if( pVal->vt == VT_NULL || pVal->vt == VT_EMPTY )
			{
				pVal->vt =  vtType;
				pVal->bstrVal = ::SysAllocString( T2BSTR( _T("") ) );
			}
			*/
			
			_ASSERTE( m_wndStrictOption.m_hWnd == NULL );
			if( m_wndStrictOption.m_hWnd != NULL )
				m_wndStrictOption.DestroyWindow();
			m_wndStrictOption.Create( hWnd, *prcBounds, NULL, WS_CHILD );

			// Add options
			if( pDefinition->m_bstrRange != NULL )
			{
				OLECHAR* pIterator = pDefinition->m_bstrRange;
				OLECHAR* pLast = pIterator;
				while( true )
				{
					if( *pIterator == '|' || *pIterator == '\0' )
					{
						basic_string< TCHAR > strOption;
						while( pLast != pIterator )
						{
							strOption += (TCHAR)(*pLast);
							pLast++;
						}

						m_wndStrictOption.AddItem( CComBSTR( strOption.c_str() ) );

						if( *pIterator == '\0' )
							break;

						pIterator++;
						pLast = pIterator;

					}else
						pIterator++;
				}
			}			

			if( pVal->vt == VT_BSTR && pVal->bstrVal != NULL )
			{
				basic_string< TCHAR > strText( OLE2T( pVal->bstrVal ) );
				m_wndStrictOption.SelectItem( CComBSTR( strText.c_str() ) );
			}
			
			if( pVal->vt == VT_BSTR && pVal->bstrVal != NULL )
				m_wndStrictOption.SetText( CComBSTR( pVal->bstrVal ) );
			else
				m_wndStrictOption.SetText( CComBSTR( _T("") ) );

			m_wndStrictOption.MoveWindow( prcBounds );
			m_wndStrictOption.ShowWindow( SW_SHOW );

			m_wndStrictOption.ShowDropDown( TRUE );
		}
		break;

	case EditState_Update:
		{
			CComBSTR bstrVal = m_wndStrictOption.GetText();

			CComVariant v( bstrVal );
			if( SUCCEEDED( v.ChangeType( vtSave ) ) )
			{
				::VariantClear( pVal );
				::VariantCopy( pVal, &v );
			}

			pVal = NULL;
			m_wndStrictOption.DestroyWindow();
		}
		break;
	
	case EditState_Cancel:
		{
			pVal = NULL;
			m_wndStrictOption.DestroyWindow();
		}
		break;

	default:
		_ASSERTE( FALSE );
	}	
}

void
CManageData::Edit_Object( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{	
}

void
CManageData::Edit_Null( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{
}

void
CManageData::Edit_Unknown( EditState state, VARIANT *val, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT* prcBounds )
{
}

void
CManageData::Draw(VARIANT *pvarData, ColumnDefinition* pDefinition, HDC hDC, RECT rcBounds, CSmartGrid* pSmartGrid )
{	
	if( pvarData == NULL || hDC == NULL )
		return;

	m_pSmartGrid = pSmartGrid;

	if( pvarData->vt == VT_NULL || pvarData->vt == VT_EMPTY )
	{
		Draw_Null( *pvarData, hDC, rcBounds );
		return;
	}

	switch( pDefinition->m_vtType )
	{

	/*
		Boolean data types
	*/

	case DataType_Bool:
		Draw_Bool( pvarData->bVal, hDC, rcBounds );
		break;

	/*
		Integer data types
	*/
	case DataType_I2:
		Draw_Integer( pvarData->iVal, hDC, rcBounds );
		break;

	case DataType_I4:
		Draw_Integer( pvarData->lVal, hDC, rcBounds );
		break;

	/*
		Real data types
	*/

	case DataType_R4:
		Draw_Real( pvarData->fltVal, hDC, rcBounds );
		break;

	case DataType_R8:
		Draw_Real( pvarData->dblVal, hDC, rcBounds );
		break;

	/*
		Codes
	*/

	case DataType_Code:
		Draw_Code( pvarData->scode, hDC, rcBounds );
		break;

	/*
		Currency
	*/

	case DataType_Cy:
		Draw_Currency( pvarData->cyVal, hDC, rcBounds );
		break;

	/*
		Date
	*/

	case DataType_Date:
		Draw_Date( pvarData->date, hDC, rcBounds );
		break;

	/*
		String
	*/

	case DataType_BStr:
		Draw_String( pvarData->bstrVal, hDC, rcBounds );
		break;

	/*
		Objects
	*/
	case DataType_Unknown:
		Draw_Object( pvarData->punkVal, hDC, rcBounds );
		break;

	case DataType_Dispatch:
		Draw_Object( pvarData->pdispVal, hDC, rcBounds );
		break;

	/*
		Options
	*/

	case DataType_Option:
		Draw_Option( pvarData->bstrVal, hDC, rcBounds );
		break;

	case DataType_StrictOption:
		Draw_StrictOption( pvarData->bstrVal, hDC, rcBounds );
		break;

	/*
		Empty
	*/
	case VT_EMPTY:
	case VT_NULL:
		Draw_Null( *pvarData, hDC, rcBounds );
		break;

	/*
		Unknown
	*/
	default:
		Draw_Unknown( *pvarData, hDC, rcBounds );
		break;
	}
}

void
CManageData::Edit(VARIANT *pvarData, ColumnDefinition* pDefinition, VARTYPE vtType, HWND hWnd, RECT rcBounds, CSmartGrid* pSmartGrid )
{
	if( pvarData == NULL || hWnd == NULL )
		return;

	m_pSmartGrid = pSmartGrid;

	// Check to see if this column is read only
	if( pDefinition->m_bReadOnly )
		return;

	BOOL bReadOnly;
	m_pSmartGrid->get_ReadOnly( &bReadOnly );
	if( bReadOnly )
		return;

	switch( pDefinition->m_vtType )
	{

	/*
		Boolean data types
	*/
	
	case DataType_Bool:
		m_pEditFunction = Edit_Bool;
		break;

	/*
		Integer data types
	*/

	case DataType_I2:
	case DataType_I4:
		m_pEditFunction = Edit_Integer;
		break;

	/*
		Real data types
	*/

	case DataType_R4:
	case DataType_R8:
		m_pEditFunction = Edit_Real;
		break;

	/*
		Codes
	*/

	case DataType_Code:
		m_pEditFunction = Edit_Code;
		break;

	/*
		Currency
	*/

	case DataType_Cy:
		m_pEditFunction = Edit_Currency;
		break;

	/*
		Date
	*/

	case DataType_Date:
		m_pEditFunction = Edit_Date;
		break;

	/*
		String
	*/

	case DataType_BStr:
		m_pEditFunction = Edit_String;
		break;

	/*
		Options
	*/
	case DataType_Option:
		m_pEditFunction = Edit_Option;
		break;

	case DataType_StrictOption:
		m_pEditFunction = Edit_StrictOption;
		break;


	/*
		Objects
	*/

	case DataType_Unknown:
	case DataType_Dispatch:
		m_pEditFunction = Edit_Object;
		break;

	/*
		Empty
	*/
	case VT_EMPTY:
	case VT_NULL:
		m_pEditFunction = Edit_Null;
		break;

	/*
		Unknown
	*/
	default:
		m_pEditFunction = Edit_Unknown;
		break;
	}

	(this->*m_pEditFunction)( EditState_Begin, pvarData, pDefinition, vtType, hWnd, &rcBounds );
}