/********************************************
** 工作室：S&P工作室
** 作者	 ：张东斌
** 日期  ：2006年3月
*********************************************/
#if !defined(__XTMASKEDITEX_H__)
#define __XTMASKEDITEX_H__

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

//////////////////////////////////////////////////////////////////////
// Summary:
//     CXTMaskEditT is a template class. It allows text masking to be
//     applied to the control to format it for special editing restrictions.
//////////////////////////////////////////////////////////////////////
template <class TBase>
class CXTMaskEditT : public TBase
{

public:

	//-----------------------------------------------------------------------
	// Summary:
	//     Constructs a CXTMaskEditT object
	//-----------------------------------------------------------------------
	CXTMaskEditT()
		: m_nStartChar( 0 )
		, m_nEndChar( 0 )
		, m_bOverType( true )
		, m_bUseMask( true )
		, m_bRedo( false )
		, m_bModified( false )
		, m_strWindowText( _T( "" ) )
		, m_strMask( _T( "" ) )
		, m_strLiteral( _T( "" ) )
		, m_strDefault( _T( "" ) )
		, m_strUndoBuffer( _T( "" ) )
		, m_chPrompt( _T('_') )
	{
	}

public:

	//-----------------------------------------------------------------------
	// Parameters:
	//     bUseMask - true to enable the mask. false to disable the mask.
	// Summary:
	//     Call this member function to enable or disable the mask for the mask
	//     edit control.
	//-----------------------------------------------------------------------
	void SetUseMask(bool bUseMask) {
		m_bUseMask = bUseMask;
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to determine if the mask for the edit
	//     control can be used.
	// Returns:
	//     true if the mask can be used, otherwise returns false.
	//-----------------------------------------------------------------------
	bool CanUseMask() {
		return m_bUseMask && ((GetStyle() & ES_READONLY) == 0);
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to enable or disable type over, also
	//     known as insert mode.
	// Parameters:
	//     bOverType - true to enable type over.
	//-----------------------------------------------------------------------
	void SetOverType(bool bOverType) {
		m_bOverType = bOverType;
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to determine if type over has been enabled.
	// Returns:
	//     true if type over is enabled, otherwise returns false.
	//-----------------------------------------------------------------------
	bool CanOverType() {
		return m_bOverType;
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to determine if the index specified
	//     by 'iPos' is a valid index for the currently displayed edit text.
	// Parameters:
	//     iPos - Index of the character to check.
	// Returns:
	//     true if the index is valid, otherwise returns false.
	//-----------------------------------------------------------------------
	bool PosInRange(int iPos) {
		return ( ( iPos >= 0 ) && ( iPos < m_strLiteral.GetLength( ) ) );
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function retrieves the character that is currently used as
	//     the mask prompt. The mask prompt indicates that the field is editable.
	// Returns:
	//     A TCHAR data type.
	//-----------------------------------------------------------------------
	TCHAR GetPromptChar() {
		return m_chPrompt;
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to set the prompt character that is
	//     displayed to the user that indicates the field can be edited.
	// Parameters:
	//     ch - A TCHAR data type.
	//-----------------------------------------------------------------------
	void SetPromptChar(TCHAR ch)
	{
		if (m_chPrompt == ch)
			return;

		for (int i = 0; i < m_strLiteral.GetLength(); i++)
			if (m_strLiteral[i] == m_chPrompt) m_strLiteral.SetAt(i, ch);

		for (int j = 0; j < m_strWindowText.GetLength(); j++)
			if (m_strWindowText[j] == m_chPrompt) m_strWindowText.SetAt(j, ch);

		m_chPrompt = ch;
		SetWindowText( m_strWindowText );

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to perform a cut operation using the
	//     currently selected text.
	//-----------------------------------------------------------------------
	void MaskCut()
	{
		if ( !CanUseMask( ))
		{
			DefWindowProc( WM_CUT, 0, 0);
		}
		else
		{
			MaskCopy( );
			MaskClear( );

			m_bRedo = false;
			m_bModified = true;
			SetWindowText( m_strWindowText );

			CorrectPosition( m_nStartChar );
			m_nEndChar = m_nStartChar;
			SetSel( m_nStartChar, m_nEndChar );
		}

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to perform a copy operation using the
	//     currently selected text.
	//-----------------------------------------------------------------------
	void MaskCopy()
	{
		if ( !CanUseMask( ))
		{
			DefWindowProc( WM_COPY, 0, 0);
		}
		else
		{
			GetSel( m_nStartChar, m_nEndChar );

			CString strBuffer;
			int i;
			for ( i = m_nStartChar; i < m_nEndChar; ++i )
			{
				if ( m_strLiteral.GetAt( i ) == m_chPrompt )
				{
					if ( m_strWindowText.GetAt( i ) == m_chPrompt )
						continue;

					strBuffer += m_strWindowText.GetAt( i );
				}
			}

			CopyToClipboard( strBuffer );
		}

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to perform a paste operation using the
	//     current clipboard text.
	//-----------------------------------------------------------------------
	void MaskPaste()
	{
		if ( !CanUseMask( ))
		{
			DefWindowProc(WM_PASTE, 0, 0);
		}
		else
		{
			GetSel( m_nStartChar, m_nEndChar );
			MaskClear( );

			if ( !OpenClipboard( ) )
				return;

			LPTSTR lptstrPaste = NULL;
			HGLOBAL hglbPaste = ::GetClipboardData( CF_TEXT );
			if ( hglbPaste != NULL )
			{
				lptstrPaste = ( TCHAR* )::GlobalLock( hglbPaste );
				if ( lptstrPaste != NULL )
				{
					::GlobalUnlock( hglbPaste );
				}
			}

			::CloseClipboard();

			int i, x = m_nStartChar, iLen = (int)_tcslen( lptstrPaste );

			for ( i = 0; i < iLen; ++i )
			{
				UINT ch = lptstrPaste[ i ];

				if ( CheckChar( ch, false ) )
				{
					InsertCharAt( x, ( TCHAR )ch );
					++x;

					if ( x == m_strWindowText.GetLength( ) )
						break;
				}
			}

			m_bRedo = false;
			m_bModified = true;
			SetWindowText( m_strWindowText );

			m_nEndChar = m_nStartChar;
			SetSel( m_nStartChar, m_nEndChar );
		}

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to clear the current text selection.
	//-----------------------------------------------------------------------
	void MaskClear()
	{
		if ( !CanUseMask( ))
		{
			DefWindowProc( WM_CLEAR, 0, 0);
		}
		else
		{
			if ( m_nStartChar == m_nEndChar )
				return;

			// check to see if there is anything left to delete
			int iLength = m_strWindowText.GetLength( );

			int i;
			for ( i = m_nStartChar; i < iLength; ++i )
			{
				TCHAR ch1 = m_strLiteral.GetAt( i );
				TCHAR ch2 = m_strWindowText.GetAt( i );

				if ( ( ch1 == m_chPrompt ) && ( ch2 != m_chPrompt ) )
				{
					break;
				}
			}

			if ( i == iLength )
			{
				::MessageBeep( ( UINT )-1 );
				return;
			}

			for ( i = m_nStartChar; i < m_nEndChar; ++i )
			{
				if ( m_strLiteral.GetAt( i ) == m_chPrompt )
				{
					DeleteCharAt( m_nStartChar );
				}
			}

			m_bRedo = false;
			m_bModified = true;
			SetWindowText( m_strWindowText );

			m_nEndChar = m_nStartChar;
			SetSel( m_nStartChar, m_nEndChar );
		}

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to undo the previous action.
	//-----------------------------------------------------------------------
	void MaskUndo()
	{
		if ( !CanUseMask( ))
		{
			DefWindowProc( EM_UNDO, 0, 0);
		}
		else
		{
			GetSel( m_nStartChar, m_nEndChar );

			if ( m_bRedo )
			{
				m_bRedo = false;
				m_bModified = true;
				SetWindowText( m_strRedoBuffer );
			}
			else
			{
				m_bRedo = true;
				m_bModified = true;
				GetWindowText( m_strRedoBuffer );
				SetWindowText( m_strUndoBuffer );
			}

			GetWindowText( m_strWindowText );
			m_nEndChar = m_nStartChar;
			SetSel( m_nStartChar, m_nEndChar );
		}

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is called to select all text in the mask edit
	//     control.
	//-----------------------------------------------------------------------
	void MaskSelectAll()
	{
		if ( !CanUseMask( ))
		{
			CEdit::SetSel(0, -1);
		}
		else
		{
			m_nStartChar = 0;
			CorrectPosition( m_nStartChar );
			SetSel(m_nStartChar, -1);
		}
	}

	//-----------------------------------------------------------------------}
	// Summary:
	//     This member function is called to determine if the text has been modified.
	// Returns:
	//     true if the text has changed, otherwise returns false.
	//-----------------------------------------------------------------------
	bool IsModified() {
		return m_bModified;
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This method called to set masked text for the edit control.
	// Parameters:
	//     lpszMaskedText - Text string without mask.
	// Remarks:
	//     If a mask is used, then the mask will be applied to the text
	//     in lpszMaskedText.
	//-----------------------------------------------------------------------
	void SetMaskedText(LPCTSTR lpszMaskedText)
	{
		CString strMaskedText = lpszMaskedText;
		int nLen = strMaskedText.GetLength();
		int x = 0;

		m_strWindowText = m_strLiteral;

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

		// set the window text for the control.
		m_bRedo = false;
		m_bModified = false;
		SetWindowText( m_strWindowText );

		m_strUndoBuffer = m_strWindowText;

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function will set the mask for the edit control.
	// Parameters:
	//     lpszMask    - The format for the mask field. For example, if you wanted to set
	//                   the mask for a phone number, and you only wanted digits to be entered,
	//                   your mask might look like this; _T("(000) 000-0000").
	//     lpszLiteral - The literal format is entered here. Wherever you place an underscore
	//                   ('_') is where the user will be allowed to enter data only. Using
	//                   the phone number example; _T("(___) ___-____").
	//     lpszDefault - Text that is to be displayed when the control is initialized. For
	//                   example; _T("(800) 555-1212"). If NULL, 'lpszLiteral' is used to initialize
	//                   the edit text.
	// Remarks:
	//     The values that can be set are:
	//     <TABLE>
	//          <b>Mask Character</b>  <b>Description</b>
	//          ---------------------  ------------------------
	//          0                      Numeric (0-9)
	//          9                      Numeric (0-9) or space (' ')
	//          #                      Numeric (0-9) or space (' ') or ('+') or ('-')
	//          L                      Alpha (a-Z)
	//          ?                      Alpha (a-Z) or space (' ')
	//          A                      Alpha numeric (0-9 and a-Z)
	//          a                      Alpha numeric (0-9 and a-Z) or space (' ')
	//          &                      All print character only
	//          H                      Hex digit (0-9 and A-F)
	//          X                      Hex digit (0-9 and A-F) and space (' ')
	//          >                      Forces characters to upper case (A-Z)
	//          <                      Forces characters to lower case (a-z)
	//     </TABLE>
	//-----------------------------------------------------------------------
	virtual void SetEditMask(LPCTSTR lpszMask,LPCTSTR lpszLiteral,LPCTSTR lpszDefault=NULL)
	{
		ASSERT(lpszMask);
		ASSERT(lpszLiteral);

		// initialize the mask for the control.
		m_strMask    = lpszMask;
		m_strLiteral = lpszLiteral;

		ASSERT(m_strMask.GetLength() == m_strLiteral.GetLength());

		if ( lpszDefault == NULL )
		{
			m_strWindowText = lpszLiteral;
			m_strDefault    = lpszLiteral;
		}
		else
		{
			SetMaskedText(lpszDefault);
			m_strDefault    = m_strWindowText;
		}

		ASSERT(m_strWindowText.GetLength() == m_strLiteral.GetLength());

		// set the window text for the control.
		m_bRedo = false;
		m_bModified = false;
		SetWindowText( m_strWindowText );

		m_strUndoBuffer = m_strWindowText;

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     Converts character to Upper/Lower case.
	// Parameters:
	//     nChar - Char to be converted
	//     bUpperCase  - TRUE to convert to upper case
	// Returns:
	//     Converted character.
	//-----------------------------------------------------------------------
	TCHAR ConvertUnicodeAlpha(TCHAR nChar, BOOL bUpperCase)
	{
		CString strTemp(nChar);
		if (bUpperCase) strTemp.MakeUpper(); else strTemp.MakeLower();
		return strTemp[0];
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This method determines if nChar is alpha character
	// Parameters:
	//     nChar - Character need to test
	// Returns:
	//     true if nChar is alpha character.
	//-----------------------------------------------------------------------
	bool IsUnicodeAlpha(TCHAR nChar)
	{
		if (ConvertUnicodeAlpha(nChar, TRUE) != nChar)
			return TRUE;

		if (ConvertUnicodeAlpha(nChar, FALSE) != nChar)
			return TRUE;

		return FALSE;
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is used internally to validate the character indicated
	//     by 'nChar'.
	// Parameters:
	//     nChar - Contains the character code value of the key.
	//     bBeep - true to enable beep. false to disable beep.
	// Returns:
	//     true if successful, otherwise returns false.
	//-----------------------------------------------------------------------
	virtual bool CheckChar(UINT& nChar,bool bBeep=true)
	{
		// do not use mask
		if ( !CanUseMask( ) )
		{
			return false;
		}

		// control character, OK
		if ( !_istprint( ( TCHAR )nChar ) && !IsUnicodeAlpha(( TCHAR )nChar))
		{
			return true;
		}

		// advance to the first character input position.
		int i;
		for ( i = m_nStartChar; i < m_strLiteral.GetLength( ); ++i )
		{
			if ( m_strLiteral.GetAt( i ) == m_chPrompt )
			{
				SetSel( i, i );
				break;
			}
		}

		// make sure the string is not longer than the mask
		if ( i >= m_strMask.GetLength( ) )
		{
			if ( bBeep )
			{
				:: MessageBeep( ( UINT )-1 );
			}
			return false;
		}

		if ( !ProcessMask( nChar, i ) )
		{
			if ( bBeep )
			{
				:: MessageBeep( ( UINT )-1 );
			}
			return false;
		}

		return true;

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     This member function is used internally to process the character passed
	//     in by 'nChar' whose index is specified by 'nEndPos'.
	// Parameters:
	//     nChar - Contains the character code value of the key.
	//     nEndPos - Index of character in display string.
	// Returns:
	//     true if successful, otherwise returns false.
	//-----------------------------------------------------------------------
	virtual bool ProcessMask(UINT& nChar,int nEndPos)
	{
		// check the key against the mask
		switch ( m_strMask.GetAt( nEndPos ) )
		{
		case '0':       // digit only //completely changed this
			{
				if ( _istdigit( ( TCHAR )nChar ) ) {
					return true;
				}
				break;
			}
		case '9':       // digit or space
			{
				if ( _istdigit( ( TCHAR )nChar ) ) {
					return true;
				}
				if ( nChar == ' ' ) {
					return true;
				}
				break;
			}
		case '#':       // digit or space or '+' or '-'
			{
				if ( _istdigit( ( TCHAR )nChar ) ) {
					return true;
				}
				if ( nChar == ' ' || nChar == '-' || nChar == '+' ) {
					return true;
				}
				break;
			}
		case 'd':       // decimal
			{
				if ( _istdigit( ( TCHAR )nChar ) ) {
					return true;
				}
				if ( nChar == ' ' || nChar == '-' || nChar == '+' || nChar == '.' || nChar == ',') {
					return true;
				}
				break;
			}
		case 'L':       // alpha only
			{
				if ( _istalpha( ( TCHAR )nChar ) || IsUnicodeAlpha(( TCHAR )nChar) ) {
					return true;
				}
				break;
			}
		case '?':       // alpha or space
			{
				if ( _istalpha( ( TCHAR )nChar ) || IsUnicodeAlpha(( TCHAR )nChar) ) {
					return true;
				}
				if ( nChar == ' ' ) {
					return true;
				}
				break;
			}
		case 'A':       // alpha numeric only
			{
				if ( _istalnum( ( TCHAR )nChar ) || IsUnicodeAlpha(( TCHAR )nChar)) {
					return true;
				}
				break;
			}
		case 'a':       // alpha numeric or space
			{
				if ( _istalnum( ( TCHAR )nChar ) || IsUnicodeAlpha(( TCHAR )nChar)) {
					return true;
				}
				if ( nChar == ' ' ) {
					return true;
				}
				break;
			}
		case '&':       // all print character only
			{
				if ( _istprint( ( TCHAR )nChar ) || IsUnicodeAlpha(( TCHAR )nChar) ) {
					return true;
				}
				break;
			}
		case 'H':       // hex digit
			{
				if ( _istxdigit( ( TCHAR )nChar ) ) {
					return true;
				}
				break;
			}
		case 'X':       // hex digit or space
			{
				if ( _istxdigit( ( TCHAR )nChar ) ) {
					return true;
				}
				if ( nChar == ' ' ) {
					return true;
				}
				break;
			}
		case '>':
			{
				if ( _istalpha( ( TCHAR )nChar ) || IsUnicodeAlpha(( TCHAR )nChar))
				{
					nChar = ConvertUnicodeAlpha( ( TCHAR )nChar, TRUE);
					return true;
				}
				break;
			}
		case '<':
			{
				if ( _istalpha( ( TCHAR )nChar ) || IsUnicodeAlpha(( TCHAR )nChar))
				{
					nChar = ConvertUnicodeAlpha( ( TCHAR )nChar, FALSE);
					return true;
				}
				break;
			}
		}

		return false;
	}

public:

	//-----------------------------------------------------------------------
	// Summary:
	//     Used by class CWinApp to translate window messages before they are dispatched to theTranslateMessage andDispatchMessage Windows functions.
	// Parameters:
	//     pMsg - Points to a MSG structure that contains the message to process.
	// Returns:
	//     Nonzero if the message was translated and should not be dispatched; 0 if the message was not translated and should be dispatched.
	//-----------------------------------------------------------------------
	virtual BOOL PreTranslateMessage(MSG* pMsg)
	{
		if (!CanUseMask())
		{
			return TBase::PreTranslateMessage(pMsg);
		}

		// intercept Ctrl+C (copy), Ctrl+V (paste), Ctrl+X (cut) and Ctrl+Z (undo)
		// before CEdit base class gets a hold of them.

		if ( pMsg->message == WM_KEYDOWN )
		{
			if ( ::GetKeyState( VK_SUBTRACT ) < 0 )
			{
				OnChar( '-', 1, 1 );
				return TRUE;
			}

			if ( ::GetKeyState( VK_ADD ) < 0 )
			{
				OnChar( '+', 1, 1 );
				return TRUE;
			}

			if ( ::GetKeyState( VK_CONTROL ) < 0 )
			{
				switch ( pMsg->wParam )
				{
				case 'X':
				case 'x':
					{
						MaskCut( );
						return TRUE;
					}

				case 'C':
				case 'c':
					{
						MaskCopy( );
						return TRUE;
					}

				case 'V':
				case 'v':
					{
						MaskPaste( );
						return TRUE;
					}

				case 'Z':
				case 'z':
					{
						MaskUndo( );
						return TRUE;
					}
				}
			}
			else
			{
				switch ( pMsg->wParam )
				{
				case '-':
					{
						OnChar( '-', 1, 1 );
						return TRUE;
					}

				case '+':
					{
						OnChar( '+', 1, 1 );
						return TRUE;
					}
				}
			}
		}

		return TBase::PreTranslateMessage(pMsg);

	}

	//{{AFX_CODEJOCK_PRIVATE
	virtual bool CorrectPosition(int& iPos, bool bForward=true, bool bBeep=true) // used internally
	{
		GetWindowText( m_strWindowText );
		int iLen = m_strWindowText.GetLength( );

		if ( iPos == iLen )
		{
			if ( bBeep )
			{
				::MessageBeep( ( UINT )-1 );
			}
			return false;
		}

		if (! PosInRange(iPos))
			return false;

		if ( m_strLiteral.GetAt( iPos ) != m_chPrompt )
		{
			int i;
			if ( bForward )
			{
				for ( i = iPos; i < iLen; ++i )
				{
					if ( m_strLiteral.GetAt( i ) == m_chPrompt )
					{
						iPos = i;
						break;
					}
				}
			}
			else
			{
				for ( i = iPos; i >= 0; --i )
				{
					if ( m_strLiteral.GetAt( i ) == m_chPrompt )
					{
						iPos = i;
						break;
					}
				}

				if ( i == -1 )
				{
					iPos++;

					if ( bBeep )
					{
						::MessageBeep( ( UINT )-1 );
					}
					return false;
				}
			}

			if ( i == iLen )
			{
				if ( bBeep )
				{
					::MessageBeep( ( UINT )-1 );
				}
				return false;
			}
		}
		return true;

	}
	//}}AFX_CODEJOCK_PRIVATE

	//-----------------------------------------------------------------------
	// Summary:
	//     Deletes character in specified position
	// Parameters:
	//     iPos - Position for character to be deleted.
	//-----------------------------------------------------------------------
	virtual void DeleteCharAt(int iPos)
	{
		if (!PosInRange(iPos))
			return;

		CString strBuffer = GetMaskedText( iPos+1 );
		strBuffer += m_chPrompt;

		int x = 0;
		int iLen = strBuffer.GetLength( );
		int i;
		for (i = iPos; i < m_strLiteral.GetLength( ); ++i )
		{
			if ( ( m_strLiteral.GetAt( i ) == m_chPrompt ) )
			{
				m_strWindowText.SetAt( i, strBuffer.GetAt( x ) );
				++x;

				if ( x == iLen )
					break;
			}
		}


	}

	//-----------------------------------------------------------------------
	// Summary:
	//     Inserts character to specified position.
	// Parameters:
	//     iPos - Position to insert
	//     nChar - Character to be inserted
	//-----------------------------------------------------------------------
	virtual void InsertCharAt(int iPos, TCHAR nChar)
	{
		if (!PosInRange(iPos))
		{
			return;
		}

		UINT uChar = nChar;
		if ( !CheckChar( uChar, false ) )
		{
			return;
		}

		CString strBuffer = GetMaskedText( iPos );

		CString strTemp(nChar);
		int i, x = 0, iLen = strBuffer.GetLength( );
		for ( i = 1; i < strBuffer.GetLength(); ++i )
		{
			strTemp += strBuffer.GetAt( i-1 );
		}
		strBuffer = strTemp;

		for ( i = iPos; i < m_strWindowText.GetLength( ); ++i )
		{
			if ( m_strLiteral.GetAt( i ) == m_chPrompt )
			{
				m_strWindowText.SetAt( i, strBuffer[ x ] );
				++x;

				if ( x == iLen )
					break;
			}
		}
	}

	//-----------------------------------------------------------------------
	// Summary:
	//     Copies text to system clipboard
	// Parameters:
	//     lpszText - Text to be copied
	// Returns:
	//     TRUE if successful; otherwise returns FALSE
	//-----------------------------------------------------------------------
	virtual bool CopyToClipboard(LPCTSTR lpszText)
	{
		if ( !OpenClipboard( ) )
			return false;

		::EmptyClipboard( );

		int iLen = (int)_tcslen( lpszText ) + 1;

		HGLOBAL hglbCopy = ::GlobalAlloc( GMEM_MOVEABLE, iLen );

		if ( hglbCopy == NULL )
		{
			::CloseClipboard( );
			return false;
		}

		LPTSTR lptstrCopy = ( TCHAR* )::GlobalLock( hglbCopy );
		memcpy(lptstrCopy, lpszText, iLen);
		::GlobalUnlock( hglbCopy );

		::SetClipboardData( CF_TEXT, hglbCopy );

		if ( !::CloseClipboard( ) )
			return false;

		return true;

	}

	//-----------------------------------------------------------------------
	// Summary:
	//     Retrieves masked text of the control
	// Parameters:
	//     iPos - Start position
	// Returns:
	//     Masked text of the control.
	//-----------------------------------------------------------------------
	virtual CString GetMaskedText(int iPos = 0)
	{
		int iWndLen = m_strWindowText.GetLength( );

		ASSERT( iWndLen == m_strLiteral.GetLength( ) ); // must be equal in length

		CString strBuffer;
		int i;
		for ( i = iPos; i < iWndLen; ++i )
		{
			if ( m_strLiteral.GetAt( i ) == m_chPrompt )
			{
				strBuffer += m_strWindowText.GetAt( i );
			}
		}

		return strBuffer;

	}


	//-----------------------------------------------------------------------
	// Summary:
	//     Call this member function to determine if a selection has been made
	// Returns:
	//     TRUE if successful; otherwise returns FALSE
	//-----------------------------------------------------------------------
	virtual BOOL SelectionMade() {
		GetSel( m_nStartChar, m_nEndChar ); return ( m_nStartChar != m_nEndChar );
	}


protected:


//{{AFX_CODEJOCK_PRIVATE
	afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
	{
		if (!CanUseMask())
		{
			TBase::OnKeyDown( nChar, nRepCnt, nFlags ); // default processing.
			return;
		}

		GetWindowText( m_strWindowText ); // refresh
		GetSel( m_nStartChar, m_nEndChar );

		if ( m_strMask.IsEmpty( ) )
		{
			TBase::OnKeyDown( nChar, nRepCnt, nFlags ); // default processing.
			return;
		}

		bool bShift = (::GetKeyState(VK_SHIFT) < 0);

		switch ( nChar )
		{
		case VK_UP:
		case VK_LEFT:
			{
				TBase::OnKeyDown( nChar, nRepCnt, nFlags );
				GetSel( m_nStartChar, m_nEndChar );

				int iStartChar = m_nStartChar;
				CorrectPosition( iStartChar, false, false );

				if ( m_nStartChar < iStartChar )
				{
					m_nStartChar = iStartChar;

					if ( !bShift )
						m_nEndChar = iStartChar;

					SetSel( m_nStartChar, m_nEndChar );
				}
			}
			return;

		case VK_DOWN:
		case VK_RIGHT:
			{
				TBase::OnKeyDown( nChar, nRepCnt, nFlags );
				GetSel( m_nStartChar, m_nEndChar );

				int iEndChar = m_nEndChar;
				CorrectPosition( iEndChar, true, false );

				if ( m_nEndChar > iEndChar )
				{
					m_nEndChar = iEndChar;

					if ( !bShift )
						m_nStartChar = iEndChar;

					SetSel( m_nStartChar, m_nEndChar );
				}
			}
			return;

		case VK_HOME:
			{
				TBase::OnKeyDown( nChar, nRepCnt, nFlags );
				GetSel( m_nStartChar, m_nEndChar );

				int iStartChar = m_nStartChar;
				CorrectPosition( iStartChar, true, false );

				if ( m_nStartChar < iStartChar )
				{
					m_nStartChar = iStartChar;

					if (!bShift)
					{
						m_nEndChar = m_nStartChar;
					}
					SetSel( m_nStartChar, m_nEndChar );
				}
			}
			return;

		case VK_END:
			{
				TBase::OnKeyDown( nChar, nRepCnt, nFlags );
				GetSel( m_nStartChar, m_nEndChar );

				int iEndChar = m_nEndChar;
				CorrectPosition( iEndChar, true, false );

				if ( m_nEndChar > iEndChar )
				{
					m_nEndChar = iEndChar;

					if ( !bShift )
						m_nStartChar = iEndChar;

					SetSel( m_nStartChar, m_nEndChar );
				}
			}
			return;

		case VK_INSERT:
			{
				if ( bShift )
				{
					MaskPaste( );
				}
				else
				{
					m_bOverType = !m_bOverType; // set the type-over flag
				}
			}
			return;

		case VK_DELETE:
			{
				if ( m_nStartChar == m_nEndChar )
				{
					if ( CorrectPosition( m_nStartChar ) )
					{
						DeleteCharAt( m_nStartChar );

						m_bRedo = false;
						m_bModified = true;
						SetWindowText( m_strWindowText );

						m_nEndChar = m_nStartChar;
						SetSel( m_nStartChar, m_nEndChar );
					}
				}
				else
				{
					MaskClear( );
				}
			}
			return;

		case VK_SPACE:
			{
				GetWindowText( m_strWindowText ); // refresh

				if ( CorrectPosition( m_nStartChar ) )
				{
					if ( m_nStartChar < m_strLiteral.GetLength( ) )
					{
						if ( ProcessMask( nChar, m_nStartChar ) )
						{
							if ( CanOverType( ) )
							{
								m_strWindowText.SetAt( m_nStartChar, ' ' );
							}
							else
							{
								InsertCharAt( m_nStartChar, ( TCHAR )nChar );
							}
						}
						else
						{
							m_strWindowText.SetAt( m_nStartChar, m_chPrompt );
						}

						m_bRedo = false;
						m_bModified = true;
						SetWindowText( m_strWindowText );

						m_nStartChar++;
						m_nEndChar = m_nStartChar;
						SetSel( m_nStartChar, m_nEndChar );
					}
					else
					{
						::MessageBeep( ( UINT )-1 );
					}
				}
			}
			return;

		case VK_BACK:
			{
				GetWindowText( m_strWindowText ); // refresh

				if ( ( m_nStartChar > 0 ) &&
					( m_nStartChar <= m_strLiteral.GetLength( ) ) )
				{
					m_nStartChar--;

					if ( CorrectPosition( m_nStartChar, false ) )
					{
						TCHAR ch = m_chPrompt;

						// get the masked literal representation.
						if ( !m_strDefault.IsEmpty( ) )
						{
							ch = m_strDefault.GetAt( m_nStartChar );
						}

						m_strWindowText.SetAt( m_nStartChar, ch );

						m_bRedo = false;
						m_bModified = true;
						SetWindowText( m_strWindowText );

						m_nEndChar = m_nStartChar;
						SetSel( m_nStartChar, m_nEndChar );
					}
				}
				else
				{
					::MessageBeep( ( UINT )-1 );
				}
			}
			return;
		}

		TBase::OnKeyDown( nChar, nRepCnt, nFlags );

	}
	afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
	{
		if (!CanUseMask())
		{
			TBase::OnChar(nChar, nRepCnt, nFlags);
			return;
		}

		switch ( nChar )
		{
		case VK_UP:
		case VK_LEFT:
		case VK_DOWN:
		case VK_RIGHT:
		case VK_HOME:
		case VK_END:
		case VK_DELETE:
		case VK_SPACE:
		case VK_BACK:
			return; // handled in WM_KEYDOWN
		}

		if (!CheckChar(nChar))
		{
			return;
		}

		if ( CanUseMask( ) )
		{
			if ( _istprint( ( TCHAR )nChar ) || IsUnicodeAlpha(( TCHAR )nChar))
			{
				int iLen = m_strLiteral.GetLength( );
				if ( m_nStartChar >= iLen )
				{
					::MessageBeep( ( UINT )-1 );
					return;
				}

				if ( m_nEndChar >= iLen )
					m_nEndChar = iLen-1;

				if ( m_nStartChar != m_nEndChar )
				{
					int i;
					for ( i = m_nStartChar; i < m_nEndChar; ++i )
					{
						if ( m_strLiteral.GetAt( i ) == m_chPrompt )
						{
							DeleteCharAt( m_nStartChar );
						}
					}
				}

				SetWindowText( m_strWindowText );

				if ( CorrectPosition( m_nStartChar ) )
				{
					if ( CanOverType( ) )
					{
						if ( m_nStartChar != m_nEndChar )
						{
							InsertCharAt( m_nStartChar, ( TCHAR )nChar );
						}
						else
						{
							m_strWindowText.SetAt( m_nStartChar, ( TCHAR )nChar );
						}
					}
					else
					{
						InsertCharAt( m_nStartChar, ( TCHAR )nChar );
					}
				}

				m_bRedo = false;
				m_bModified = true;
				SetWindowText( m_strWindowText );

				if (m_nStartChar < iLen )
					m_nStartChar++;

				if ( m_nStartChar < iLen )
					CorrectPosition( m_nStartChar );

				m_nEndChar = m_nStartChar;
				SetSel( m_nStartChar, m_nEndChar );

				return;
			}
		}

		if (nChar != 127)
			TBase::OnChar(nChar, nRepCnt, nFlags);

		// update the window text string.
		GetWindowText( m_strWindowText );

	}
	afx_msg void OnLButtonDown(UINT nFlags, CPoint point)
	{
		TBase::OnLButtonDown(nFlags, point);

		if (!CanUseMask())
		{
			return;
		}

		GetSel( m_nStartChar, m_nEndChar );
		CorrectPosition( m_nStartChar, true, false );

		if ( ::GetKeyState( VK_SHIFT ) < 0 )
			m_nEndChar = m_nStartChar;

		SetSel( m_nStartChar, m_nEndChar );

	}
	afx_msg void OnSetFocus(CWnd* pOldWnd)
	{
		TBase::OnSetFocus(pOldWnd);

		if (!CanUseMask())
		{
			return;
		}

		GetSel( m_nStartChar, m_nEndChar );
		CorrectPosition( m_nStartChar, true, false );

		m_nEndChar = m_nStartChar;
		SetSel( m_nStartChar, m_nEndChar );

	}
	afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point)
	{
		TBase::OnLButtonDblClk(nFlags, point);

		if (!CanUseMask())
		{
			return;
		}

		GetSel( m_nStartChar, m_nEndChar );
		CorrectPosition( m_nStartChar, true, false );
		CorrectPosition( m_nEndChar, true, false );

		SetSel( m_nStartChar, m_nEndChar );

	}
	afx_msg void OnUpdateEditUndo(CCmdUI* pCmdUI)
	{
		if (!CanUseMask())
		{
			pCmdUI->Enable( CanUndo( ) );
		}
		else
		{
			pCmdUI->Enable( m_bModified );
		}

	}
//}}AFX_CODEJOCK_PRIVATE

	//-----------------------------------------------------------------------
	// Summary:
	//     The framework calls this member function when the user selects an item from a menu
	// Parameters:
	//     wParam - The low-order word of wParam identifies the command ID of the menu item, control, or accelerator. The high-order word of wParam specifies the notification message if the message is from a control. If the message is from an accelerator, the high-order word is 1. If the message is from a menu, the high-order word is 0
	//     lParam - Identifies the control that sends the message if the message is from a control. Otherwise, lParam is 0.
	// Returns:
	//     An application returns nonzero if it processes this message; otherwise 0.
	//-----------------------------------------------------------------------
	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam)
	{
		switch (LOWORD(wParam))
		{
			case ID_EDIT_CUT:
				if ( !CanUseMask( )) CEdit::Cut(); else MaskCut( );
				return TRUE;

			case ID_EDIT_COPY:
				if ( !CanUseMask( )) CEdit::Copy(); else MaskCopy( );
				return TRUE;

			case ID_EDIT_PASTE:
				if ( !CanUseMask()) CEdit::Paste(); else MaskPaste( );
				return TRUE;

			case ID_EDIT_CLEAR:
				if ( !CanUseMask()) CEdit::Clear(); else MaskClear( );
				return TRUE;

			case ID_EDIT_UNDO:
				if ( !CanUseMask()) CEdit::Undo(); else MaskUndo( );
				return TRUE;

			case ID_EDIT_SELECT_ALL:
				MaskSelectAll( );
				return TRUE;
		}
		return TBase::OnCommand(wParam, lParam);
	}

protected:

	int         m_nStartChar;       // Current position of the first character in the current selection.
	int         m_nEndChar;         // Current position of the first non-selected character past the end of the current selection.
	bool        m_bUseMask;         // true to use the edit mask.
	bool        m_bOverType;        // true to over type the text, set with VK_INSERT key press.
	bool        m_bRedo;            // true to redo, or false to undo.
	bool        m_bModified;        // true if mask edit has been modified.
	TCHAR       m_chPrompt;         // Prompt character used to identify the text entry.
	CString     m_strMask;          // Buffer that holds the actual edit mask value.
	CString     m_strDefault;       // Contains the edit controls default display text.
	CString     m_strUndoBuffer;    // Holds the contents of the undo buffer.
	CString     m_strRedoBuffer;    // Holds the contents of the redo buffer.
	CString     m_strWindowText;    // Buffer that holds the actual edit text.
	CString     m_strLiteral;       // Literal format that restricts where the user can enter text.

};

//{{AFX_CODEJOCK_PRIVATE
#define ON_MASKEDIT_REFLECT\
	ON_MESSAGE_VOID(WM_CUT, MaskCut)\
	ON_MESSAGE_VOID(WM_PASTE, MaskPaste)\
	ON_MESSAGE_VOID(WM_CLEAR, MaskClear)\
	ON_MESSAGE_VOID(WM_UNDO, MaskUndo)\
	ON_MESSAGE_VOID(WM_COPY, MaskCopy)\
	ON_WM_KEYDOWN()\
	ON_WM_CHAR()\
	ON_WM_LBUTTONDOWN()\
	ON_WM_SETFOCUS()\
	ON_WM_LBUTTONDBLCLK
//}}AFX_CODEJOCK_PRIVATE
//////////////////////////////////////////////////////////////////////


#endif // #if !defined(__XTMASKEDITEX_H__)