开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTMaskEditT.h
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：34k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTMaskEditT.h：源码内容
  1. // XTMaskEditT.h interface for the CXTMaskEditT class.
  2. //
  3. // This file is a part of the XTREME TOOLKIT PRO MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. //{{AFX_CODEJOCK_PRIVATE
  22. #if !defined(__XTMASKEDITEX_H__)
  23. #define __XTMASKEDITEX_H__
  24. //}}AFX_CODEJOCK_PRIVATE
  26. #if _MSC_VER >= 1000
  27. #pragma once
  28. #endif // _MSC_VER >= 1000
  30. //////////////////////////////////////////////////////////////////////
  31. // Summary:
  32. //     CXTMaskEditT is a template class. It allows text masking to be
  33. //     applied to the control to format it for special editing restrictions.
  34. //////////////////////////////////////////////////////////////////////
  35. template <class TBase>
  36. class CXTMaskEditT : public TBase
  37. {
  39. public:
  41. //-----------------------------------------------------------------------
  42. // Summary:
  43. //     Constructs a CXTMaskEditT object
  44. //-----------------------------------------------------------------------
  45. CXTMaskEditT()
  46. : m_nStartChar(0)
  47. , m_nEndChar(0)
  48. , m_bOverType(FALSE)
  49. , m_bUseMask(TRUE)
  50. , m_bRedo(FALSE)
  51. , m_bModified(FALSE)
  52. , m_strWindowText(_T(""))
  53. , m_strMask(_T(""))
  54. , m_strLiteral(_T(""))
  55. , m_strDefault(_T(""))
  56. , m_strUndoBuffer(_T(""))
  57. , m_chPrompt(_T('_'))
  58. , m_bUpdateUndo(TRUE)
  59. {
  60. }
  62. public:
  64. //-----------------------------------------------------------------------
  65. // Parameters:
  66. //     bUseMask - TRUE to enable the mask. FALSE to disable the mask.
  67. // Summary:
  68. //     Call this member function to enable or disable the mask for the mask
  69. //     edit control.
  70. //-----------------------------------------------------------------------
  71. void SetUseMask(BOOL bUseMask) {
  72. m_bUseMask = bUseMask;
  73. }
  75. //-----------------------------------------------------------------------
  76. // Summary:
  77. //     This member function is called to determine if the mask for the edit
  78. //     control can be used.
  79. // Returns:
  80. //     TRUE if the mask can be used, otherwise returns FALSE.
  81. //-----------------------------------------------------------------------
  82. BOOL CanUseMask() const {
  83. return m_bUseMask && m_hWnd && ((GetStyle() & ES_READONLY) == 0) && !m_strMask.IsEmpty();
  84. }
  86. //-----------------------------------------------------------------------
  87. // Summary:
  88. //     This member function is called to enable or disable type over, also
  89. //     known as insert mode.
  90. // Parameters:
  91. //     bOverType - TRUE to enable type over.
  92. //-----------------------------------------------------------------------
  93. void SetOverType(BOOL bOverType) {
  94. m_bOverType = bOverType;
  95. }
  97. //-----------------------------------------------------------------------
  98. // Summary:
  99. //     This member function is called to determine if type over has been enabled.
  100. // Returns:
  101. //     TRUE if type over is enabled, otherwise returns FALSE.
  102. //-----------------------------------------------------------------------
  103. BOOL CanOverType() const {
  104. return m_bOverType;
  105. }
  107. //-----------------------------------------------------------------------
  108. // Summary:
  109. //     This member function is called to determine if the index specified
  110. //     by 'iPos' is a valid index for the currently displayed edit text.
  111. // Parameters:
  112. //     iPos - Index of the character to check.
  113. // Returns:
  114. //     TRUE if the index is valid, otherwise returns FALSE.
  115. //-----------------------------------------------------------------------
  116. BOOL PosInRange(int iPos) const {
  117. return ((iPos >= 0) && (iPos < m_strLiteral.GetLength()));
  118. }
  120. //-----------------------------------------------------------------------
  121. // Summary:
  122. //     This member function retrieves the character that is currently used as
  123. //     the mask prompt. The mask prompt indicates that the field is editable.
  124. // Returns:
  125. //     A TCHAR data type.
  126. //-----------------------------------------------------------------------
  127. TCHAR GetPromptChar() const {
  128. return m_chPrompt;
  129. }
  131. //-----------------------------------------------------------------------
  132. // Summary:
  133. //     This helper member function retrieves the string contains nLength prompt characters.
  134. // Parameters:
  135. //     nLength - Length of string to create.
  136. // Returns:
  137. //     CString contains nLength prompt characters
  138. //-----------------------------------------------------------------------
  139. CString GetPromptString(int nLength) const {
  140. CString strPrompt;
  142. while (nLength--)
  143. strPrompt += m_chPrompt;
  145. return strPrompt;
  146. }
  149. //-----------------------------------------------------------------------
  150. // Summary:
  151. //     This member function is called to set the prompt character that is
  152. //     displayed to the user that indicates the field can be edited.
  153. // Parameters:
  154. //     ch - A TCHAR data type.
  155. //     bAutoReplace - TRUE to auto replace
  156. //-----------------------------------------------------------------------
  157. void SetPromptChar(TCHAR ch, BOOL bAutoReplace = TRUE)
  158. {
  159. if (m_chPrompt == ch)
  160. return;
  162. if (bAutoReplace)
  163. {
  164. GetMaskState();
  166. for (int i = 0; i < m_strLiteral.GetLength(); i++)
  167. if (m_strLiteral[i] == m_chPrompt) m_strLiteral.SetAt(i, ch);
  169. for (int j = 0; j < m_strWindowText.GetLength(); j++)
  170. if (m_strWindowText[j] == m_chPrompt) m_strWindowText.SetAt(j, ch);
  172. SetMaskState();
  173. }
  175. m_chPrompt = ch;
  177. }
  179. //-----------------------------------------------------------------------
  180. // Summary:
  181. //     This member function is called to perform a cut operation using the
  182. //     currently selected text.
  183. //-----------------------------------------------------------------------
  184. afx_msg BOOL MaskCut()
  185. {
  186. if (!CanUseMask())
  187. return (BOOL)DefWindowProc(WM_CUT, 0, 0);
  189. MaskCopy();
  190. MaskClear();
  192. return TRUE;
  193. }
  195. //-----------------------------------------------------------------------
  196. // Summary:
  197. //     This member function is called to perform a copy operation using the
  198. //     currently selected text.
  199. //-----------------------------------------------------------------------
  200. afx_msg BOOL MaskCopy()
  201. {
  202. if (!CanUseMask())
  203. return (BOOL)DefWindowProc(WM_COPY, 0, 0);
  205. GetMaskState();
  207. CString strMaskedText = GetMaskedText(m_nStartChar, m_nEndChar);
  208. CopyToClipboard(strMaskedText);
  210. return TRUE;
  211. }
  213. //-----------------------------------------------------------------------
  214. // Summary:
  215. //     This member function is called to perform a replace operation using the
  216. //     currently selected text.
  217. // Parameters:
  218. //     lpszNewText - Text to replace.
  219. //-----------------------------------------------------------------------
  220. void MaskReplaceSel(LPCTSTR lpszNewText)
  221. {
  223. ASSERT(CanUseMask());
  225. if (m_nStartChar != m_nEndChar)
  226. MaskDeleteSel();
  228. int x = m_nStartChar, nNewTextLen = (int)_tcslen(lpszNewText);
  229. int nWindowTextLen = m_strWindowText.GetLength();
  231. if (x >= nWindowTextLen)
  232. return;
  234. for (int i = 0; i < nNewTextLen; ++i)
  235. {
  236. TCHAR ch = lpszNewText[i];
  238. if (ch == m_chPrompt || CheckChar(ch, x))
  239. {
  240. InsertCharAt(x, ch);
  241. x++;
  243. while (x < nWindowTextLen && !IsPromptPos(x))
  244. x++;
  246. if (x >= m_strWindowText.GetLength())
  247. break;
  248. }
  249. }
  250. CorrectPosition(x);
  251. m_nStartChar = m_nEndChar = x;
  252. }
  254. //-----------------------------------------------------------------------
  255. // Summary:
  256. //     This member function is called to perform a paste operation using the
  257. //     current clipboard text.
  258. //-----------------------------------------------------------------------
  259. afx_msg BOOL MaskPaste()
  260. {
  261. if (!CanUseMask())
  262. return (BOOL)DefWindowProc(WM_PASTE, 0, 0);
  264. GetMaskState();
  266. if (!OpenClipboard())
  267. return FALSE;
  269. #ifndef _UNICODE
  270. HGLOBAL hglbPaste = ::GetClipboardData(CF_TEXT);
  271. #else
  272. HGLOBAL hglbPaste = ::GetClipboardData(CF_UNICODETEXT);
  273. #endif
  275. if (hglbPaste != NULL)
  276. {
  277. TCHAR* lpszClipboard = (TCHAR*)GlobalLock(hglbPaste);
  279. MaskReplaceSel(lpszClipboard);
  281. GlobalUnlock(hglbPaste);
  283. SetMaskState();
  284. }
  285. ::CloseClipboard();
  287. return TRUE;
  288. }
  290. //-----------------------------------------------------------------------
  291. // Summary:
  292. //     This member function is called to delete the selection.
  293. //-----------------------------------------------------------------------
  294. void MaskDeleteSel()
  295. {
  296. if (m_nStartChar == m_nEndChar)
  297. return;
  299. CString strMaskedText = GetMaskedText(m_nEndChar);
  300. SetMaskedText(strMaskedText, m_nStartChar, FALSE);
  302. m_nEndChar = m_nStartChar;
  303. }
  305. //-----------------------------------------------------------------------
  306. // Summary:
  307. //     This member function is called to clear the current text selection.
  308. //-----------------------------------------------------------------------
  309. afx_msg BOOL MaskClear()
  310. {
  311. if (!CanUseMask())
  312. return (BOOL)DefWindowProc(WM_CLEAR, 0, 0);
  314. GetMaskState();
  316. MaskDeleteSel();
  318. SetMaskState();
  320. return TRUE;
  322. }
  324. //-----------------------------------------------------------------------
  325. // Summary:
  326. //     This member function is called to undo the previous action.
  327. //-----------------------------------------------------------------------
  328. afx_msg BOOL MaskUndo()
  329. {
  330. if (!CanUseMask())
  331. {
  332. return (BOOL)DefWindowProc(EM_UNDO, 0, 0);
  333. }
  334. else
  335. {
  336. MaskGetSel();
  338. if (m_bRedo)
  339. {
  340. SetWindowText(m_strRedoBuffer);
  341. }
  342. else
  343. {
  344. GetWindowText(m_strRedoBuffer);
  345. SetWindowText(m_strUndoBuffer);
  346. }
  348. m_bRedo = !m_bRedo;
  349. m_bModified = TRUE;
  351. m_nEndChar = m_nStartChar;
  352. SetSel(m_nStartChar, m_nEndChar);
  353. }
  355. return TRUE;
  356. }
  358. //-----------------------------------------------------------------------
  359. // Summary:
  360. //     This member function is called to select all text in the mask edit
  361. //     control.
  362. //-----------------------------------------------------------------------
  363. afx_msg void MaskSelectAll()
  364. {
  365. if (!CanUseMask())
  366. {
  367. SetSel(0, -1);
  368. }
  369. else
  370. {
  371. m_nStartChar = 0;
  372. CorrectPosition(m_nStartChar);
  373. SetSel(m_nStartChar, -1);
  374. }
  375. }
  377. //-----------------------------------------------------------------------}
  378. // Summary:
  379. //     This member function is called to determine if the text has been modified.
  380. // Returns:
  381. //     TRUE if the text has changed, otherwise returns FALSE.
  382. //-----------------------------------------------------------------------
  383. BOOL IsModified() const {
  384. return m_bModified;
  385. }
  387. //-----------------------------------------------------------------------
  388. // Summary:
  389. //     This method called to set masked text for the edit control.
  390. // Parameters:
  391. //     lpszMaskedText - Text string without mask.
  392. //     iPos          - Start position from which current masked text
  393. //                     will be updated.
  394. //                     Default value 0 (the first position).
  395. //     bUpdateWindow - If TRUE - edit control window text and selection
  396. //                     will be updated, otherwise only internal members
  397. //                     take changes.
  398. // Remarks:
  399. //     If a mask is used, then the mask will be applied to the text
  400. //     in lpszMaskedText.
  401. //-----------------------------------------------------------------------
  402. void SetMaskedText(LPCTSTR lpszMaskedText, int iPos = 0, BOOL bUpdateWindow = TRUE)
  403. {
  404. int nMaskedTextLength = (int)_tcslen(lpszMaskedText);
  406. m_strWindowText = m_strWindowText.Left(iPos);
  407. int nIndex = 0;
  409. for (; (iPos <  m_strLiteral.GetLength()) && (nIndex < nMaskedTextLength) ; iPos++)
  410. {
  411. TCHAR uChar = lpszMaskedText[nIndex];
  413. if (IsPromptPos(iPos) && ((uChar == m_chPrompt) || ProcessMask(uChar, iPos)))
  414. {
  415. m_strWindowText += (TCHAR)uChar;
  416. nIndex ++;
  417. }
  418. else
  419. {
  420. m_strWindowText += m_strLiteral[iPos];
  421. }
  422. }
  424. if (bUpdateWindow)
  425. {
  426. SetMaskState(FALSE);
  427. }
  428. else
  429. {
  430. CorrectWindowText();
  431. }
  432. }
  434. //-----------------------------------------------------------------------
  435. // Summary:
  436. //     This member function will set the mask for the edit control.
  437. // Parameters:
  438. //     lpszMask    - The format for the mask field. For example, if you wanted to set
  439. //                   the mask for a phone number, and you only wanted digits to be entered,
  440. //                   your mask might look like this; _T("(000) 000-0000").
  441. //     lpszLiteral - The literal format is entered here. Wherever you place an underscore
  442. //                   ('_') is where the user will be allowed to enter data only. Using
  443. //                   the phone number example; _T("(___) ___-____").
  444. //     lpszDefault - Text that is to be displayed when the control is initialized. For
  445. //                   example; _T("(800) 555-1212"). If NULL, 'lpszLiteral' is used to initialize
  446. //                   the edit text.
  447. // Remarks:
  448. //     The values that can be set are:
  449. //     <TABLE>
  450. //          <b>Mask Character</b>  <b>Description</b>
  451. //          ---------------------  ------------------------
  452. //          0                      Numeric (0-9)
  453. //          9                      Numeric (0-9) or space (' ')
  454. //          #                      Numeric (0-9) or space (' ') or ('+') or ('-')
  455. //          L                      Alpha (a-Z)
  456. //          ?                      Alpha (a-Z) or space (' ')
  457. //          A                      Alpha numeric (0-9 and a-Z)
  458. //          a                      Alpha numeric (0-9 and a-Z) or space (' ')
  459. //          &                      All print character only
  460. //          H                      Hex digit (0-9 and A-F)
  461. //          X                      Hex digit (0-9 and A-F) and space (' ')
  462. //          >                      Forces characters to upper case (A-Z)
  463. //          <                      Forces characters to lower case (a-z)
  464. //     </TABLE>
  465. //-----------------------------------------------------------------------
  466. virtual BOOL SetEditMask(LPCTSTR lpszMask, LPCTSTR lpszLiteral, LPCTSTR lpszDefault=NULL)
  467. {
  468. ASSERT(lpszMask);
  469. ASSERT(lpszLiteral);
  471. // initialize the mask for the control.
  472. m_strMask    = lpszMask;
  473. m_strLiteral = lpszLiteral;
  475. ASSERT(m_strMask.GetLength() == m_strLiteral.GetLength());
  477. if (m_strMask.GetLength() != m_strLiteral.GetLength())
  478. return FALSE;
  480. if (lpszDefault == NULL)
  481. {
  482. m_strWindowText = m_strDefault = lpszLiteral;
  483. }
  484. else
  485. {
  486. m_strWindowText = m_strDefault = lpszDefault;
  488. if (m_strDefault.GetLength() != m_strLiteral.GetLength())
  489. {
  490. SetMaskedText(m_strDefault, 0, FALSE);
  491. m_strDefault = m_strWindowText;
  492. }
  493. }
  495. ASSERT(m_strWindowText.GetLength() == m_strLiteral.GetLength());
  497. // set the window text for the control.
  498. m_bRedo = FALSE;
  499. m_bModified = FALSE;
  500. SetWindowText(m_strWindowText);
  502. m_strUndoBuffer = m_strWindowText;
  503. return TRUE;
  505. }
  507. //-----------------------------------------------------------------------
  508. // Summary:
  509. //     Converts character to Upper/Lower case.
  510. // Parameters:
  511. //     nChar - Char to be converted
  512. //     bUpperCase  - TRUE to convert to upper case
  513. // Returns:
  514. //     Converted character.
  515. //-----------------------------------------------------------------------
  516. TCHAR ConvertUnicodeAlpha(TCHAR nChar, BOOL bUpperCase) const
  517. {
  518. CString strTemp(nChar);
  519. if (bUpperCase) strTemp.MakeUpper(); else strTemp.MakeLower();
  520. return strTemp[0];
  521. }
  525. //-----------------------------------------------------------------------
  526. // Summary:
  527. //     This member function is used internally to validate the character indicated
  528. //     by 'nChar'.
  529. // Parameters:
  530. //     nChar - Contains the character code value of the key.
  531. //     nPos - Sting length.
  532. // Returns:
  533. //     TRUE if successful, otherwise returns FALSE.
  534. //-----------------------------------------------------------------------
  535. virtual BOOL CheckChar(TCHAR& nChar, int nPos)
  536. {
  537. // do not use mask
  538. if (!CanUseMask())
  539. return FALSE;
  541. // control character, OK
  542. if (!IsPrintChar(nChar))
  543. return TRUE;
  545. // make sure the string is not longer than the mask
  546. if (nPos >= m_strMask.GetLength())
  547. return FALSE;
  549. if (!IsPromptPos(nPos))
  550. return FALSE;
  552. return ProcessMask(nChar, nPos);
  553. }
  555. //-----------------------------------------------------------------------
  556. // Summary:
  557. //     This member function is used internally to process the character passed
  558. //     in by 'nChar' whose index is specified by 'nEndPos'.
  559. // Parameters:
  560. //     nChar - Contains the character code value of the key.
  561. //     nEndPos - Index of character in display string.
  562. // Returns:
  563. //     TRUE if successful, otherwise returns FALSE.
  564. //-----------------------------------------------------------------------
  565. virtual BOOL ProcessMask(TCHAR& nChar, int nEndPos)
  566. {
  567. ASSERT(nEndPos < m_strMask.GetLength());
  568. if (nEndPos < 0 || nEndPos >= m_strMask.GetLength())
  569. return FALSE;
  571. // check the key against the mask
  572. switch (m_strMask.GetAt(nEndPos))
  573. {
  574. case '0':       // digit only //completely changed this
  575. return _istdigit(nChar);
  577. case '9':       // digit or space
  578. return _istdigit(nChar) || _istspace(nChar);
  580. case '#':       // digit or space or '+' or '-'
  581. return _istdigit(nChar) || (_istspace(nChar) || nChar == _T('-') || nChar == _T('+'));
  583. case 'd':       // decimal
  584. return _istdigit(nChar) || (_istspace(nChar) || nChar == _T('-') || nChar == _T('+') || nChar == _T('.') || nChar == _T(','));
  586. case 'L':       // alpha only
  587. return IsAlphaChar(nChar);
  589. case '?':       // alpha or space
  590. return IsAlphaChar(nChar) || _istspace(nChar);
  592. case 'A':       // alpha numeric only
  593. return _istalnum(nChar) || IsAlphaChar(nChar);
  595. case 'a':       // alpha numeric or space
  596. return _istalnum(nChar) || IsAlphaChar(nChar) || _istspace(nChar);
  598. case '&':       // all print character only
  599. return IsPrintChar(nChar);
  601. case 'H':       // hex digit
  602. return _istxdigit(nChar);
  604. case 'X':       // hex digit or space
  605. return _istxdigit(nChar) || _istspace(nChar);
  607. case '>':
  608. if (IsAlphaChar(nChar))
  609. {
  610. nChar = ConvertUnicodeAlpha(nChar, TRUE);
  611. return TRUE;
  612. }
  613. return FALSE;
  615. case '<':
  616. if (IsAlphaChar(nChar))
  617. {
  618. nChar = ConvertUnicodeAlpha(nChar, FALSE);
  619. return TRUE;
  620. }
  621. return FALSE;
  622. }
  624. return FALSE;
  625. }
  627. public:
  629. //-----------------------------------------------------------------------
  630. // Summary:
  631. //     Used by class CWinApp to translate window messages before they are dispatched to theTranslateMessage andDispatchMessage Windows functions.
  632. // Parameters:
  633. //     pMsg - Points to a MSG structure that contains the message to process.
  634. // Returns:
  635. //     Nonzero if the message was translated and should not be dispatched; 0 if the message was not translated and should be dispatched.
  636. //-----------------------------------------------------------------------
  637. virtual BOOL PreTranslateMessage(MSG* pMsg)
  638. {
  639. if (!CanUseMask())
  640. return TBase::PreTranslateMessage(pMsg);
  643. // intercept Ctrl+C (copy), Ctrl+V (paste), Ctrl+X (cut) and Ctrl+Z (undo)
  644. // before CEdit base class gets a hold of them.
  646. if (pMsg->message == WM_KEYDOWN)
  647. {
  648. if (::GetKeyState(VK_SUBTRACT) < 0)
  649. {
  650. OnChar('-', 1, 1);
  651. return TRUE;
  652. }
  654. if (::GetKeyState(VK_ADD) < 0)
  655. {
  656. OnChar('+', 1, 1);
  657. return TRUE;
  658. }
  660. if (::GetKeyState(VK_CONTROL) < 0)
  661. {
  662. switch (pMsg->wParam)
  663. {
  664. case 'X':
  665. case 'x':
  666. {
  667. MaskCut();
  668. return TRUE;
  669. }
  671. case 'C':
  672. case 'c':
  673. {
  674. MaskCopy();
  675. return TRUE;
  676. }
  678. case 'V':
  679. case 'v':
  680. {
  681. MaskPaste();
  682. return TRUE;
  683. }
  685. case 'Z':
  686. case 'z':
  687. {
  688. MaskUndo();
  689. return TRUE;
  690. }
  691. }
  692. }
  694. }
  696. return TBase::PreTranslateMessage(pMsg);
  698. }
  700. //-----------------------------------------------------------------------
  701. // Summary:
  702. //     Deletes character in specified position
  703. // Parameters:
  704. //     iPos - Position for character to be deleted.
  705. //-----------------------------------------------------------------------
  706. void DeleteCharAt(int iPos)
  707. {
  708. ASSERT(PosInRange(iPos));
  710. if (!PosInRange(iPos))
  711. return;
  713. CString strMaskedText = GetMaskedText(iPos + 1) + m_chPrompt;
  715. SetMaskedText(strMaskedText, iPos, FALSE);
  716. }
  718. //-----------------------------------------------------------------------
  719. // Summary:
  720. //     Inserts character to specified position.
  721. // Parameters:
  722. //     iPos - Position to insert
  723. //     nChar - Character to be inserted
  724. //-----------------------------------------------------------------------
  725. void InsertCharAt(int iPos, TCHAR nChar)
  726. {
  727. ASSERT(PosInRange(iPos));
  729. if (!PosInRange(iPos))
  730. return;
  732. CString strMaskedText = CString(nChar) + GetMaskedText(iPos);
  734. SetMaskedText(strMaskedText, iPos, FALSE);
  735. }
  737. //-----------------------------------------------------------------------
  738. // Summary:
  739. //     Copies text to system clipboard
  740. // Parameters:
  741. //     strText - Text to be copied
  742. // Returns:
  743. //     TRUE if successful; otherwise returns FALSE
  744. //-----------------------------------------------------------------------
  745. BOOL CopyToClipboard(const CString& strText)
  746. {
  747. if (!OpenClipboard())
  748. return FALSE;
  750. ::EmptyClipboard();
  752. int iLen = (strText.GetLength() + 1) * sizeof(TCHAR);
  754. HGLOBAL hglbCopy = ::GlobalAlloc(GMEM_MOVEABLE, iLen);
  756. if (hglbCopy == NULL)
  757. {
  758. ::CloseClipboard();
  759. return FALSE;
  760. }
  762. LPTSTR lptstrCopy = (TCHAR*)GlobalLock(hglbCopy);
  763. STRCPY_S(lptstrCopy, strText.GetLength() + 1, (LPCTSTR)strText);
  764. GlobalUnlock(hglbCopy);
  766. #ifndef _UNICODE
  767. ::SetClipboardData(CF_TEXT, hglbCopy);
  768. #else
  769. ::SetClipboardData(CF_UNICODETEXT, hglbCopy);
  770. #endif
  772. if (!::CloseClipboard())
  773. return FALSE;
  775. return TRUE;
  777. }
  779. //-----------------------------------------------------------------------
  780. // Summary:
  781. //     Retrieves masked text of the control
  782. // Parameters:
  783. //     nStartPos - Start position
  784. //     nEndPos - End position
  785. // Returns:
  786. //     Masked text of the control.
  787. //-----------------------------------------------------------------------
  788. CString GetMaskedText(int nStartPos = 0, int nEndPos = -1) const
  789. {
  790. if (nEndPos == -1)
  791. nEndPos = m_strWindowText.GetLength();
  792. else
  793. nEndPos = min(nEndPos, m_strWindowText.GetLength());
  795. CString strBuffer;
  797. for (int i = nStartPos; i < nEndPos; ++i)
  798. {
  799. if (IsPromptPos(i))
  800. {
  801. strBuffer += m_strWindowText[i];
  802. }
  803. }
  805. return strBuffer;
  807. }
  810. protected:
  813. //{{AFX_CODEJOCK_PRIVATE
  814. afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
  815. {
  816. if (!CanUseMask())
  817. {
  818. TBase::OnKeyDown(nChar, nRepCnt, nFlags); // default processing.
  819. return;
  820. }
  822. BOOL bShift = (::GetKeyState(VK_SHIFT) < 0);
  823. BOOL bCtrl = (::GetKeyState(VK_CONTROL) < 0);
  825. switch (nChar)
  826. {
  827. case VK_UP:
  828. case VK_LEFT:
  829. case VK_HOME:
  830. {
  831. TBase::OnKeyDown(nChar, nRepCnt, nFlags);
  833. GetMaskState(FALSE);
  835. int iStartChar = m_nStartChar;
  836. CorrectPosition(iStartChar, FALSE);
  838. if (m_nStartChar < iStartChar)
  839. {
  840. m_nStartChar = iStartChar;
  842. if (!bShift)
  843. m_nEndChar = iStartChar;
  844. }
  846. SetMaskState();
  847. }
  848. return;
  850. case VK_DOWN:
  851. case VK_RIGHT:
  852. case VK_END:
  853. {
  854. TBase::OnKeyDown(nChar, nRepCnt, nFlags);
  856. GetMaskState(FALSE);
  858. int iEndChar = m_nEndChar;
  859. CorrectPosition(iEndChar);
  861. if (m_nEndChar > iEndChar)
  862. {
  863. m_nEndChar = iEndChar;
  865. if (!bShift)
  866. m_nStartChar = iEndChar;
  867. }
  869. SetMaskState();
  870. }
  871. return;
  874. case VK_INSERT:
  875. {
  876. if (bCtrl)
  877. {
  878. MaskCopy();
  879. }
  880. else if (bShift)
  881. {
  882. MaskPaste();
  883. }
  884. else
  885. {
  886. m_bOverType = !m_bOverType; // set the type-over flag
  887. }
  889. }
  890. return;
  892. case VK_DELETE:
  893. {
  894. GetMaskState();
  896. if (m_nStartChar == m_nEndChar)
  897. {
  898. m_nEndChar = m_nStartChar +1;
  899. }
  900. else if (bShift)
  901. {
  902. MaskCopy();
  903. }
  905. MaskDeleteSel();
  906. SetMaskState();
  907. }
  908. return;
  910. case VK_SPACE:
  911. {
  912. GetMaskState();
  914. if (!PosInRange(m_nStartChar) || !IsPromptPos(m_nStartChar))
  915. {
  916. NotifyPosNotInRange();
  917. return;
  918. }
  920. TCHAR chSpace = _T(' ');
  922. if (!ProcessMask(chSpace, m_nStartChar))
  923. chSpace = m_chPrompt;
  925. ProcessChar(chSpace);
  927. SetMaskState();
  928. }
  929. return;
  931. case VK_BACK:
  932. {
  933. GetMaskState(FALSE);
  935. if ((m_nStartChar > 0) &&
  936. (m_nStartChar <= m_strLiteral.GetLength()))
  937. {
  938. if (m_nStartChar == m_nEndChar)
  939. {
  940. m_nStartChar--;
  941. CorrectPosition(m_nStartChar, FALSE);
  943. if (m_bOverType && PosInRange(m_nStartChar))
  944. {
  945. m_strWindowText.SetAt(m_nStartChar, m_strDefault[m_nStartChar]);
  946. m_nEndChar = m_nStartChar;
  947. }
  948. }
  950. MaskDeleteSel();
  951. SetMaskState();
  952. }
  953. else
  954. {
  955. NotifyPosNotInRange();
  956. }
  957. }
  958. return;
  959. }
  961. TBase::OnKeyDown(nChar, nRepCnt, nFlags);
  963. }
  965. void ProcessChar(TCHAR nChar)
  966. {
  967. int iLen = m_strLiteral.GetLength();
  969. if (m_nStartChar >= iLen)
  970. {
  971. NotifyPosNotInRange();
  972. return;
  973. }
  975. if (m_nStartChar != m_nEndChar)
  976. {
  977. MaskDeleteSel();
  978. }
  980. ASSERT(m_nStartChar == m_nEndChar);
  982. CorrectPosition(m_nStartChar);
  984. if (CanOverType())
  985. {
  986. m_strWindowText.SetAt(m_nStartChar, nChar);
  987. }
  988. else
  989. {
  990. InsertCharAt(m_nStartChar, nChar);
  991. }
  993. if (m_nStartChar < iLen)
  994. m_nStartChar++;
  996. CorrectPosition(m_nStartChar);
  998. m_nEndChar = m_nStartChar;
  999. }
  1001. afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
  1002. {
  1003. if (!CanUseMask())
  1004. {
  1005. TBase::OnChar(nChar, nRepCnt, nFlags);
  1006. return;
  1007. }
  1009. switch (nChar)
  1010. {
  1011. case VK_UP:
  1012. case VK_LEFT:
  1013. case VK_DOWN:
  1014. case VK_RIGHT:
  1015. case VK_HOME:
  1016. case VK_END:
  1017. case VK_DELETE:
  1018. case VK_SPACE:
  1019. case VK_BACK:
  1020. return; // handled in WM_KEYDOWN
  1021. }
  1023. GetMaskState();
  1025. if (!PosInRange(m_nStartChar) || !IsPromptPos(m_nStartChar))
  1026. {
  1027. NotifyPosNotInRange();
  1028. return;
  1029. }
  1031. TCHAR ch = (TCHAR)nChar;
  1033. if (!CheckChar(ch, m_nStartChar))
  1034. {
  1035. NotifyInvalidCharacter(ch, m_strMask[m_nStartChar]);
  1036. return;
  1037. }
  1039. if (IsPrintChar(ch))
  1040. {
  1041. ProcessChar(ch);
  1042. SetMaskState(FALSE);
  1043. }
  1044. else
  1045. {
  1046. if (nChar != 127)
  1047. TBase::OnChar(nChar, nRepCnt, nFlags);
  1048. }
  1049. }
  1051. afx_msg void OnSetFocus(CWnd* pOldWnd)
  1052. {
  1053. TBase::OnSetFocus(pOldWnd);
  1055. if (!CanUseMask())
  1056. {
  1057. return;
  1058. }
  1060. MaskGetSel();
  1061. CorrectPosition(m_nStartChar);
  1063. m_nEndChar = m_nStartChar;
  1064. SetSel(m_nStartChar, m_nEndChar);
  1066. }
  1068. afx_msg void OnUpdateEditUndo(CCmdUI* pCmdUI)
  1069. {
  1070. if (!CanUseMask())
  1071. {
  1072. pCmdUI->Enable(CanUndo());
  1073. }
  1074. else
  1075. {
  1076. pCmdUI->Enable(m_bModified);
  1077. }
  1079. }
  1080. //}}AFX_CODEJOCK_PRIVATE
  1083. //{{AFX_CODEJOCK_PRIVATE
  1085. // Some goodies
  1086. BOOL CorrectPosition(int& iPos, BOOL bForward = TRUE) // used internally
  1087. {
  1088. int iLen = m_strLiteral.GetLength();
  1090. if (IsPromptPos(iPos))
  1091. return TRUE;
  1093. if (bForward)
  1094. {
  1095. for (; iPos < iLen; iPos++)
  1096. {
  1097. if (IsPromptPos(iPos))
  1098. return TRUE;
  1099. }
  1101. for (; iPos >= 0; iPos--)
  1102. {
  1103. if (IsPromptPos(iPos - 1))
  1104. return FALSE;
  1105. }
  1106. }
  1107. else
  1108. {
  1109. for (; iPos >= 0; iPos--)
  1110. {
  1111. if (IsPromptPos(iPos))
  1112. return TRUE;
  1113. }
  1115. for (; iPos < iLen; iPos++)
  1116. {
  1117. if (IsPromptPos(iPos))
  1118. return FALSE;
  1119. }
  1120. }
  1122. return FALSE;
  1123. }
  1125. virtual BOOL IsPrintChar(TCHAR nChar)
  1126. {
  1127. return _istprint(nChar) || IsAlphaChar(nChar);
  1128. }
  1129. //-----------------------------------------------------------------------
  1130. // Summary:
  1131. //     This method determines if nChar is alpha character
  1132. // Parameters:
  1133. //     nChar - Character need to test
  1134. // Returns:
  1135. //     TRUE if nChar is alpha character.
  1136. //-----------------------------------------------------------------------
  1137. virtual BOOL IsAlphaChar(TCHAR nChar)
  1138. {
  1139. if (_istalpha(nChar))
  1140. return TRUE;
  1142. if (ConvertUnicodeAlpha(nChar, TRUE) != nChar)
  1143. return TRUE;
  1145. if (ConvertUnicodeAlpha(nChar, FALSE) != nChar)
  1146. return TRUE;
  1148. return FALSE;
  1149. }
  1151. virtual void NotifyPosNotInRange()
  1152. {
  1153. ::MessageBeep((UINT)-1);
  1154. }
  1156. virtual void NotifyInvalidCharacter(TCHAR /*nChar*/, TCHAR /*chMask*/)
  1157. {
  1158. ::MessageBeep((UINT)-1);
  1159. }
  1161. BOOL IsPromptPos(int nPos) const
  1162. {
  1163. return IsPromptPos(m_strLiteral, nPos);
  1164. }
  1166. BOOL IsPromptPos(const CString& strLiteral, int nPos) const
  1167. {
  1168. return (nPos >= 0 && nPos < strLiteral.GetLength()) && (strLiteral[nPos] == m_chPrompt);
  1169. }
  1171. void CorrectWindowText()
  1172. {
  1173. int nLiteralLength = m_strLiteral.GetLength();
  1174. int nWindowTextLength = m_strWindowText.GetLength();
  1176. if (nWindowTextLength > nLiteralLength)
  1177. {
  1178. m_strWindowText = m_strWindowText.Left(nLiteralLength);
  1179. }
  1180. else if (nWindowTextLength < nLiteralLength)
  1181. {
  1182. m_strWindowText += m_strLiteral.Mid(nWindowTextLength, nLiteralLength - nWindowTextLength);
  1183. }
  1184. }
  1186. void GetMaskState(BOOL bCorrectSelection = TRUE)
  1187. {
  1188. if (!m_hWnd)
  1189. return;
  1191. ASSERT(m_bUseMask);
  1193. MaskGetSel();
  1194. GetWindowText(m_strWindowText);
  1196. ASSERT(m_strDefault.GetLength() == m_strLiteral.GetLength());
  1197. ASSERT(m_strMask.GetLength() == m_strLiteral.GetLength());
  1199. CorrectWindowText();
  1201. if (bCorrectSelection)
  1202. {
  1203. CorrectPosition(m_nStartChar);
  1204. CorrectPosition(m_nEndChar);
  1206. if (m_nEndChar < m_nStartChar)
  1207. m_nEndChar = m_nStartChar;
  1208. }
  1209. }
  1211. void MaskGetSel() // To allow CEdit and CRichEditCtrl
  1212. {
  1213. if (m_hWnd)
  1214. {
  1215. SendMessage(EM_GETSEL, (WPARAM)&m_nStartChar, (LPARAM)&m_nEndChar);
  1216. }
  1217. }
  1219. void SetMaskState(BOOL bUpdateUndo = TRUE)
  1220. {
  1221. if (!m_hWnd)
  1222. return;
  1224. ASSERT(m_bUseMask);
  1226. CString strWindowText;
  1227. GetWindowText(strWindowText);
  1229. CorrectWindowText();
  1230. HideCaret();
  1232. if (strWindowText != m_strWindowText)
  1233. {
  1234. SetWindowText(m_strWindowText);
  1236. if (bUpdateUndo || m_bUpdateUndo)
  1237. m_strUndoBuffer = strWindowText;
  1239. m_bRedo = FALSE;
  1240. m_bModified = TRUE;
  1241. }
  1243. m_bUpdateUndo = bUpdateUndo;
  1245. SetSel(m_nStartChar, m_nEndChar);
  1246. ShowCaret();
  1247. }
  1250. //}}AFX_CODEJOCK_PRIVATE
  1253. //-----------------------------------------------------------------------
  1254. // Summary:
  1255. //     The framework calls this member function when the user selects an item from a menu
  1256. // Parameters:
  1257. //     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
  1258. //     lParam - Identifies the control that sends the message if the message is from a control. Otherwise, lParam is 0.
  1259. // Returns:
  1260. //     An application returns nonzero if it processes this message; otherwise 0.
  1261. //-----------------------------------------------------------------------
  1262. virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam)
  1263. {
  1264. switch (LOWORD(wParam))
  1265. {
  1266. case ID_EDIT_CUT:
  1267. MaskCut();
  1268. return TRUE;
  1270. case ID_EDIT_COPY:
  1271. MaskCopy();
  1272. return TRUE;
  1274. case ID_EDIT_PASTE:
  1275. MaskPaste();
  1276. return TRUE;
  1278. case ID_EDIT_CLEAR:
  1279. MaskClear();
  1280. return TRUE;
  1282. case ID_EDIT_UNDO:
  1283. MaskUndo();
  1284. return TRUE;
  1286. case ID_EDIT_SELECT_ALL:
  1287. MaskSelectAll();
  1288. return TRUE;
  1289. }
  1290. return TBase::OnCommand(wParam, lParam);
  1291. }
  1293. protected:
  1295. int         m_nStartChar;       // Current position of the first character in the current selection.
  1296. int         m_nEndChar;         // Current position of the first non-selected character past the end of the current selection.
  1297. BOOL        m_bUseMask;         // TRUE to use the edit mask.
  1298. BOOL        m_bOverType;        // TRUE to over type the text, set with VK_INSERT key press.
  1299. BOOL        m_bRedo;            // TRUE to redo, or FALSE to undo.
  1300. BOOL        m_bModified;        // TRUE if mask edit has been modified.
  1301. TCHAR       m_chPrompt;         // Prompt character used to identify the text entry.
  1302. CString     m_strMask;          // Buffer that holds the actual edit mask value.
  1303. CString     m_strDefault;       // Contains the edit controls default display text.
  1304. CString     m_strUndoBuffer;    // Holds the contents of the undo buffer.
  1305. CString     m_strRedoBuffer;    // Holds the contents of the redo buffer.
  1306. CString     m_strWindowText;    // Buffer that holds the actual edit text.
  1307. CString     m_strLiteral;       // Literal format that restricts where the user can enter text.
  1308. BOOL        m_bUpdateUndo;      // TRUE to update undo
  1309. };
  1311. //{{AFX_CODEJOCK_PRIVATE
  1312. #define ON_MESSAGE_BOOL(message, memberFxn) 
  1313. { message, 0, 0, 0, AfxSig_bv, 
  1314. (AFX_PMSG)(AFX_PMSGW)(BOOL (AFX_MSG_CALL CWnd::*)(void))&memberFxn },
  1316. #define ON_MASKEDIT_REFLECT
  1317. ON_MESSAGE_BOOL(WM_CUT, MaskCut)
  1318. ON_MESSAGE_BOOL(WM_PASTE, MaskPaste)
  1319. ON_MESSAGE_BOOL(WM_CLEAR, MaskClear)
  1320. ON_MESSAGE_BOOL(WM_UNDO, MaskUndo)
  1321. ON_MESSAGE_BOOL(WM_COPY, MaskCopy)
  1322. ON_WM_KEYDOWN()
  1323. ON_WM_CHAR()
  1324. ON_WM_SETFOCUS
  1326. //}}AFX_CODEJOCK_PRIVATE
  1327. //////////////////////////////////////////////////////////////////////
  1330. #endif // #if !defined(__XTMASKEDITEX_H__)