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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 查看源码
ExtEdit.cpp
资源名称：profuis288_freeware.zip　[点击查看]
上传用户：sesekoo
上传日期：2020-07-18
资源大小：21543k
文件大小：204k
源码类别：

界面编程

开发平台：

Visual C++

ExtEdit.cpp：源码内容
  1. , m_fnValidation( fnValidation )
  2. , m_fnConversion( fnConversion )
  3. , m_clrSymbol( COLORREF(-1L) )
  4. {
  5. }
  7. CExtEditWithBehavior::CBehaviorMasked::CharRule::CharRule( COLORREF clrSymbol, __EXT_MFC_SAFE_TCHAR cSymbol, ValidationFunction fnValidation, ConversionFunction fnConversion /*= NULL*/ )
  8. : m_cSymbol( cSymbol )
  9. , m_fnValidation( fnValidation )
  10. , m_fnConversion( fnConversion )
  11. , m_clrSymbol( clrSymbol )
  12. {
  13. }
  15. CExtEditWithBehavior::CBehaviorMasked::CharRule::~CharRule()
  16. {
  17. }
  19. bool CExtEditWithBehavior::CBehaviorMasked::CharRule::Validate( __EXT_MFC_SAFE_TCHAR _tchr ) const
  20. {
  21. if( m_fnValidation != NULL )
  22. return ( m_fnValidation( _tchr ) != 0 ) ? true : false;
  23. return true;
  24. }
  26. __EXT_MFC_SAFE_TCHAR CExtEditWithBehavior::CBehaviorMasked::CharRule::Convert( __EXT_MFC_SAFE_TCHAR _tchr ) const
  27. {
  28. if( m_fnConversion != NULL )
  29. return (TCHAR)m_fnConversion( _tchr );
  30. return _tchr;
  31. }
  33. void CExtEditWithBehavior::CBehaviorMasked::CharRule::Set(__EXT_MFC_SAFE_TCHAR cSymbol)
  34. {
  35. m_cSymbol = cSymbol;
  36. }
  38. __EXT_MFC_SAFE_TCHAR CExtEditWithBehavior::CBehaviorMasked::CharRule::Get() const
  39. {
  40. return m_cSymbol;
  41. }
  43. CExtEditWithBehavior::CBehaviorMasked::CharRule::operator __EXT_MFC_SAFE_TCHAR() const
  44. {
  45. return m_cSymbol;
  46. }
  48. //void CExtEditWithBehavior::OnChange() 
  49. //{
  50. //}
  51. //
  52. //void CExtEditWithBehavior::OnUpdate() 
  53. //{
  54. //}
  56. void CExtEditWithBehavior::CBehaviorMasked::CharRule::Serialize( CArchive & ar )
  57. {
  58. if( ar.IsStoring() )
  59. {
  60. ar << DWORD(TCHAR(__EXT_MFC_SAFE_TCHAR(m_cSymbol)));
  61. ar << DWORD(m_clrSymbol);
  62. }
  63. else
  64. {
  65. DWORD dwTmp;
  66. ar >> dwTmp;
  67. m_cSymbol = (__EXT_MFC_SAFE_TCHAR)(TCHAR)(dwTmp);
  68. ar >> dwTmp;
  69. m_clrSymbol = (COLORREF)dwTmp;
  70. }
  71. }
  73. void CExtEditWithBehavior::CBehaviorMasked::CharRuleArray::Serialize( CArchive & ar )
  74. {
  75. DWORD dwIndex, dwCount;
  76. if( ar.IsStoring() )
  77. {
  78. dwCount = DWORD( GetSize() );
  79. ar << dwCount;
  80. }
  81. else
  82. {
  83. RemoveAll();
  84. ar >> dwCount;
  85. SetSize( INT(dwCount) );
  86. }
  87. for( dwIndex = 0; dwIndex < dwCount; dwIndex ++ )
  88. {
  89. CharRule & _cr = ElementAt( INT(dwIndex) );
  90. _cr.Serialize( ar );
  91. }
  92. }
  94. /////////////////////////////////////////////////////////////////////////////
  95. // CExtEditMasked
  97. IMPLEMENT_DYNCREATE( CExtEditMasked, CExtEditWithBehavior );
  99. CExtEditMasked::CExtEditMasked(
  100. __EXT_MFC_SAFE_LPCTSTR strMask // = _T("")
  101. )
  102. : CBehaviorMasked( strMask )
  103. , m_clrDefault( COLORREF(-1L) )
  104. {
  105. m_pEditWithBehaviorWnd = this;
  106. }
  108. BEGIN_MESSAGE_MAP( CExtEditMasked, CExtEditWithBehavior )
  109. //{{AFX_MSG_MAP(CExtEditMasked)
  110. ON_WM_CHAR()
  111. ON_WM_KEYDOWN()
  112. ON_WM_KILLFOCUS()
  113. //}}AFX_MSG_MAP
  114. END_MESSAGE_MAP()
  116. void CExtEditMasked::_Rich_OnDraw()
  117. {
  118. ASSERT_VALID( this );
  119. if( ! m_bRichMode )
  120. return;
  121. if( GetSafeHwnd() == NULL )
  122. return;
  123. if( m_bRichPainting )
  124. return;
  125. m_bRichPainting = true;
  126. CExtSafeString strText = TextGet();
  127. CExtSafeString strMask = MaskGet();
  128. INT nTextLen = INT( strText.GetLength() );
  129. INT nMaskLen = INT( strMask.GetLength() );
  130. INT nWalkLen = min( nTextLen, nMaskLen );
  131. if( nWalkLen > 0 )
  132. {
  133. COLORREF clrDefault = m_clrDefault;
  134. if( clrDefault == COLORREF(-1L) )
  135. {
  136. if( IsWindowEnabled() && ( GetStyle() & ES_READONLY ) == 0 )
  137. clrDefault = ::GetSysColor( COLOR_WINDOWTEXT );
  138. else
  139. clrDefault = ::GetSysColor( COLOR_3DSHADOW );
  140. }
  141. CHARFORMAT cfDefault;
  142. ::memset( &cfDefault, 0, sizeof(CHARFORMAT) );
  143. cfDefault.dwMask = CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_STRIKEOUT|CFM_FACE|CFM_SIZE|CFM_CHARSET|CFM_PROTECTED|CFM_COLOR;
  144. cfDefault.dwEffects = CFE_PROTECTED; 
  145. CFont * pFont = GetFont();
  146. if( pFont->GetSafeHandle() == NULL )
  147. {
  148. CWnd * pWndParent = GetParent();
  149. if( pWndParent->GetSafeHwnd() != NULL )
  150. pFont = pWndParent->GetFont();
  151. if( pFont->GetSafeHandle() == NULL )
  152. pFont = &(PmBridge_GetPM()->m_FontNormal);
  153. }
  154. LOGFONT _lf; ::memset( &_lf, 0, sizeof(LOGFONT) );
  155. pFont->GetLogFont( &_lf );
  156. #if (! defined _RICHEDIT_VER )
  157. USES_CONVERSION;
  158. strcpy( cfDefault.szFaceName, T2CA(_lf.lfFaceName) );
  159. #else
  160. #if ( _RICHEDIT_VER < 0x0200 )
  161. USES_CONVERSION;
  162. strcpy( cfDefault.szFaceName, T2CA(_lf.lfFaceName) );
  163. #else
  164. __EXT_MFC_STRCPY( cfDefault.szFaceName, sizeof(cfDefault.szFaceName)/sizeof(cfDefault.szFaceName[0]), _lf.lfFaceName );
  165. #endif
  166. #endif
  167. CWindowDC dcDesktop( NULL );
  168. cfDefault.yHeight = ::MulDiv( _lf.lfHeight, 72 * 20, dcDesktop.GetDeviceCaps( LOGPIXELSY ) );
  169. cfDefault.yHeight = abs( cfDefault.yHeight );
  170. bool bEnabled = IsWindowEnabled() ? true : false, bReadOnly = ( ( GetStyle() & ES_READONLY ) != 0 ) ? true : false;
  171. cfDefault.crTextColor = bEnabled ? ( bReadOnly ? m_clrRichTextReadOnly : m_clrRichTextNormal ) : m_clrRichTextDisabled;
  172. if( cfDefault.crTextColor == COLORREF(-1L) )
  173. {
  174. if( bEnabled )
  175. {
  176. if( bReadOnly )
  177. cfDefault.crTextColor = ::GetSysColor( COLOR_3DSHADOW );
  178. else
  179. cfDefault.crTextColor = ::GetSysColor( COLOR_WINDOWTEXT );
  180. }
  181. else
  182. cfDefault.crTextColor = ::GetSysColor( COLOR_GRAYTEXT );
  183. }
  184. COLORREF clrBack = OnQueryBackColor();
  185. if( clrBack == COLORREF(-1L) )
  186. {
  187. clrBack = bEnabled ? ( bReadOnly ? m_clrRichBackReadOnly : m_clrRichBackNormal ) : m_clrRichBackDisabled;
  188. if( clrBack == COLORREF(-1L) )
  189. {
  190. if( bEnabled )
  191. {
  192. if( bReadOnly )
  193. clrBack = ::GetSysColor( COLOR_3DFACE );
  194. else
  195. clrBack = ::GetSysColor( COLOR_WINDOW );
  196. }
  197. else
  198. clrBack = ::GetSysColor( COLOR_3DFACE );
  199. }
  200. }
  201. Rich_SetBackgroundColor( FALSE, clrBack );
  202. Rich_HideSelection( true, false );
  203. CHARRANGE crRestore;
  204. Rich_GetSel( crRestore );
  205. Rich_SetSel( 0, -1 ); 
  206. SendMessage( EM_SETCHARFORMAT, SCF_DEFAULT, LPARAM(&cfDefault) );
  207. SendMessage( EM_SETCHARFORMAT, SCF_SELECTION, LPARAM(&cfDefault) );
  208. Rich_SetSelectionColor( cfDefault.crTextColor );
  209. CharRuleArray & arrCharRules = GetSymbolArray();
  210. INT nWalkIndex;
  211. for( nWalkIndex = 0; nWalkIndex < nWalkLen; nWalkIndex ++ )
  212. {
  213. TCHAR tchrMask = strMask[ nWalkIndex ];
  214. INT nRuleNo = arrCharRules.FindPos( tchrMask );
  215. if( nRuleNo < 0 )
  216. continue;
  217. CharRule & theCharRule = arrCharRules.ElementAt( nRuleNo );
  218. if( theCharRule.m_clrSymbol == COLORREF(-1L) )
  219. continue;
  220. Rich_SetSel( nWalkIndex, ( nWalkIndex + 1 ) );
  221. Rich_SetSelectionColor( theCharRule.m_clrSymbol );
  222. }
  223. Rich_SetSel( crRestore );
  224. Rich_HideSelection( false, false );
  225. } // if( nWalkLen > 0 )
  226. m_bRichPainting = false;
  227. }
  229. CExtSafeString CExtEditMasked::TextGetValid() const
  230. {
  231. ASSERT_VALID( this );
  232. return Behavior_GetValidText();
  233. }
  235. #ifndef _UNICODE
  236. int CExtEditMasked::stat_IsCharDigit( UINT c ) { return _istdigit( (TCHAR)c ); } // similar to _istdigit()
  237. int CExtEditMasked::stat_IsCharAlpha( UINT c ) { return IsCharAlpha( (TCHAR)c ); } // similar to _istalpha()
  238. int CExtEditMasked::stat_IsCharAlphaOrDigit( UINT c ) { return IsCharAlphaNumeric( (TCHAR)c ); } // similar to _istalnum()
  239. #else
  240. int CExtEditMasked::stat_IsCharDigit( __EXT_MFC_SAFE_TCHAR c ) { return _istdigit( (TCHAR)c ); } // similar to _istdigit()
  241. int CExtEditMasked::stat_IsCharAlpha( __EXT_MFC_SAFE_TCHAR c ) { return IsCharAlpha( (TCHAR)c ); } // similar to _istalpha()
  242. int CExtEditMasked::stat_IsCharAlphaOrDigit( __EXT_MFC_SAFE_TCHAR c ) { return IsCharAlphaNumeric( (TCHAR)c ); } // similar to _istalnum()
  243. #endif
  245. void CExtEditMasked::OnChar( UINT uChar, UINT nRepCnt, UINT nFlags )
  246. {
  247. ASSERT_VALID( this );
  248. Behavior_OnChar( uChar, nRepCnt, nFlags );
  249. // _Rich_OnDraw();
  250. }
  252. void CExtEditMasked::OnKeyDown( UINT uChar, UINT nRepCnt, UINT nFlags )
  253. {
  254. ASSERT_VALID( this );
  255. Behavior_OnKeyDown( uChar, nRepCnt, nFlags );
  256. }
  258. void CExtEditMasked::OnKillFocus( CWnd * pNewWnd )
  259. {
  260. ASSERT_VALID( this );
  261. Behavior_OnKillFocus( pNewWnd );
  262. }
  264. /////////////////////////////////////////////////////////////////////////////
  265. // CExtEditSystemNumberCurrencyBase window
  267. IMPLEMENT_DYNAMIC( CExtEditSystemNumberCurrencyBase, CExtEditWithBehavior );
  269. CExtEditSystemNumberCurrencyBase::CExtEditSystemNumberCurrencyBase(
  270. INT nMaxWholeDigits, // = __EXT_MFC_DEFAULT_MAX_WHOLE_DIGITS
  271. INT nMaxFractionDigits // = __EXT_MFC_DEFAULT_FRACTION_WHOLE_DIGITS
  272. )
  273. : m_nMaxWholeDigits( nMaxWholeDigits >= 0 ? nMaxWholeDigits : (-nMaxWholeDigits) )
  274. , m_nMaxFractionDigits( nMaxFractionDigits )
  275. , m_nNegSignMatch( 0 )
  276. , m_strNegativeSign( _T("-") )
  277. , m_strDecimalPoint( _T('.') )
  278. , m_strGroupSeparator( _T(',') )
  279. , m_nNegativeFormatIndex( 0 )
  280. , m_nPositiveFormatIndex( 0 )
  281. , m_lfMin( __EXT_MFC_SYSTEM_NUMBER_MIN )
  282. , m_lfMax( __EXT_MFC_SYSTEM_NUMBER_MAX )
  283. , m_bAdjustingSeparators( false )
  284. , m_bBackspace( false )
  285. , m_nStartSel( -1 )
  286. , m_nEndSel( -1 )
  287. , m_clrNumber( COLORREF(-1L) )
  288. , m_clrFraction( COLORREF(-1L) )
  289. , m_clrGroupSeparator( COLORREF(-1L) )
  290. , m_clrDecimalSeparator( COLORREF(-1L) )
  291. , m_clrSign( COLORREF(-1L) )
  292. , m_clrBrackets( COLORREF(-1L) )
  293. , m_strCurrencySymbol( _T("$") )
  294. {
  295. ASSERT( m_nMaxWholeDigits > 0 ); // must have at least 1 digit to the left of the decimal
  296. ASSERT( m_nMaxFractionDigits >= 0 ); // decimal places must be positive
  297. m_pEditWithBehaviorWnd = this;
  298. if( nMaxWholeDigits < 0 )
  299. CBehaviorBase::m_nBehaviorFlags |= __ESE_DISABLE_NEGATIVE;
  300. }
  302. CExtEditSystemNumberCurrencyBase::~CExtEditSystemNumberCurrencyBase()
  303. {
  304. }
  306. BEGIN_MESSAGE_MAP( CExtEditSystemNumberCurrencyBase, CExtEditWithBehavior )
  307. //{{AFX_MSG_MAP(CExtEditWithBehavior)
  308. ON_WM_CHAR()
  309. ON_WM_KEYDOWN()
  310. ON_WM_KILLFOCUS()
  311. ON_MESSAGE( WM_PASTE, OnPaste )
  312. //}}AFX_MSG_MAP
  313. END_MESSAGE_MAP()
  315. void CExtEditSystemNumberCurrencyBase::CurrencySet( const CURRENCY & _cy )
  316. {
  317. ASSERT_VALID( this );
  318. long double lfVal = ((long double)_cy.int64) / ((long double)10000.0);
  319. LongDoubleSet( lfVal );
  320. }
  322. COleCurrency CExtEditSystemNumberCurrencyBase::CurrencyGet() const
  323. {
  324. ASSERT_VALID( this );
  325. long double lfVal = LongDoubleGet() * ((long double)10000.0);
  326. COleCurrency _oleCurrency;
  327. _oleCurrency.m_cur.int64 = (LONGLONG)lfVal;
  328. return _oleCurrency;
  329. }
  331. void CExtEditSystemNumberCurrencyBase::LongDoubleSet( long double lfValue, bool bTrimTrailingZeros /*= true*/ )
  332. {
  333. ASSERT_VALID( this );
  334. if( GetSafeHwnd() == NULL )
  335. return;
  336. m_pEditWithBehaviorWnd->SetWindowText( _GetDoubleText( lfValue, bTrimTrailingZeros ) );
  337. }
  339. void CExtEditSystemNumberCurrencyBase::MaxWholeDigitsSet( INT nMaxWholeDigits )
  340. {
  341. ASSERT_VALID( this );
  342. ASSERT( nMaxWholeDigits );
  343. bool bAllowNegative = (nMaxWholeDigits >= 0);
  344. if( nMaxWholeDigits < 0 )
  345. nMaxWholeDigits = -nMaxWholeDigits;
  346. if( m_nMaxWholeDigits == nMaxWholeDigits && AllowNegativeGet() == bAllowNegative )
  347. return;
  348. m_nMaxWholeDigits = nMaxWholeDigits;
  349. if( ! _FlagsModify( bAllowNegative ? 0 : __ESE_DISABLE_NEGATIVE, bAllowNegative ? __ESE_DISABLE_NEGATIVE : 0 ) )
  350. _Redraw();
  351. }
  353. INT CExtEditSystemNumberCurrencyBase::MaxWholeDigitsGet() const
  354. {
  355. ASSERT_VALID( this );
  356. return m_nMaxWholeDigits;
  357. }
  359. void CExtEditSystemNumberCurrencyBase::MaxFractionDigitsSet( INT nMaxFractionDigits )
  360. {
  361. ASSERT_VALID( this );
  362. ASSERT( nMaxFractionDigits >= 0 );
  363. if( m_nMaxFractionDigits == nMaxFractionDigits )
  364. return;
  365. m_nMaxFractionDigits = nMaxFractionDigits;
  366. _Redraw();
  367. }
  369. INT CExtEditSystemNumberCurrencyBase::MaxFractionDigitsGet() const
  370. {
  371. ASSERT_VALID( this );
  372. return m_nMaxFractionDigits;
  373. }
  375. void CExtEditSystemNumberCurrencyBase::AllowNegativeSet( bool bAllowNegative /*= true*/ )
  376. {
  377. ASSERT_VALID( this );
  378. _FlagsModify( bAllowNegative ? 0 : __ESE_DISABLE_NEGATIVE, bAllowNegative ? __ESE_DISABLE_NEGATIVE : 0 );
  379. }
  381. bool CExtEditSystemNumberCurrencyBase::AllowNegativeGet() const
  382. {
  383. ASSERT_VALID( this );
  384. bool bAllowNegative = ( ( CBehaviorBase::m_nBehaviorFlags & __ESE_DISABLE_NEGATIVE ) != 0 ) ? false : true;
  385. return bAllowNegative;
  386. }
  388. void CExtEditSystemNumberCurrencyBase::RangeSet( long double lfMin, long double lfMax )
  389. {
  390. ASSERT_VALID( this );
  391. ASSERT( lfMin <= lfMax );
  392. m_lfMin = lfMin;
  393. m_lfMax = lfMax;
  394. _AdjustWithinRange();
  395. _Redraw();
  396. }
  398. void CExtEditSystemNumberCurrencyBase::RangeGet( long double * p_lfMin, long double * p_lfMax ) const
  399. {
  400. ASSERT_VALID( this );
  401. if( p_lfMin != NULL )
  402. (*p_lfMin) = m_lfMin;
  403. if( p_lfMax != NULL )
  404. (*p_lfMax) = m_lfMax;
  405. }
  407. void CExtEditSystemNumberCurrencyBase::NumberColorSet( COLORREF clrNumber /* = COLORREF(-1L) */ )
  408. {
  409. ASSERT_VALID( this );
  410. if( m_clrNumber == clrNumber )
  411. return;
  412. m_clrNumber = clrNumber;
  413. _Rich_OnDraw();
  414. }
  416. COLORREF CExtEditSystemNumberCurrencyBase::NumberColorGet() const
  417. {
  418. ASSERT_VALID( this );
  419. return m_clrNumber;
  420. }
  422. void CExtEditSystemNumberCurrencyBase::FractionColorSet( COLORREF clrFraction /* = COLORREF(-1L) */ )
  423. {
  424. ASSERT_VALID( this );
  425. if( m_clrFraction == clrFraction )
  426. return;
  427. m_clrFraction = clrFraction;
  428. _Rich_OnDraw();
  429. }
  431. COLORREF CExtEditSystemNumberCurrencyBase::FractionColorGet() const
  432. {
  433. ASSERT_VALID( this );
  434. return m_clrFraction;
  435. }
  437. void CExtEditSystemNumberCurrencyBase::GroupSeparatorColorSet( COLORREF clrGroupSeparator /* = COLORREF(-1L) */ )
  438. {
  439. ASSERT_VALID( this );
  440. if( m_clrGroupSeparator == clrGroupSeparator )
  441. return;
  442. m_clrGroupSeparator = clrGroupSeparator;
  443. _Rich_OnDraw();
  444. }
  446. COLORREF CExtEditSystemNumberCurrencyBase::GroupSeparatorColorGet() const
  447. {
  448. ASSERT_VALID( this );
  449. return m_clrGroupSeparator;
  450. }
  452. void CExtEditSystemNumberCurrencyBase::DecimalSeparatorColorSet( COLORREF clrDecimalSeparator /* = COLORREF(-1L) */ )
  453. {
  454. ASSERT_VALID( this );
  455. if( m_clrDecimalSeparator == clrDecimalSeparator )
  456. return;
  457. m_clrDecimalSeparator = clrDecimalSeparator;
  458. _Rich_OnDraw();
  459. }
  461. COLORREF CExtEditSystemNumberCurrencyBase::DecimalSeparatorColorGet() const
  462. {
  463. ASSERT_VALID( this );
  464. return m_clrDecimalSeparator;
  465. }
  467. void CExtEditSystemNumberCurrencyBase::SignColorSet( COLORREF clrSign /* = COLORREF(-1L) */ )
  468. {
  469. ASSERT_VALID( this );
  470. if( m_clrSign == clrSign )
  471. return;
  472. m_clrSign = clrSign;
  473. _Rich_OnDraw();
  474. }
  476. COLORREF CExtEditSystemNumberCurrencyBase::SignColorGet() const
  477. {
  478. ASSERT_VALID( this );
  479. return m_clrSign;
  480. }
  482. void CExtEditSystemNumberCurrencyBase::BracketsColorSet( COLORREF clrBrackets /* = COLORREF(-1L) */ )
  483. {
  484. ASSERT_VALID( this );
  485. if( m_clrBrackets == clrBrackets )
  486. return;
  487. m_clrBrackets = clrBrackets;
  488. _Rich_OnDraw();
  489. }
  491. COLORREF CExtEditSystemNumberCurrencyBase::BracketsColorGet() const
  492. {
  493. ASSERT_VALID( this );
  494. return m_clrBrackets;
  495. }
  497. bool CExtEditSystemNumberCurrencyBase::_IsValid() const
  498. {
  499. ASSERT_VALID( this );
  500. long double lfValue = LongDoubleGet();
  501. bool bRetVal = ( m_lfMin <= lfValue && lfValue <= m_lfMax ) ? true : false;
  502. return bRetVal;
  503. }
  505. INT CExtEditSystemNumberCurrencyBase::_GetGroupSeparatorCount( const CExtSafeString & strText ) const
  506. {
  507. ASSERT_VALID( this );
  508. INT nPos = 0, nSepCount = 0;
  509. for( ; true; )
  510. {
  511. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  512. if( nPos == -1 )
  513. break;
  514. nSepCount ++;
  515. nPos ++;
  516. }
  517. return nSepCount;
  518. }
  520. void CExtEditSystemNumberCurrencyBase::_AdjustSeparators( 
  521. INT nCurrentSeparatorCount, 
  522. bool bDecimalPoint // = false
  523. )
  524. {
  525. ASSERT_VALID( this );
  526. nCurrentSeparatorCount; 
  527. bDecimalPoint;
  528. m_bAdjustingSeparators = true;
  529. CExtSafeString strText = Behavior_GetValidText( true );
  530. m_bAdjustingSeparators = false;
  531. }
  533. void CExtEditSystemNumberCurrencyBase::stat_InsertZeros( CExtSafeString * pStrText, INT nPos, INT nCount )
  534. {
  535. ASSERT( pStrText != NULL );
  536. if( nPos < 0 && nCount > 0 )
  537. nPos = INT( pStrText->GetLength() );
  538. for( INT iZero = 0; iZero < nCount; iZero++ )
  539. pStrText->Insert( nPos, _T('0') );
  540. }
  542. CExtSafeString CExtEditSystemNumberCurrencyBase::TextGetValid() const
  543. {
  544. ASSERT_VALID( this );
  545. return Behavior_GetValidText();
  546. }
  548. void CExtEditSystemNumberCurrencyBase::OnChar( UINT uChar, UINT nRepCnt, UINT nFlags )
  549. {
  550. ASSERT_VALID( this );
  551. Behavior_OnChar( uChar, nRepCnt, nFlags );
  552. // _Rich_OnDraw();
  553. }
  555. void CExtEditSystemNumberCurrencyBase::OnKeyDown( UINT uChar, UINT nRepCnt, UINT nFlags )
  556. {
  557. ASSERT_VALID( this );
  558. Behavior_OnKeyDown( uChar, nRepCnt, nFlags );
  559. }
  561. void CExtEditSystemNumberCurrencyBase::OnKillFocus( CWnd * pNewWnd )
  562. {
  563. ASSERT_VALID( this );
  564. Behavior_OnKillFocus( pNewWnd );
  565. }
  567. LRESULT CExtEditSystemNumberCurrencyBase::OnPaste( WPARAM wParam, LPARAM lParam )
  568. {
  569. ASSERT_VALID( this );
  570. if( ( GetStyle() & ES_READONLY ) != 0 )
  571. return 0;
  572. LRESULT lResult = Behavior_OnPaste( wParam, lParam );
  573. return lResult;
  574. }
  576. void CExtEditSystemNumberCurrencyBase::_CheckFlags()
  577. {
  578. ASSERT_VALID( this );
  579. if( GetSafeHwnd() == NULL )
  580. return;
  581. // test whether value is empty
  582. CExtSafeString strOriginalText = _GetNumericText( m_pEditWithBehaviorWnd->TextGet() );
  583. CExtSafeString strText = strOriginalText;
  584. INT nLen = INT( strText.GetLength() );
  585. // optionally remove any extra leading zeros but always leave one in front of the decimal point
  586. if( ( CBehaviorBase::m_nBehaviorFlags & __ESE_KF_REMOVE_EXTRA_LEADING_ZEROS ) != 0 && nLen > 0 )
  587. {
  588. bool bIsNegative = _IsNegative( strText );
  589. INT _nStart = 0, _nEnd = 0;
  590. _GetTextWithoutMarks( strText, _nStart, _nEnd );
  591. strText.TrimLeft( _T('0') );
  592. INT nDecimalSignPos = (INT)strText.Find( m_strDecimalPoint );
  593. if( strText.IsEmpty() || nDecimalSignPos == 0 )
  594. strText.Insert( 0, _T('0') );
  595. _GetTextWithMarks( strText, _nStart, _nEnd, bIsNegative );
  596. }
  597. else if( nLen == 0 && ( CBehaviorBase::m_nBehaviorFlags & __ESE_KF_DONT_PAD_WITH_ZEROS_IF_EMPTY ) != 0 )
  598. return;
  599. // test whether we need to pad the number with zeros after decimal point
  600. if( ( CBehaviorBase::m_nBehaviorFlags & __ESE_KF_PAD_WITH_ZEROS_AFTER_DECIMAL ) != 0 && m_nMaxFractionDigits > 0 )
  601. {
  602. bool bIsNegative = _IsNegative( strText );
  603. INT _nStart = 0, _nEnd = 0;
  604. _GetTextWithoutMarks( strText, _nStart, _nEnd );
  605. INT nDecimalSignPos = (INT)strText.Find( m_strDecimalPoint );
  606. INT nLen = INT( strText.GetLength() );
  607. if( nDecimalSignPos < 0 )
  608. {
  609. if( nLen == 0 )
  610. {
  611. strText = _T('0');
  612. nLen = (INT)strText.GetLength();
  613. }
  614. strText += m_strDecimalPoint;
  615. nDecimalSignPos = (INT)strText.Find( m_strDecimalPoint );
  616. }
  617. INT _nRightPartLen = (INT)strText.Mid( nDecimalSignPos + (INT)m_strDecimalPoint.GetLength() ).GetLength();
  618. if( _nRightPartLen > m_nMaxFractionDigits )
  619. strText.Delete( nDecimalSignPos + m_nMaxFractionDigits + m_strDecimalPoint.GetLength() );
  620. stat_InsertZeros( &strText, -1, m_nMaxFractionDigits - _nRightPartLen );
  621. _GetTextWithoutMarks( strText, _nStart, _nEnd );
  622. _GetTextWithMarks( strText, _nStart, _nEnd, bIsNegative );
  623. }
  624. // test whether we need to pad the number with zeros before the decimal point
  625. if( ( CBehaviorBase::m_nBehaviorFlags & __ESE_KF_PAD_WITH_ZEROS_BEFORE_DECIMAL ) != 0 && m_nMaxWholeDigits > 0 )
  626. {
  627. bool bIsNegative = _IsNegative( strText );
  628. INT _nStart = 0, _nEnd = 0;
  629. _GetTextWithoutMarks( strText, _nStart, _nEnd );
  630. INT nDecimalSignPos = (INT)strText.Find( m_strDecimalPoint );
  631. INT nLen = INT( strText.GetLength() );
  632. INT nZeroCount = 0, nZeroPos = -1;
  633. if( nDecimalSignPos < 0 )
  634. {
  635. nZeroCount = m_nMaxWholeDigits - nLen;
  636. nZeroPos = nLen;
  637. }
  638. else
  639. {
  640. nZeroCount = m_nMaxWholeDigits - nDecimalSignPos;
  641. nZeroPos = nDecimalSignPos;
  642. }
  643. stat_InsertZeros( &strText, nZeroPos, nZeroCount );
  644. _GetTextWithoutMarks( strText, _nStart, _nEnd );
  645. _GetTextWithMarks( strText, _nStart, _nEnd, bIsNegative );
  646. }
  647. if( strText != strOriginalText )
  648. m_pEditWithBehaviorWnd->SetWindowText( strText );
  649. }
  651. void CExtEditSystemNumberCurrencyBase::Behavior_OnKeyDown( UINT uChar, UINT nRepCnt, UINT nFlags ) 
  652. {
  653. ASSERT_VALID( this );
  654. switch( uChar )
  655. {
  656. case VK_DELETE:
  657. {
  658. if( ( GetStyle() & ES_READONLY ) != 0 )
  659. return;
  660. INT nStart = 0, nEnd = 0;
  661. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  662. CExtSafeString strText = m_pEditWithBehaviorWnd->TextGet();
  663. if( _DeleteSymbols( strText, nStart, nEnd ) )
  664. {
  665. m_pEditWithBehaviorWnd->SetWindowText( strText );
  666. m_pEditWithBehaviorWnd->SetSel( nStart, nStart );
  667. }
  668. else
  669. m_pEditWithBehaviorWnd->SetSel( nEnd, nEnd );
  670. // _Rich_OnDraw();
  671. return;
  672. }
  673. case VK_BACK:
  674. {
  675. if( ( GetStyle() & ES_READONLY ) != 0 )
  676. return;
  677. CExtSafeString strText = m_pEditWithBehaviorWnd->TextGet();
  678. if( strText.IsEmpty() )
  679. return;
  680. INT nStart = 0, nEnd = 0;
  681. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  682. if( _DeleteSymbols( strText, nStart, nEnd, true ) )
  683. m_pEditWithBehaviorWnd->SetWindowText( strText );
  684. m_pEditWithBehaviorWnd->SetSel( nStart, nStart );
  685. // _Rich_OnDraw();
  686. return;
  687. }
  688. }
  689. //CExtEditWithBehavior::CBehaviorBase::Behavior_OnKeyDown( uChar, nRepCnt, nFlags );
  690. CBehaviorBase::Behavior_OnKeyDown( uChar, nRepCnt, nFlags );
  691. }
  693. void CExtEditSystemNumberCurrencyBase::Behavior_OnKillFocus( CWnd * pNewWnd )
  694. {
  695. ASSERT_VALID( this );
  696. //CExtEditWithBehavior::CBehaviorBase::Behavior_OnKillFocus( pNewWnd );
  697. CBehaviorBase::Behavior_OnKillFocus( pNewWnd );
  698. _CheckFlags();
  699. }
  701. LRESULT CExtEditSystemNumberCurrencyBase::Behavior_OnPaste( WPARAM wParam, LPARAM lParam )
  702. {
  703. ASSERT_VALID( this );
  704. wParam;
  705. lParam;
  706. if( ( GetStyle() & ES_READONLY ) != 0 )
  707. return 0;
  708. INT nStart = 0, nEnd = 0;
  709. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  710. CExtSafeString strText = m_pEditWithBehaviorWnd->TextGet();
  711. // paste from clipboard
  712. if( OpenClipboard() )
  713. {
  714. CExtSafeString strClipboardText;
  715. bool bHaveClipboardText = false;
  716. if( g_PaintManager.m_bIsWinNT4orLater && ::IsClipboardFormatAvailable( CF_UNICODETEXT ) )
  717. {
  718. HGLOBAL h = ::GetClipboardData( CF_UNICODETEXT );
  719. if( h != NULL )
  720. {
  721. LPWSTR strUnicodeBuffer = (LPWSTR) ::GlobalLock( h );
  722. if( strUnicodeBuffer != NULL )
  723. {
  724. bHaveClipboardText = true;
  725. USES_CONVERSION;
  726. LPCTSTR strBuffer = W2CT(strUnicodeBuffer);
  727. strClipboardText = strBuffer;
  728. ::GlobalUnlock( h );
  729. }
  730. }
  731. } // if( g_PaintManager.m_bIsWinNT4orLater && ::IsClipboardFormatAvailable( CF_UNICODETEXT ) )
  732. if( ( ! bHaveClipboardText ) && ::IsClipboardFormatAvailable( CF_TEXT ) )
  733. {
  734. HGLOBAL h = ::GetClipboardData( CF_TEXT );
  735. if( h != NULL )
  736. {
  737. LPSTR strBuffer = (LPSTR) ::GlobalLock( h );
  738. if( strBuffer != NULL )
  739. {
  740. bHaveClipboardText = true;
  741. strClipboardText = LPCTSTR(strBuffer);
  742. ::GlobalUnlock( h );
  743. } // if( strBuffer != NULL )
  744. }
  745. } // if( ( ! bHaveClipboardText ) && ::IsClipboardFormatAvailable( CF_TEXT ) )
  746. if( bHaveClipboardText )
  747. {
  748. bool bNegative = _IsNegative( strText );
  749. _GetTextWithoutMarks( strText, nStart, nEnd );
  750. INT _nStart = 0, _nEnd = 0;
  751. INT nDecimalPointPos = INT( strText.Find( m_strDecimalPoint ) );
  752. INT nDecimalPointLen = INT( m_strDecimalPoint.GetLength() );
  753. if( nDecimalPointPos != -1 )
  754. _GetTextWithoutMarks( strClipboardText, _nStart, _nEnd, true );
  755. else
  756. _GetTextWithoutMarks( strClipboardText, _nStart, _nEnd );
  757. if( strText.IsEmpty() )
  758. _GetTextWithoutMarks( strClipboardText, _nStart, _nEnd, true );
  759. INT nClipboardTextLen = INT( strClipboardText.GetLength() );
  760. if( ( nEnd - nStart ) > 0 )
  761. strText.Delete( nStart, ( nEnd - nStart ) );
  762. nDecimalPointPos = INT( strText.Find( m_strDecimalPoint ) );
  763. bool bStartInFrontOfDecimalPoint = ( nStart <= nDecimalPointPos );
  764. strText.Insert( nStart, strClipboardText );
  765. nDecimalPointPos = INT( strText.Find( m_strDecimalPoint ) );
  766. if( nDecimalPointPos > m_nMaxWholeDigits )
  767. {
  768. strText.Delete( nDecimalPointPos, nDecimalPointLen );
  769. strText.Insert( m_nMaxWholeDigits, m_strDecimalPoint );
  770. nDecimalPointPos = m_nMaxWholeDigits;
  771. }
  772. if( nDecimalPointPos != -1 )
  773. nDecimalPointPos = INT( strText.Find( m_strDecimalPoint ) );
  774. INT nMaxLen = m_nMaxWholeDigits + m_nMaxFractionDigits + ( ( nDecimalPointPos != -1 ) ? nDecimalPointLen : 0 );
  775. nEnd = nStart + nClipboardTextLen;
  776. if( bStartInFrontOfDecimalPoint 
  777. && nEnd > nDecimalPointPos
  778. )
  779. nEnd += nDecimalPointLen;
  780. if( nMaxLen < strText.GetLength() )
  781. {
  782. strText.Delete( nMaxLen, ( strText.GetLength() - nMaxLen ) );
  783. if( nDecimalPointPos != -1 )
  784. {
  785. nDecimalPointPos = INT( strText.Find( m_strDecimalPoint ) );
  786. // check if DecimalPoint deleted
  787. if( nDecimalPointPos == -1 )
  788. {
  789. nMaxLen -= nDecimalPointLen;
  790. strText.Delete( nMaxLen, nDecimalPointLen );
  791. }
  792. }
  793. if( nDecimalPointPos != -1 && nDecimalPointPos > m_nMaxWholeDigits )
  794. {
  795. strText.Delete( nDecimalPointPos, nDecimalPointLen );
  796. strText.Insert( m_nMaxWholeDigits, m_strDecimalPoint );
  797. if( nEnd >= m_nMaxWholeDigits )
  798. nEnd += nDecimalPointLen;
  799. }
  800. }
  801. _GetTextWithMarks( strText, nStart, nEnd, bNegative );
  802. m_pEditWithBehaviorWnd->TextSet( strText );
  803. m_pEditWithBehaviorWnd->SetSel( nEnd, nEnd );
  804. } // if( bHaveClipboardText )
  805. ::CloseClipboard();
  806. } // if( OpenClipboard() )
  807. // _Rich_OnDraw();
  808. return 0;
  809. }
  811. BOOL CExtEditSystemNumberCurrencyBase::OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pLResult) 
  812. {
  813. ASSERT_VALID( this );
  814. if( message == WM_COMMAND )
  815. {
  816. INT nCode = HIWORD(wParam);
  817. switch( nCode )
  818. {
  819. case EN_CHANGE:
  820. _AdjustWithinRange();
  821. break;
  822. }
  823. }
  824. return CExtEditWithBehavior::OnChildNotify(message, wParam, lParam, pLResult);
  825. }
  827. /////////////////////////////////////////////////////////////////////////////
  828. // CExtEditSystemNumber window
  830. IMPLEMENT_DYNCREATE( CExtEditSystemNumber, CExtEditSystemNumberCurrencyBase );
  832. CExtEditSystemNumber::CExtEditSystemNumber(
  833. INT nMaxWholeDigits, // = __EXT_MFC_DEFAULT_MAX_WHOLE_DIGITS,
  834. INT nMaxFractionDigits // = __EXT_MFC_DEFAULT_FRACTION_WHOLE_DIGITS
  835. )
  836. : CExtEditSystemNumberCurrencyBase( nMaxWholeDigits, nMaxFractionDigits )
  837. {
  838. _Init();
  839. }
  841. CExtEditSystemNumber::~CExtEditSystemNumber()
  842. {
  843. }
  845. BEGIN_MESSAGE_MAP( CExtEditSystemNumber, CExtEditSystemNumberCurrencyBase )
  846. //{{AFX_MSG_MAP(CExtEditSystemNumberCurrencyBase)
  847. //}}AFX_MSG_MAP
  848. __EXT_MFC_SAFE_ON_WM_SETTINGCHANGE()
  849. END_MESSAGE_MAP()
  851. void CExtEditSystemNumber::_Init()
  852. {
  853. ASSERT_VALID( this );
  854. // negative sign
  855. if( g_ResourceManager->GetLocaleInfo( LOCALE_SNEGATIVESIGN, NULL, 0 ) )
  856. {
  857. g_ResourceManager->GetLocaleInfo( LOCALE_SNEGATIVESIGN, m_strNegativeSign.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  858. m_strNegativeSign.ReleaseBuffer();
  859. }
  860. // decimal point
  861. if( g_ResourceManager->GetLocaleInfo( LOCALE_SDECIMAL, NULL, 0 ) )
  862. g_ResourceManager->GetLocaleInfo( LOCALE_SDECIMAL, m_strDecimalPoint.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  863. m_strDecimalPoint.ReleaseBuffer();
  864. // group separator
  865. if( g_ResourceManager->GetLocaleInfo( LOCALE_STHOUSAND, NULL, 0 ) )
  866. g_ResourceManager->GetLocaleInfo( LOCALE_STHOUSAND, m_strGroupSeparator.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  867. m_strGroupSeparator.ReleaseBuffer();
  868. TCHAR cNegNumFormatIndex = _T('0');
  869. if( g_ResourceManager->GetLocaleInfo( LOCALE_INEGNUMBER, NULL, 0 ) )
  870. g_ResourceManager->GetLocaleInfo( LOCALE_INEGNUMBER, &cNegNumFormatIndex, sizeof( cNegNumFormatIndex ) / sizeof(TCHAR) );
  871. m_nNegativeFormatIndex = _ttoi( & cNegNumFormatIndex );
  872. CExtSafeString strDigitGrouping = _T("0");
  873. if( g_ResourceManager->GetLocaleInfo( LOCALE_SGROUPING, NULL, 0 ) )
  874. {
  875. g_ResourceManager->GetLocaleInfo( LOCALE_SGROUPING, strDigitGrouping.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  876. strDigitGrouping.ReleaseBuffer();
  877. INT nStrLen = INT( strDigitGrouping.GetLength() );
  878. CExtSafeString _strGroup = _T("");
  879. INT nGroup = 0;
  880. if( m_listDigitGrouping.GetCount() > 0 )
  881. m_listDigitGrouping.RemoveAll();
  882. for( INT i = 0; i < nStrLen; i++ )
  883. {
  884. TCHAR ch = strDigitGrouping[i];
  885. if( ch == _T(';') )
  886. {
  887. nGroup = _ttoi( _strGroup );
  888. m_listDigitGrouping.AddTail( nGroup );
  889. _strGroup = _T("");
  890. nGroup = 0;
  891. }
  892. else
  893. _strGroup = _strGroup + ch;
  894. }
  895. nGroup = _ttoi( _strGroup );
  896. m_listDigitGrouping.AddTail( nGroup );
  897. }
  898. TCHAR cNoOfDigitsAfterDecimal = _T('0');
  899. if( g_ResourceManager->GetLocaleInfo( LOCALE_IDIGITS, NULL, 0 ) )
  900. g_ResourceManager->GetLocaleInfo( LOCALE_IDIGITS, &cNoOfDigitsAfterDecimal, sizeof( cNoOfDigitsAfterDecimal ) / sizeof(TCHAR) );
  901. m_nMaxFractionDigits = _ttoi( & cNoOfDigitsAfterDecimal );
  902. TCHAR cDisplayLeadingZeros = _T('0');
  903. if( g_ResourceManager->GetLocaleInfo( LOCALE_ILZERO, NULL, 0 ) )
  904. g_ResourceManager->GetLocaleInfo( LOCALE_ILZERO, &cDisplayLeadingZeros, sizeof( cDisplayLeadingZeros ) / sizeof(TCHAR) );
  905. m_nDisplayLeadingZeros = _ttoi( & cDisplayLeadingZeros );
  906. TCHAR cDigitGrouping[20] = _T("");
  907. if( g_ResourceManager->GetLocaleInfo( LOCALE_SGROUPING, NULL, 0 ) )
  908. g_ResourceManager->GetLocaleInfo( LOCALE_SGROUPING, cDigitGrouping, sizeof( cDigitGrouping ) / sizeof( cDigitGrouping[0] ) );
  909. // ensure the separators are not the same
  910. if( m_strDecimalPoint == m_strGroupSeparator
  911. && ( m_strDecimalPoint == _T(".")
  912. || m_strDecimalPoint == _T(",")
  913. )
  914. )
  915. m_strGroupSeparator = ( m_strDecimalPoint == _T(",") ? _T(".") : _T(",") );
  916. if( m_strDecimalPoint == m_strGroupSeparator
  917. && ( m_strDecimalPoint != _T(".")
  918. && m_strDecimalPoint != _T(",")
  919. )
  920. )
  921. m_strDecimalPoint == _T(".");
  922. }
  924. void CExtEditSystemNumber::OnSettingChange(UINT uFlags, __EXT_MFC_SAFE_LPCTSTR lpszSection) 
  925. {
  926. ASSERT_VALID( this );
  927. CExtEditSystemNumberCurrencyBase::OnSettingChange( uFlags, lpszSection );
  928. if( _tcscmp( lpszSection, _T("intl") ) == 0 )
  929. {
  930. long double lfSaved = LongDoubleGet();
  931. _Init();
  932. LongDoubleSet( lfSaved );
  933. SetSel( -1, -1 );
  934. }
  935. }
  937. CExtSafeString CExtEditSystemNumber::_GetNumericText(
  938. const CExtSafeString & strText,
  939. bool bUseMathSymbols // = false
  940. ) const
  941. {
  942. ASSERT_VALID( this );
  943. CExtSafeString strNewText;
  944. bool bIsNegative = _IsNegative(strText); // false;
  945. bool bHasDecimalPoint = false;
  946. INT nDecimalSignLen = INT( m_strDecimalPoint.GetLength() );
  947. INT nDecimalSignPos = INT( strText.Find( m_strDecimalPoint ) );
  948. INT nPos, nLen;
  949. for( nPos = 0, nLen = INT( strText.GetLength() ); nPos < nLen; nPos++ )
  950. {
  951. TCHAR c = strText[nPos];
  952. if( _istdigit(c) )
  953. strNewText += c;
  954. else if( nPos == nDecimalSignPos && !bHasDecimalPoint )
  955. {
  956. bHasDecimalPoint = true;
  957. strNewText += ( bUseMathSymbols ? _T(".") : m_strDecimalPoint );
  958. nPos += nDecimalSignLen - 1;
  959. }
  960. }
  961. // add negative sign to the front of the number
  962. if( bIsNegative )
  963. {
  964. CExtSafeString strNegativeSign;
  965. if( m_nNegativeFormatIndex == 1 || m_nNegativeFormatIndex == 3 )
  966. strNegativeSign = m_strNegativeSign;
  967. if( m_nNegativeFormatIndex == 2 )
  968. strNegativeSign = m_strNegativeSign + _T(" ");
  969. if( m_nNegativeFormatIndex == 4 )
  970. strNegativeSign = _T(" ") + m_strNegativeSign;
  972. if( bUseMathSymbols )
  973. {
  974. strNewText.Insert( 0, _T('-') );
  975. }
  976. else
  977. {
  978. INT nIndex = ( m_nNegativeFormatIndex == 1 || m_nNegativeFormatIndex == 2 ) ? 0 : strNewText.GetLength();
  980. if( m_nNegativeFormatIndex != 0 )
  981. strNewText.Insert( nIndex, bUseMathSymbols ? _T("-") : strNegativeSign );
  982. else
  983. {
  984. strNewText.Insert( strNewText.GetLength(), _T(')') );
  985. strNewText.Insert( 0, _T('(') );
  986. }
  987. }
  988. }
  989. return strNewText;
  990. }
  992. CExtSafeString CExtEditSystemNumber::_GetDoubleText( long double lfValue, bool bTrimTrailingZeros /*= true*/ ) const
  993. {
  994. ASSERT_VALID( this );
  995. CExtSafeString strText;
  996. strText.Format( _T("%lf"), lfValue );
  997. if( m_strDecimalPoint != _T(".") )
  998. strText.Replace( _T("."), m_strDecimalPoint );
  999. if( bTrimTrailingZeros )
  1000. {
  1001. strText.TrimRight( _T('0') );
  1002. strText.TrimRight( m_strDecimalPoint );
  1003. }
  1004. bool bNegative = ( strText.Find( _T("-") ) == 0 ) ? true : false;
  1005. if( bNegative )
  1006. {
  1007. strText.Delete( 0 );
  1008. CExtSafeString _strBefore = _T("");
  1009. CExtSafeString _strAfter = _T("");
  1010. switch( m_nNegativeFormatIndex )
  1011. {
  1012. case 0:
  1013. _strBefore = _T("(");
  1014. _strAfter = _T(")");
  1015. break;
  1016. case 1:
  1017. _strBefore = m_strNegativeSign;
  1018. break;
  1019. case 2:
  1020. _strBefore = m_strNegativeSign + _T(" ");
  1021. break;
  1022. case 3:
  1023. _strAfter = m_strNegativeSign;
  1024. break;
  1025. case 4:
  1026. _strAfter = _T(" ") + m_strNegativeSign;
  1027. break;
  1028. }
  1029. INT nLen = INT( strText.GetLength() );
  1030. if( ! _strAfter.IsEmpty() )
  1031. strText.Insert( nLen, _strAfter );
  1032. if( ! _strBefore.IsEmpty() )
  1033. strText.Insert( 0, _strBefore );
  1034. }
  1035. return strText;
  1036. }
  1038. void CExtEditSystemNumber::IntSet( INT nVal )
  1039. {
  1040. ASSERT_VALID( this );
  1041. CExtSafeString strText;
  1042. strText.Format( _T("%d"), nVal );
  1043. bool bNegative = ( strText.Find( _T("-") ) == 0 ) ? true : false;
  1044. if( bNegative )
  1045. {
  1046. strText.Delete( 0 );
  1047. CExtSafeString _strBefore = _T("");
  1048. CExtSafeString _strAfter = _T("");
  1049. switch( m_nNegativeFormatIndex )
  1050. {
  1051. case 0:
  1052. _strBefore = _T("(");
  1053. _strAfter = _T(")");
  1054. break;
  1055. case 1:
  1056. _strBefore = m_strNegativeSign;
  1057. break;
  1058. case 2:
  1059. _strBefore = m_strNegativeSign + _T(" ");
  1060. break;
  1061. case 3:
  1062. _strAfter = m_strNegativeSign;
  1063. break;
  1064. case 4:
  1065. _strAfter = _T(" ") + m_strNegativeSign;
  1066. break;
  1067. }
  1068. INT nLen = INT( strText.GetLength() );
  1069. if( ! _strAfter.IsEmpty() )
  1070. strText.Insert( nLen, _strAfter );
  1071. if( ! _strBefore.IsEmpty() )
  1072. strText.Insert( 0, _strBefore );
  1073. }
  1074. m_pEditWithBehaviorWnd->SetWindowText(strText);
  1075. }
  1077. long double CExtEditSystemNumber::LongDoubleGet() const
  1078. {
  1079. ASSERT_VALID( this );
  1080. // return _tcstod( _GetNumericText( m_pEditWithBehaviorWnd->TextGet(), true ), NULL );
  1081. CExtSafeString str = _GetNumericText( m_pEditWithBehaviorWnd->TextGet() ); //, true 
  1082. if( str.IsEmpty()
  1083. || str == _T(".")
  1084. || str == LPCTSTR(m_strDecimalPoint)
  1085. || ( str.GetLength() == 1 && m_strDecimalPoint.GetLength() > 0 && str[0] == m_strDecimalPoint[0] )
  1086. )
  1087. return 0.0;
  1088. LCID _LCID = LANG_USER_DEFAULT;
  1089. if( g_ResourceManager->IsCustomLangAllowed() )
  1090. _LCID = g_ResourceManager->GetLangIdDesired();
  1091. DOUBLE lfTmp = 0.0;
  1092. USES_CONVERSION;
  1093. HRESULT hr = ::VarR8FromStr( (LPOLESTR) T2COLE( LPCTSTR(str) ), _LCID, 0, &lfTmp );
  1094. ASSERT( SUCCEEDED( hr ) );
  1095. hr;
  1096. long double lfVal = (long double)lfTmp;
  1097. return lfVal;
  1098. }
  1100. INT CExtEditSystemNumber::IntGet() const
  1101. {
  1102. ASSERT_VALID( this );
  1103. // return (INT)_ttoi( _GetNumericText( m_pEditWithBehaviorWnd->TextGet(), true ) );
  1104. CExtSafeString str = _GetNumericText( m_pEditWithBehaviorWnd->TextGet() ); //, true 
  1105. if( str.IsEmpty() )
  1106. return 0;
  1107. LCID _LCID = LANG_USER_DEFAULT;
  1108. if( g_ResourceManager->IsCustomLangAllowed() )
  1109. _LCID = g_ResourceManager->GetLangIdDesired();
  1110. LONG nTmp = 0L;
  1111. USES_CONVERSION;
  1112. HRESULT hr = ::VarI4FromStr( (LPOLESTR) T2COLE( LPCTSTR(str) ), _LCID, 0, &nTmp );
  1113. ASSERT( SUCCEEDED( hr ) );
  1114. hr;
  1115. return INT(nTmp);
  1116. }
  1118. CExtSafeString CExtEditSystemNumber::Behavior_GetValidText(
  1119. bool bSetSel // = false
  1120. ) const
  1121. {
  1122. ASSERT_VALID( this );
  1123. CExtSafeString strText = m_pEditWithBehaviorWnd->TextGet();
  1124. CExtSafeString strNewText = strText;
  1125. bool bIsNegative = _IsNegative( strText );
  1126. INT nStart, nEnd;
  1127. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  1128. _GetTextWithoutMarks( strNewText, nStart, nEnd );
  1129. _GetTextWithMarks( strNewText, nStart, nEnd );
  1130. // insert the negative sign if it is not present
  1131. if( bIsNegative && AllowNegativeGet() )
  1132. {
  1133. INT nNegSignLen = INT( m_strNegativeSign.GetLength() ) + ( ( m_nNegativeFormatIndex == 2 || m_nNegativeFormatIndex == 4 ) ? 1: 0 );
  1134. if( m_nNegativeFormatIndex == 0 )
  1135. nNegSignLen = 1;
  1136. CExtSafeString _strNegativeSign = ( (m_nNegativeFormatIndex == 4) ? _T(" "): _T("") ) + m_strNegativeSign + ( (m_nNegativeFormatIndex == 2) ? _T(" "): _T("") );
  1137. if( m_nNegativeFormatIndex == 0 )
  1138. {
  1139. strNewText.Insert( strNewText.GetLength(), _T(")") );
  1140. strNewText.Insert( 0, _T("(") );
  1141. nStart += 1;
  1142. nEnd += 1;
  1143. }
  1144. if( m_nNegativeFormatIndex == 1 || m_nNegativeFormatIndex == 2 )
  1145. strNewText.Insert( 0, _strNegativeSign );
  1146. if( m_nNegativeFormatIndex == 3 || m_nNegativeFormatIndex == 4 )
  1147. strNewText.Insert( strNewText.GetLength(), _strNegativeSign );
  1148. if( m_nNegativeFormatIndex == 1 || m_nNegativeFormatIndex == 2 )
  1149. {
  1150. nStart += nNegSignLen;
  1151. nEnd += nNegSignLen;
  1152. }
  1153. }
  1154. if( bSetSel && ( ! m_bRichPainting ) )
  1155. {
  1156. CExtSafeString strCurrentText = m_pEditWithBehaviorWnd->TextGet();
  1157. if( strNewText != strCurrentText )
  1158. m_pEditWithBehaviorWnd->SetWindowText( strNewText );
  1159. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  1160. }
  1161. return strNewText;
  1162. }
  1164. void CExtEditSystemNumber::Behavior_OnChar( UINT uChar, UINT nRepCnt, UINT nFlags )
  1165. {
  1166. ASSERT_VALID( this );
  1167. if( m_pEditWithBehaviorWnd->GetStyle() & ES_READONLY )
  1168. return;
  1169. TCHAR c = static_cast<TCHAR>( uChar );
  1170. INT nStart, nEnd;
  1171. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  1172. CExtSafeString strText = m_pEditWithBehaviorWnd->TextGet();
  1173. CExtSafeString strNumericText = _GetNumericText( strText );
  1174. INT nDecimalPos = INT( strText.Find( m_strDecimalPoint ) );
  1175. INT nNumericDecimalPos = INT( strNumericText.Find( m_strDecimalPoint ) );
  1176. INT nLen = INT( strText.GetLength() );
  1177. INT nNumericLen = INT( strNumericText.GetLength() );
  1178. INT nSepCount = _GetGroupSeparatorCount( strText );
  1179. bool bNeedAdjustment = false;
  1180. INT nNegSignLen = INT( m_strNegativeSign.GetLength() );
  1181. bool bIsNegative = false;
  1182. bool bIsDecimalPoint = false;
  1183. if( ( c == m_strNegativeSign[0/*nNegSignMatch*/] )
  1184. || ( m_nNegativeFormatIndex == 0 
  1185. && c == _T('(') 
  1186. )
  1187. || ( c == _T('-') )
  1188. )
  1189. bIsNegative = true;
  1190. // check if it's a negative sign
  1191. if( bIsNegative && AllowNegativeGet() )
  1192. {
  1193. bool bNegative = _IsNegative( strText );
  1194. CExtSafeString _strBefore = _T(""), _strAfter = _T("");
  1195. switch( m_nNegativeFormatIndex )
  1196. {
  1197. case 0:
  1198. _strBefore = _T("(");
  1199. _strAfter = _T(")");
  1200. break;
  1201. case 1:
  1202. _strBefore = m_strNegativeSign;
  1203. break;
  1204. case 2:
  1205. _strBefore = m_strNegativeSign + _T(" ");
  1206. break;
  1207. case 3:
  1208. _strAfter = m_strNegativeSign;
  1209. break;
  1210. case 4:
  1211. _strAfter = _T(" ") + m_strNegativeSign;
  1212. break;
  1213. }
  1214. INT nBeforLen = INT( _strBefore.GetLength() );
  1215. INT nAfterLen = INT( _strAfter.GetLength() );
  1216. CExtSafeString strNewText = strText;
  1217. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  1218. if( bNegative )
  1219. {
  1220. if( nStart < nBeforLen )
  1221. nStart = nBeforLen;
  1222. if( nEnd > ( nLen - nAfterLen ) )
  1223. nEnd = ( nLen - nAfterLen );
  1224. }
  1225. _GetTextWithoutMarks( strNewText, nStart, nEnd );
  1226. _GetTextWithMarks( strNewText, nStart, nEnd, ! bNegative );
  1227. CExtSafeString strCurrentText = m_pEditWithBehaviorWnd->TextGet();
  1228. if( strNewText != strCurrentText )
  1229. m_pEditWithBehaviorWnd->SetWindowText( strNewText );
  1230. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  1231. return;
  1232. }
  1233. // test whether it is decimal point (only one is enabled)
  1234. else if( c == m_strDecimalPoint[0] && m_nMaxFractionDigits > 0 )
  1235. {
  1236. if( nDecimalPos >= 0 )
  1237. {
  1238. // test decimal point replacement
  1239. if( nDecimalPos >= nStart && nDecimalPos < nEnd )
  1240. {
  1241. bNeedAdjustment = true;
  1242. bIsDecimalPoint = true;
  1243. }
  1244. else
  1245. { // else set caret
  1246. m_pEditWithBehaviorWnd->SetSel( nDecimalPos + m_strDecimalPoint.GetLength(), nDecimalPos + m_strDecimalPoint.GetLength() );
  1247. return;
  1248. }
  1249. }
  1250. else
  1251. {
  1252. bNeedAdjustment = true;
  1253. bIsDecimalPoint = true;
  1254. }
  1255. }
  1256. else if( _istdigit(c) )
  1257. {
  1258. // test we're on the right of the decimal point.
  1259. if( nDecimalPos >= 0 && nDecimalPos < nStart )
  1260. {
  1261. bool bIsNegative = ( ! strNumericText.IsEmpty() && ( strNumericText.Find( m_strNegativeSign ) >= 0 ) && ( m_nNegativeFormatIndex == 3 || m_nNegativeFormatIndex == 4 ) );
  1262. if( ! bIsNegative )
  1263. bIsNegative = ( ! strNumericText.IsEmpty() && ( strNumericText.Find( _T('(') ) >= 0 ) && m_nNegativeFormatIndex == 0 );
  1265. INT nNegLength = 0;
  1266. if( m_nNegativeFormatIndex != 0 )
  1267. nNegLength = nNegSignLen + ( ( m_nNegativeFormatIndex == 4 ) ? 1 : 0 );
  1268. else
  1269. nNegLength = 1;
  1270. if( bIsNegative )
  1271. {
  1272. INT nNegSignPos = -1;
  1273. if( m_nNegativeFormatIndex == 3 )
  1274. nNegSignPos = INT( strText.Find( m_strNegativeSign ) );
  1275. if( m_nNegativeFormatIndex == 4 )
  1276. nNegSignPos = INT( strText.Find( _T(' ') + m_strNegativeSign ) );
  1277. if( m_nNegativeFormatIndex == 0 )
  1278. nNegSignPos = INT( strText.Find( _T(')') ) );
  1279. if( ( nStart > nNegSignPos ) && ( nStart <= nLen ) && nNegSignPos != -1 )
  1280. {
  1281. nStart = nNegSignPos;
  1282. m_pEditWithBehaviorWnd->SetSel( nStart, nStart );
  1283. }
  1284. }
  1285. INT nDecimalSeparatorLen = INT( m_strDecimalPoint.GetLength() );
  1286. if( nDecimalPos <= nStart && nStart < ( nDecimalPos + nDecimalSeparatorLen ) )
  1287. {
  1288. INT nPrevStart = nStart;
  1289. nStart = ( nDecimalPos + nDecimalSeparatorLen );
  1290. if( nEnd == nPrevStart 
  1291. || nEnd < nPrevStart 
  1292. || ( nEnd > nPrevStart 
  1293. && nEnd < nStart
  1294. )
  1295. )
  1296. nEnd = nStart;
  1297. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  1298. }
  1299. if( strNumericText.Mid( /*nDecimalPos */ nNumericDecimalPos + nDecimalSeparatorLen ).GetLength() == ( m_nMaxFractionDigits + ( bIsNegative ? nNegLength : 0 ) ) )
  1300. {
  1301. if( nStart <= ( nDecimalPos + m_nMaxFractionDigits + nDecimalSeparatorLen - 1 ) )
  1302. {
  1303. nEnd = ( ( ( nEnd == nLen ) || ( nEnd > ( nStart + 1 ) ) ) ? nEnd : (nStart + 1) );
  1304. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  1305. m_pEditWithBehaviorWnd->ReplaceSel( CExtSafeString(c), TRUE );
  1306. CExtSafeString strReplaceText = Behavior_GetValidText();
  1307. }
  1308. return;
  1309. }
  1310. else if( strNumericText.Mid( /*nDecimalPos */ nNumericDecimalPos + nDecimalSeparatorLen ).GetLength() > ( m_nMaxFractionDigits + ( bIsNegative ? nNegLength : 0 ) ) )
  1311. {
  1312. ASSERT(false);
  1313. return;
  1314. }
  1315. }
  1316. // we're on the left side of the decimal point
  1317. else
  1318. {
  1319. bool bIsNegative = ( ! strNumericText.IsEmpty() && ( strNumericText.Find( m_strNegativeSign ) >= 0 ) && ( m_nNegativeFormatIndex == 1 || m_nNegativeFormatIndex == 2 ) );
  1320. if( ! bIsNegative )
  1321. bIsNegative = ( ! strNumericText.IsEmpty() && ( strNumericText.Find( _T('(') ) >= 0 ) && m_nNegativeFormatIndex == 0 );
  1322. bool bIsNegativeRight = ( ! strNumericText.IsEmpty() && ( strNumericText.Find( m_strNegativeSign ) >= 0 ) && ( m_nNegativeFormatIndex == 3 || m_nNegativeFormatIndex == 4 ) );
  1323. INT nNegLength = 0;
  1324. nNegLength 
  1325. = nNegSignLen
  1326. + (
  1327. ( m_nNegativeFormatIndex == 2 
  1328. || m_nNegativeFormatIndex == 4
  1329. ) ? 1 : 0 
  1330. );
  1332. if( m_nNegativeFormatIndex == 0 )
  1333. nNegLength = 1;
  1334. if( bIsNegative )
  1335. {
  1336. if( ( nStart >= 0 ) && ( nStart < nNegLength ) )
  1337. {
  1338. nStart = nNegLength;
  1339. if( nStart > nEnd )
  1340. nEnd = nStart;
  1341. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  1342. }
  1343. }
  1344. if( bIsNegativeRight || ( bIsNegative && m_nNegativeFormatIndex == 0 ) )
  1345. {
  1346. if( ( nEnd >= ( nLen - nNegLength ) ) && ( nEnd <= nLen ) )
  1347. {
  1348. nEnd = nLen - nNegLength;
  1349. if( nStart > nEnd )
  1350. nStart = nEnd;
  1351. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  1352. }
  1353. if( ( nStart >= ( nLen - nNegLength ) ) && ( nStart <= nLen ) )
  1354. {
  1355. nStart = nLen - nNegLength;
  1356. m_pEditWithBehaviorWnd->SetSel( nStart, nStart );
  1357. }
  1358. }
  1359. INT nGroupSeparatorLen = INT( m_strGroupSeparator.GetLength() );
  1360. INT nDecimalSignLen = INT( m_strDecimalPoint.GetLength() );
  1361. // ensure we can still enter digits.
  1362. INT nDecPos = m_nMaxWholeDigits + ( bIsNegative ? nNegLength : 0 ) + ( nSepCount * nGroupSeparatorLen );
  1363. if( nStart == nDecPos )
  1364. {
  1365. UINT nFlags = CBehaviorBase::m_nBehaviorFlags;
  1366. if(  ( nFlags & __ESE_ADD_DECIMAL_AFTER_MAX_WHOLE_DIGITS ) != 0 && m_nMaxFractionDigits > 0 )
  1367. {
  1368. nEnd = ( ( ( nEnd == nLen ) || ( ( nEnd > nStart ) && ( ( nEnd - nStart ) > 1 ) ) ) ? nEnd : ( nStart + nDecimalSignLen + 1 ) );
  1369. if( bIsNegativeRight || ( bIsNegative && m_nNegativeFormatIndex == 0 ) )
  1370. {
  1371. m_pEditWithBehaviorWnd->SetSel( nStart, strText.GetLength() );
  1372. m_pEditWithBehaviorWnd->ReplaceSel( _T(""), TRUE );
  1373. }
  1374. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  1375. m_pEditWithBehaviorWnd->ReplaceSel( m_strDecimalPoint + c, TRUE );
  1376. if( bIsNegativeRight || ( bIsNegative && m_nNegativeFormatIndex == 0 ) )
  1377. {
  1378. CExtSafeString strChangedText = m_pEditWithBehaviorWnd->TextGet();
  1379. CExtSafeString _strNegativeSign = ( m_nNegativeFormatIndex == 4 ? _T(" "): _T("") ) + m_strNegativeSign;
  1380. nEnd = INT( strChangedText.GetLength() );
  1381. m_pEditWithBehaviorWnd->SetSel( nEnd, nEnd );
  1382. if( m_nNegativeFormatIndex != 0 )
  1383. m_pEditWithBehaviorWnd->ReplaceSel( _strNegativeSign, TRUE );
  1384. else
  1385. m_pEditWithBehaviorWnd->ReplaceSel( _T(")"), TRUE );
  1386. m_pEditWithBehaviorWnd->SetSel( nEnd, nEnd );
  1387. }
  1388. CExtSafeString strReplaceText = Behavior_GetValidText(true);
  1389. }
  1390. return;
  1391. }
  1392. if( strNumericText.Mid( 
  1393. 0, 
  1394. ( ( nNumericDecimalPos >= 0 )
  1395. ? nNumericDecimalPos
  1396. : nNumericLen
  1397. )
  1398. ).GetLength()
  1399. == ( m_nMaxWholeDigits + ( bIsNegative ? nNegLength : 0 ) ) //  + ( ( nNumericDecimalPos >= 0 ) ? ( m_strDecimalPoint.GetLength() ) : 0 )
  1400. )
  1401. {
  1402. {
  1403. INT nPos = 0;
  1404. for( ; true; )
  1405. {
  1406. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  1407. if( nPos == -1 )
  1408. break;
  1409. if( nPos <= nStart && nStart < ( nPos + nGroupSeparatorLen ) )
  1410. {
  1411. nStart = nPos + nGroupSeparatorLen;
  1412. break;
  1413. }
  1414. nPos ++;
  1415. }
  1416. INT _nNegativeSignLen = INT( m_strNegativeSign.GetLength() ) + ( (m_nNegativeFormatIndex == 2 || m_nNegativeFormatIndex == 4) ? 1: 0 );
  1417. if( m_nNegativeFormatIndex == 0 )
  1418. _nNegativeSignLen = 1;
  1419. if( nStart < _nNegativeSignLen && bIsNegative )
  1420. nStart = _nNegativeSignLen;
  1421. nEnd = ( ( ( nEnd == nLen ) || ( nEnd > ( nStart + 1 ) ) ) ? nEnd : ( nStart + 1 ) );
  1422. if( bIsNegativeRight )
  1423. {
  1424. INT nNegSignPos = INT( strText.Find( m_strNegativeSign ) );
  1425. if( nEnd > nNegSignPos )
  1426. nEnd = nNegSignPos;
  1427. }
  1428. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  1429. m_pEditWithBehaviorWnd->ReplaceSel( CExtSafeString(c), TRUE );
  1430. CExtSafeString strReplaceText = Behavior_GetValidText(true);
  1431. }
  1432. return;
  1433. }
  1434. bNeedAdjustment = true;
  1435. }
  1436. }
  1437. // test whether it is a non-printable character (i.e. backspace, ctrl+c )
  1438. else if( ! ( _istprint( c ) || IsCharAlphaNumeric( c ) ) )
  1439. bNeedAdjustment = true;
  1440. else
  1441. return;
  1442. if( ! m_bBackspace )
  1443. {
  1444. //CExtEditSystemNumberCurrencyBase::CBehaviorBase::Behavior_OnChar( uChar, nRepCnt, nFlags );
  1445. CBehaviorBase::Behavior_OnChar( uChar, nRepCnt, nFlags );
  1447. // if the decimal point was added/removed or a separator needs adding/removing, adjust the text
  1448. if( bNeedAdjustment )
  1449. _AdjustSeparators( nSepCount, bIsDecimalPoint );
  1450. }
  1451. else
  1452. m_bBackspace = false;
  1453. }
  1455. bool CExtEditSystemNumber::_DeleteSymbols( 
  1456. CExtSafeString & strText, 
  1457. INT & nStart, 
  1458. INT & nEnd, 
  1459. bool bBackspace // = false
  1460. )
  1461. {
  1462. ASSERT_VALID( this );
  1463. ASSERT( ! m_bRichPainting );
  1464. INT nLen = INT( strText.GetLength() );
  1465. bool bNegative = _IsNegative( strText );
  1466. CExtSafeString strTextLen = strText;
  1467. INT nStLen = 0, nEndLen = 0;
  1468. _GetTextWithoutMarks( strTextLen, nStLen, nEndLen );
  1469. INT nTextLen = INT( strTextLen.GetLength() );
  1470. INT nDecSepPosLen = INT( strTextLen.Find( m_strDecimalPoint ) );
  1471. INT nGroupSeparatorLen = INT( m_strGroupSeparator.GetLength() );
  1472. INT nDecimalSeparatorLen = INT( m_strDecimalPoint.GetLength() );
  1473. INT nDecimalSeparatorPos = INT( strText.Find( m_strDecimalPoint ) );
  1474. INT _nPos = 0, _nGroupSignBeforeStart = 0, _nGroupSignCount = (INT)_GetGroupSeparatorCount( strText );
  1475. for( ; true; )
  1476. {
  1477. _nPos = (INT)strText.Find( m_strGroupSeparator, _nPos );
  1478. if( _nPos < 0 )
  1479. break;
  1480. if( _nPos < nStart )
  1481. _nGroupSignBeforeStart ++;
  1482. _nPos ++;
  1483. }
  1484. _nGroupSignBeforeStart = _nGroupSignCount - _nGroupSignBeforeStart;
  1485. if( bBackspace )
  1486. {
  1487. if( nStart == 0 && nStart == nEnd )
  1488. return false;
  1489. INT nPos = 0;
  1490. if( nStart >= 0 )
  1491. {
  1492. if( ( nDecimalSeparatorPos < nStart
  1493. || ( nDecimalSeparatorPos == nStart
  1494. && nStart != nEnd
  1495. )
  1496. )
  1497. && nStart <= ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  1498. && nEnd <= ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  1499. && nDecSepPosLen == m_nMaxWholeDigits
  1500. && ( nTextLen > ( nDecSepPosLen + nDecimalSeparatorLen )
  1501. && nDecSepPosLen != -1
  1502. )
  1503. )
  1504. {
  1505. nStart = nDecimalSeparatorPos;
  1506. nEnd = nDecimalSeparatorPos;
  1507. m_bBackspace = true;
  1508. return false;
  1509. }
  1510. for( ; true; )
  1511. {
  1512. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  1513. if( nPos == -1 )
  1514. break;
  1515. if( ( nPos < nStart 
  1516. || ( nPos == nStart 
  1517. && nStart != nEnd
  1518. )
  1519. )
  1520. && nStart <= ( nPos + nGroupSeparatorLen )
  1521. && nEnd <= ( nPos + nGroupSeparatorLen )
  1522. )
  1523. {
  1524. nStart = nPos;
  1525. nEnd = nPos;
  1526. m_bBackspace = true;
  1527. return false;
  1528. }
  1529. nPos ++;
  1530. }
  1531. }
  1532. }
  1533. else
  1534. {
  1535. if( nStart == nLen )
  1536. return false;
  1537. INT nPos = 0;
  1538. if( nStart < nLen )
  1539. {
  1540. if( nDecimalSeparatorPos <= nStart
  1541. && nStart < ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  1542. && nEnd <= ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  1543. && nDecSepPosLen == m_nMaxWholeDigits
  1544. && ( nTextLen > ( nDecSepPosLen + nDecimalSeparatorLen )
  1545. && nDecSepPosLen != -1
  1546. )
  1547. )
  1548. {
  1549. nStart = nDecimalSeparatorPos + nDecimalSeparatorLen;
  1550. nEnd = nDecimalSeparatorPos + nDecimalSeparatorLen;
  1551. return false;
  1552. }
  1553. for( ; true; )
  1554. {
  1555. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  1556. if( nPos == -1 )
  1557. break;
  1558. if( nPos <= nStart 
  1559. && nStart < ( nPos + nGroupSeparatorLen )
  1560. && nEnd <= ( nPos + nGroupSeparatorLen )
  1561. )
  1562. {
  1563. nStart = nPos + nGroupSeparatorLen;
  1564. nEnd = nPos + nGroupSeparatorLen;
  1565. return false;
  1566. }
  1567. nPos ++;
  1568. }
  1569. }
  1570. }
  1571. if( nStart != nEnd )
  1572. {
  1573. if( nDecimalSeparatorPos < nStart
  1574. && nStart < ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  1575. )
  1576. {
  1577. nStart = nDecimalSeparatorPos + nDecimalSeparatorLen;
  1578. if( nStart > nEnd )
  1579. nEnd = nStart;
  1580. }
  1581. if( nDecimalSeparatorPos < nEnd
  1582. && nEnd <= ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  1583. )
  1584. nEnd = nDecimalSeparatorPos;
  1585. INT nPos = 0;
  1586. for( ; true; )
  1587. {
  1588. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  1589. if( nPos == -1 )
  1590. break;
  1591. if( nPos < nStart 
  1592. && nStart < ( nPos + nGroupSeparatorLen )
  1593. )
  1594. {
  1595. nStart = nPos + nGroupSeparatorLen;
  1596. if( nStart >= nEnd )
  1597. {
  1598. nEnd = nStart;
  1599. break;
  1600. }
  1601. }
  1602. if( nPos < nEnd 
  1603. && nEnd < ( nPos + nGroupSeparatorLen )
  1604. )
  1605. {
  1606. nEnd = nPos;
  1607. if( nEnd < nStart )
  1608. nStart = nEnd;
  1609. if( nEnd >= nStart )
  1610. break;
  1611. }
  1612. nPos ++;
  1613. }
  1614. }
  1616. {
  1617. INT nNegSignLen = INT( m_strNegativeSign.GetLength() ) + ( ( m_nNegativeFormatIndex == 2 || m_nNegativeFormatIndex == 4 ) ? 1 : 0 );
  1618. if( m_nNegativeFormatIndex == 0 )
  1619. nNegSignLen = 1;
  1620. bool bNegDel = false;
  1621. if( bNegative )
  1622. {
  1623. if( ( nStart < nNegSignLen || ( nStart == nNegSignLen  && nStart == nEnd  && bBackspace ) ) 
  1624. && ( m_nNegativeFormatIndex == 1 || m_nNegativeFormatIndex == 2 || m_nNegativeFormatIndex == 0 ) 
  1625. )
  1626. {
  1627. bNegative = false;
  1628. bNegDel = true;
  1629. }
  1631. if( ( ( nStart >= ( nLen - nNegSignLen )
  1632. && ! bBackspace
  1633. )
  1634. || nEnd > ( nLen - nNegSignLen )
  1635. || ( nStart > ( nLen - nNegSignLen )
  1636. && bBackspace
  1637. )
  1638. || ( nStart == nLen
  1639. && nStart == nEnd
  1640. && bBackspace
  1641. )
  1642. )
  1643. && ( m_nNegativeFormatIndex == 3
  1644. || m_nNegativeFormatIndex == 4
  1645. || m_nNegativeFormatIndex == 0
  1646. )
  1647. )
  1648. {
  1649. bNegative = false;
  1650. bNegDel = true;
  1651. }
  1652. }
  1654. _GetTextWithoutMarks( strText, nStart, nEnd );
  1656. if( bBackspace )
  1657. {
  1658. bool bSelect = ( nStart != nEnd ) ? true : false;
  1659. strText.Delete( ( nStart != nEnd ) ? nStart : ( nStart - 1 ), ( nStart != nEnd ) ? ( nEnd - nStart ) : ( bNegDel ? 0 : 1 ) );
  1660. if( ! bSelect && ! bNegDel )
  1661. nStart --;
  1662. m_bBackspace = true;
  1663. }
  1664. else
  1665. {
  1666. INT _nDecimalPointPos = INT( strText.Find( m_strDecimalPoint ) );
  1667. if( _nDecimalPointPos != -1 )
  1668. {
  1669. if( nStart > _nDecimalPointPos 
  1670. && nStart < ( _nDecimalPointPos + nDecimalSeparatorLen )
  1671. )
  1672. nStart = _nDecimalPointPos;
  1673. if( nEnd > _nDecimalPointPos 
  1674. && nEnd < ( _nDecimalPointPos + nDecimalSeparatorLen )
  1675. )
  1676. nEnd = _nDecimalPointPos + nDecimalSeparatorLen;
  1677. }
  1678. strText.Delete( nStart, ( nStart != nEnd ) ? ( nEnd - nStart ) : ( bNegDel ? 0 : 1 ) );
  1679. }
  1680. _GetTextWithoutMarks( strText, nStart, nEnd );
  1681. _GetTextWithMarks( strText, nStart, nEnd, bNegative );
  1682. if( m_bBackspace && ( nStart - nGroupSeparatorLen ) >= 0 )
  1683. {
  1684. INT nGroupSepPos = (INT)strText.Find( m_strGroupSeparator, ( nStart - nGroupSeparatorLen ) );
  1685. if( nGroupSepPos >= 0 )
  1686. {
  1687. INT _nPos = 0, _nGroupSignBeforeStartAfterDelete = 0;
  1688. bool _bChangePos = false;
  1689. INT _nGroupSignCountAfterDelete = (INT)_GetGroupSeparatorCount( strText );
  1690. for( ; true; )
  1691. {
  1692. _nPos = (INT)strText.Find( m_strGroupSeparator, _nPos );
  1693. if( _nPos == -1 )
  1694. break;
  1695. if( _nPos < nStart )
  1696. _nGroupSignBeforeStartAfterDelete ++;
  1697. _nPos ++;
  1698. }
  1699. _nGroupSignBeforeStartAfterDelete = _nGroupSignCountAfterDelete - _nGroupSignBeforeStartAfterDelete;
  1700. if( ( _nGroupSignBeforeStart - 1 ) == _nGroupSignBeforeStartAfterDelete )
  1701. _bChangePos = true;
  1702. if( nGroupSepPos == ( nStart - nGroupSeparatorLen ) && _bChangePos )
  1703. nStart = nGroupSepPos;
  1704. }
  1705. }
  1706. }
  1707. return true;
  1708. }
  1710. void CExtEditSystemNumber::_GetTextWithoutMarks( 
  1711. CExtSafeString & strText, 
  1712. INT & nStart, 
  1713. INT & nEnd, 
  1714. bool bCutDecimalPoint // = false 
  1715. ) const
  1716. {
  1717. ASSERT_VALID( this );
  1718. CExtSafeString strCurrentText;
  1719. INT nStartPos = nStart, nEndPos = nEnd;
  1720. INT nSignCountBeforeStartPos ,nSignCountBeforeEndPos ,nSignCount;
  1721. INT nStrLen = INT( strText.GetLength() );
  1722. INT nDecimalSeparatorLen = INT( m_strDecimalPoint.GetLength() );
  1723. INT nDecimalSeparatorPos = INT( strText.Find( m_strDecimalPoint ) );
  1724. nSignCount = 0;
  1725. if( nEndPos > strText.GetLength() )
  1726. nEndPos = INT( strText.GetLength() );
  1727. nSignCountBeforeStartPos = nSignCountBeforeEndPos = nSignCount = 0;
  1728. for( INT i = 0; i < nStrLen; i++ )
  1729. {
  1730. TCHAR _tchr = strText[i];
  1731. bool bUseSymbol = false;
  1732. if( _T('0') <= _tchr && _tchr <= _T('9') ) //  || ( _tchr == m_strDecimalPoint && ! bCutDecimalPoint ) 
  1733. {
  1734. strCurrentText += _tchr;
  1735. bUseSymbol = true;
  1736. }
  1737. if( i >= nDecimalSeparatorPos && i < ( nDecimalSeparatorPos + nDecimalSeparatorLen ) && ! bCutDecimalPoint && nDecimalSeparatorPos != -1 )
  1738. {
  1739. strCurrentText += _tchr;
  1740. bUseSymbol = true;
  1741. }
  1742. if( ! bUseSymbol )
  1743. nSignCount++;
  1744. if( i == ( nStartPos - 1 ) )
  1745. nSignCountBeforeStartPos = nSignCount;
  1746. else if( i == ( nEndPos - 1 ) )
  1747. nSignCountBeforeEndPos = nSignCount;
  1748. }
  1749. nStartPos -= nSignCountBeforeStartPos;
  1750. nEndPos -= nSignCountBeforeEndPos;
  1751. if( nStartPos < 0 )
  1752. nStartPos = 0;
  1753. if( nEndPos < 0 )
  1754. nEndPos = 0;
  1755. strText = strCurrentText;
  1756. if( nStart != nEnd )
  1757. {
  1758. nStart = nStartPos;
  1759. nEnd = nEndPos;
  1760. }
  1761. else
  1762. nStart = nEnd = nStartPos;
  1763. }
  1765. void CExtEditSystemNumber::_GetTextWithMarks( 
  1766. CExtSafeString & strText, 
  1767. INT & nStart, 
  1768. INT & nEnd, 
  1769. bool bInsertNegSign  // = false
  1770. ) const
  1771. {
  1772. ASSERT_VALID( this );
  1773. if( strText.IsEmpty() )
  1774. return;
  1775. INT nTextLen = INT( strText.GetLength() );
  1776. CExtSafeString strTextChange;
  1777. INT nGroupSeparatorLen = INT( m_strGroupSeparator.GetLength() );
  1778. INT nDecimalSeparatorLen = INT( m_strDecimalPoint.GetLength() );
  1779. INT nPositionDecimalPoint = INT( strText.Find( m_strDecimalPoint ) );
  1780. INT nMaxLen = m_nMaxWholeDigits + m_nMaxFractionDigits + ( ( nPositionDecimalPoint >= 0 ) ? nDecimalSeparatorLen : 0 );
  1781. if( nTextLen > nMaxLen )
  1782. {
  1783. if( nPositionDecimalPoint >= 0 )
  1784. {
  1785. CExtSafeString _strDecimalPoint = _T("");
  1786. _strDecimalPoint = m_strDecimalPoint;
  1787. strText.Replace( _strDecimalPoint, _T("") );
  1788. if( nPositionDecimalPoint > m_nMaxWholeDigits )
  1789. strText.Insert( m_nMaxWholeDigits, m_strDecimalPoint );
  1790. else
  1791. strText.Insert( nPositionDecimalPoint, m_strDecimalPoint );
  1792. }
  1793. nTextLen = INT( strText.GetLength() );
  1794. }
  1795. INT nWholeNumber = ( ( nPositionDecimalPoint >= 0 ) ? ( ( nPositionDecimalPoint < m_nMaxWholeDigits ) ? nPositionDecimalPoint : m_nMaxWholeDigits ) : ( ( m_nMaxWholeDigits >= nTextLen ) ?  nTextLen : m_nMaxWholeDigits ) );
  1796. INT nDecimalPointLen = nDecimalSeparatorLen; // 1
  1797. INT nCorectTextLen = nWholeNumber + nDecimalPointLen + m_nMaxFractionDigits;
  1798. nCorectTextLen = ( nCorectTextLen > nTextLen ) ? nTextLen : nCorectTextLen;
  1799. INT nCountDigitGroups = INT( m_listDigitGrouping.GetCount() );
  1800. CList < INT, INT > _listPos;
  1801. bool bLastZiro = ( m_listDigitGrouping.GetAt( m_listDigitGrouping.FindIndex( nCountDigitGroups - 1 ) ) == 0 ) ? true : false;
  1802. ASSERT( nWholeNumber <= m_nMaxWholeDigits );
  1803. INT nPos = nWholeNumber;
  1804. INT i = 0;
  1805. INT nPreviousCount = -1;
  1806. for( ; true; )
  1807. {
  1808. INT nCount = INT( m_listDigitGrouping.GetAt( m_listDigitGrouping.FindIndex(i) ) );
  1809. if( nCount == 0 && i < ( nCountDigitGroups - 1 ) )
  1810. break;
  1811. if( nCount == 0 && i == ( nCountDigitGroups - 1 ) )
  1812. {
  1813. ASSERT( nPreviousCount != -1 );
  1814. nCount = nPreviousCount;
  1815. }
  1816. nPos -= nCount;
  1817. if( nPos > 0 )
  1818. _listPos.AddHead( nPos - 1 );
  1819. else
  1820. break;
  1821. if( i == ( nCountDigitGroups - 1 ) && ! bLastZiro )
  1822. break;
  1823. if( i < ( nCountDigitGroups - 1 ) )
  1824. i ++;
  1825. nPreviousCount = nCount;
  1826. }
  1827. INT nSignCountBeforeStart = 0;
  1828. INT nSignCountBeforeEnd = 0;
  1829. bool bInsertedDecimalSignBeforeStart = false;
  1830. bool bInsertedDecimalSignBeforeEnd = false;
  1831. INT nCurDigitPos = 0;
  1832. INT nPosCount = INT( _listPos.GetCount() );
  1833. bool bCanPastGroupSep = ( nPosCount > 0 );
  1834. for( i = 0; i < nCorectTextLen; i++ )
  1835. {
  1836. TCHAR _tchr = strText[i];
  1837. strTextChange += _tchr;
  1838. bool bInsertSign = false;
  1839. INT nPosCur = 0;
  1840. if( bCanPastGroupSep )
  1841. nPosCur = _listPos.GetAt( _listPos.FindIndex( nCurDigitPos ) );
  1842. if( ( i <= nWholeNumber )
  1843. && ( i != ( nCorectTextLen - 1 ) )
  1844. && ( i == nPosCur )
  1845. && bCanPastGroupSep
  1846. )
  1847. {
  1848. strTextChange += m_strGroupSeparator;
  1849. bInsertSign = true;
  1850. if( nCurDigitPos < ( nPosCount - 1 ) )
  1851. nCurDigitPos ++;
  1852. else
  1853. bCanPastGroupSep = false;
  1854. }
  1855. if( i == ( nWholeNumber - 1 ) && ( nPositionDecimalPoint == -1 ) && ( i != nCorectTextLen - 1 ) )
  1856. {
  1857. strTextChange += m_strDecimalPoint;
  1858. if( i < ( nStart - 1 ) )
  1859. bInsertedDecimalSignBeforeStart  = true;
  1860. if( i < ( nEnd - 1 ) )
  1861. bInsertedDecimalSignBeforeEnd = true;
  1862. }
  1863. if( bInsertSign )
  1864. {
  1865. if( i < nStart )
  1866. nSignCountBeforeStart ++;
  1867. if( i < nEnd )
  1868. nSignCountBeforeEnd ++;
  1869. }
  1870. }
  1871. if( bInsertNegSign && AllowNegativeGet() )
  1872. {
  1873. INT nNegSignLen = INT( m_strNegativeSign.GetLength() ) + ( ( m_nNegativeFormatIndex == 2 || m_nNegativeFormatIndex == 4 ) ? 1: 0 );
  1874. CExtSafeString _strNegativeSign = ( (m_nNegativeFormatIndex == 4) ? _T(" "): _T("") ) + m_strNegativeSign + ( (m_nNegativeFormatIndex == 2) ? _T(" "): _T("") );
  1875. if( m_nNegativeFormatIndex == 0 )
  1876. {
  1877. strTextChange.Insert( strTextChange.GetLength(), _T(")") );
  1878. strTextChange.Insert( 0, _T("(") );
  1879. nStart += 1;
  1880. nEnd += 1;
  1881. }
  1882. if( m_nNegativeFormatIndex == 1 || m_nNegativeFormatIndex == 2 )
  1883. strTextChange.Insert( 0, _strNegativeSign );
  1884. if( m_nNegativeFormatIndex == 3 || m_nNegativeFormatIndex == 4 )
  1885. strTextChange.Insert( strTextChange.GetLength(), _strNegativeSign );
  1886. if( m_nNegativeFormatIndex == 1 || m_nNegativeFormatIndex == 2 )
  1887. {
  1888. nStart += nNegSignLen;
  1889. nEnd += nNegSignLen;
  1890. }
  1891. }
  1892. strText = strTextChange;
  1893. nStart += nGroupSeparatorLen * nSignCountBeforeStart + ( bInsertedDecimalSignBeforeStart ? nDecimalSeparatorLen : 0 );
  1894. nEnd += nGroupSeparatorLen * nSignCountBeforeEnd + ( bInsertedDecimalSignBeforeEnd ? nDecimalSeparatorLen : 0 );
  1895. }
  1897. bool CExtEditSystemNumber::_IsNegative( __EXT_MFC_SAFE_LPCTSTR strText ) const
  1898. {
  1899. ASSERT_VALID( this );
  1900. CExtSafeString _strText = strText;
  1901. bool bRetVal = ( ( _strText.Find( m_strNegativeSign ) >= 0 ) ? true: false );
  1902. if( m_nNegativeFormatIndex == 0 )
  1903. bRetVal = ( ( _strText.Find( _T('(') ) >= 0 ) ? true: false );
  1904. return bRetVal;
  1905. }
  1907. void CExtEditSystemNumber::_AdjustWithinRange()
  1908. {
  1909. ASSERT_VALID( this );
  1910. if( m_bRichPainting )
  1911. return;
  1912. if( _IsValid() )
  1913. return;
  1914. if( TextGet().IsEmpty() )
  1915. SetWindowText( _T(" ") );
  1916. else
  1917. _Redraw();
  1918. long double dValue = LongDoubleGet();
  1919.     if( dValue < m_lfMin )
  1920. LongDoubleSet( m_lfMin );
  1921.     else if( dValue > m_lfMax )
  1922. LongDoubleSet( m_lfMax );
  1923. CExtSafeString _strText = TextGet();
  1924. bool bNegative = _IsNegative( _strText );
  1925. INT nNegSignPos = -1;
  1926. INT nLen = INT( _strText.GetLength() );
  1927. if( bNegative )
  1928. {
  1929. switch( m_nNegativeFormatIndex )
  1930. {
  1931. case 0:
  1932. nNegSignPos = INT( _strText.Find( _T(")") ) );
  1933. break;
  1934. case 3:
  1935. nNegSignPos = INT( _strText.Find( m_strNegativeSign ) );
  1936. break;
  1937. case 4:
  1938. nNegSignPos = INT( _strText.Find( _T(" ") + m_strNegativeSign ) );
  1939. break;
  1940. }
  1941. }
  1942. _Rich_OnDraw();
  1943. if( ! m_bRichPainting )
  1944. {
  1945. if( nNegSignPos >= 0 )
  1946. SetSel( nNegSignPos, nNegSignPos );
  1947. else
  1948. SetSel( nLen, nLen );
  1949. }
  1950. }
  1952. void CExtEditSystemNumber::_Rich_OnDraw()
  1953. {
  1954. ASSERT_VALID( this );
  1955. if( ! m_bRichMode )
  1956. return;
  1957. if( GetSafeHwnd() == NULL )
  1958. return;
  1959. if( m_bRichPainting )
  1960. return;
  1961. m_bRichPainting = true;
  1962. CHARRANGE crRestore;
  1963. Rich_GetSel( crRestore );
  1964. CHARFORMAT cfDefault;
  1965. ::memset( &cfDefault, 0, sizeof(CHARFORMAT) );
  1966. cfDefault.dwMask = CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_STRIKEOUT|CFM_FACE|CFM_SIZE|CFM_CHARSET|CFM_PROTECTED|CFM_COLOR;
  1967. cfDefault.dwEffects = CFE_PROTECTED; 
  1968. //cfDefault.yHeight = 180;
  1969. //cfDefault.crTextColor = ::GetSysColor( COLOR_WINDOWTEXT );
  1970. CFont * pFont = GetFont();
  1971. if( pFont->GetSafeHandle() == NULL )
  1972. {
  1973. CWnd * pWndParent = GetParent();
  1974. if( pWndParent->GetSafeHwnd() != NULL )
  1975. pFont = pWndParent->GetFont();
  1976. if( pFont->GetSafeHandle() == NULL )
  1977. pFont = &(PmBridge_GetPM()->m_FontNormal);
  1978. }
  1979. LOGFONT _lf; ::memset( &_lf, 0, sizeof(LOGFONT) );
  1980. pFont->GetLogFont( &_lf );
  1981. #if (! defined _RICHEDIT_VER )
  1982. USES_CONVERSION;
  1983. strcpy( cfDefault.szFaceName, T2CA(_lf.lfFaceName) );
  1984. #else
  1985. #if ( _RICHEDIT_VER < 0x0200 )
  1986. USES_CONVERSION;
  1987. strcpy( cfDefault.szFaceName, T2CA(_lf.lfFaceName) );
  1988. #else
  1989. __EXT_MFC_STRCPY( cfDefault.szFaceName, sizeof(cfDefault.szFaceName)/sizeof(cfDefault.szFaceName[0]), _lf.lfFaceName );
  1990. #endif
  1991. #endif
  1992. CWindowDC dcDesktop( NULL );
  1993. cfDefault.yHeight = ::MulDiv( _lf.lfHeight, 72 * 20, dcDesktop.GetDeviceCaps( LOGPIXELSY ) );
  1994. cfDefault.yHeight = abs( cfDefault.yHeight );
  1995. bool bEnabled = IsWindowEnabled() ? true : false, bReadOnly = ( ( GetStyle() & ES_READONLY ) != 0 );
  1996. cfDefault.crTextColor = OnQueryTextColor();
  1997. if( cfDefault.crTextColor == COLORREF(-1L) )
  1998. {
  1999. cfDefault.crTextColor = bEnabled ? ( bReadOnly ? m_clrRichTextReadOnly : m_clrRichTextNormal ) : m_clrRichTextDisabled;
  2000. if( cfDefault.crTextColor == COLORREF(-1L) )
  2001. {
  2002. if( bEnabled )
  2003. {
  2004. if( bReadOnly )
  2005. cfDefault.crTextColor = ::GetSysColor( COLOR_3DSHADOW );
  2006. else
  2007. cfDefault.crTextColor = ::GetSysColor( COLOR_WINDOWTEXT );
  2008. }
  2009. else
  2010. cfDefault.crTextColor = ::GetSysColor( COLOR_GRAYTEXT );
  2011. }
  2012. }
  2013. COLORREF clrBack = OnQueryBackColor();
  2014. if( clrBack == COLORREF(-1L) )
  2015. {
  2016. clrBack = bEnabled ? ( bReadOnly ? m_clrRichBackReadOnly : m_clrRichBackNormal ) : m_clrRichBackDisabled;
  2017. if( clrBack == COLORREF(-1L) )
  2018. {
  2019. if( bEnabled )
  2020. {
  2021. if( bReadOnly )
  2022. clrBack = ::GetSysColor( COLOR_3DFACE );
  2023. else
  2024. clrBack = ::GetSysColor( COLOR_WINDOW );
  2025. }
  2026. else
  2027. clrBack = ::GetSysColor( COLOR_3DFACE );
  2028. }
  2029. }
  2030. Rich_SetBackgroundColor( FALSE, clrBack );
  2031. Rich_HideSelection( true, false );
  2032. Rich_SetSel( 0, -1 ); 
  2033. SendMessage( EM_SETCHARFORMAT, SCF_DEFAULT, LPARAM(&cfDefault) );
  2034. SendMessage( EM_SETCHARFORMAT, SCF_SELECTION, LPARAM(&cfDefault) );
  2035. Rich_SetSelectionColor( cfDefault.crTextColor );
  2037. INT nGroupSeparatorLen = INT( m_strGroupSeparator.GetLength() );
  2038. INT nDecimalSignLen = INT( m_strDecimalPoint.GetLength() );
  2040. COLORREF clrSign = m_clrSign;
  2041. if( clrSign == COLORREF(-1L) )
  2042. clrSign = cfDefault.crTextColor;
  2043. if( m_clrNumber != COLORREF(-1L)
  2044. || m_clrFraction != COLORREF(-1L)
  2045. || m_clrGroupSeparator != COLORREF(-1L)
  2046. || m_clrDecimalSeparator != COLORREF(-1L)
  2047. || m_clrBrackets != COLORREF(-1L)
  2048. || clrSign != COLORREF(-1L)
  2049. )
  2050. {
  2051. CExtSafeString strText = TextGet();
  2052. INT nTextLen = INT( strText.GetLength() );
  2053. if( nTextLen > 0 )
  2054. {
  2055. bool bNegative = _IsNegative( strText );
  2056. INT nPositionDecimalPoint = INT( strText.Find( m_strDecimalPoint ) );
  2058. CExtSafeString _strBefore = _T(""), _strAfter = _T("");
  2059. if( bNegative )
  2060. {
  2061. switch( m_nNegativeFormatIndex )
  2062. {
  2063. case 0:
  2064. _strBefore = _T("(");
  2065. _strAfter = _T(")");
  2066. break;
  2067. case 1:
  2068. _strBefore = m_strNegativeSign;
  2069. break;
  2070. case 2:
  2071. _strBefore = m_strNegativeSign + _T(" ");
  2072. break;
  2073. case 3:
  2074. _strAfter = m_strNegativeSign;
  2075. break;
  2076. case 4:
  2077. _strAfter = _T(" ") + m_strNegativeSign;
  2078. break;
  2079. }
  2080. }
  2082. INT nBeforLen = _strBefore.GetLength();
  2083. INT nAfterLen = _strAfter.GetLength();
  2084. // Whole number
  2085. if( m_clrNumber != COLORREF(-1L) )
  2086. {
  2087. Rich_SetSel( nBeforLen, ( nPositionDecimalPoint != -1 ) ? nPositionDecimalPoint : ( nTextLen - nAfterLen ) );
  2088. Rich_SetSelectionColor( m_clrNumber );
  2089. }
  2091. if( nPositionDecimalPoint != -1 )
  2092. {
  2093. if( m_clrDecimalSeparator != COLORREF(-1L) )
  2094. {
  2095. Rich_SetSel( nPositionDecimalPoint, ( nPositionDecimalPoint + nDecimalSignLen ) );
  2096. Rich_SetSelectionColor( m_clrDecimalSeparator );
  2097. }
  2098. if( m_clrFraction != COLORREF(-1L) )
  2099. {
  2100. Rich_SetSel( nPositionDecimalPoint + nDecimalSignLen, nTextLen - nAfterLen );
  2101. Rich_SetSelectionColor( m_clrFraction );
  2102. }
  2103. }
  2105. if( m_clrGroupSeparator != COLORREF(-1L) )
  2106. {
  2107. INT nPos = 0;
  2108. for( ; true; )
  2109. {
  2110. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  2111. if( nPos == -1 )
  2112. break;
  2113. Rich_SetSel( nPos, ( nPos + nGroupSeparatorLen ) );
  2114. Rich_SetSelectionColor( m_clrGroupSeparator );
  2115. nPos ++;
  2116. }
  2117. }
  2119. if( bNegative && clrSign != COLORREF(-1L) )
  2120. {
  2121. if( ( _strAfter.IsEmpty() || _strBefore.IsEmpty() )
  2122. && ( ! _strAfter.IsEmpty() || !_strBefore.IsEmpty() )
  2123. )
  2124. {
  2125. INT nNegSignPos = INT( strText.Find( m_strNegativeSign ) );
  2126. INT nNegSignLen = INT( m_strNegativeSign.GetLength() );
  2127. if( clrSign != COLORREF(-1L) )
  2128. {
  2129. Rich_SetSel( nNegSignPos, ( nNegSignPos + nNegSignLen ) );
  2130. Rich_SetSelectionColor( clrSign );
  2131. }
  2132. }
  2133. if( ! _strAfter.IsEmpty() && ! _strBefore.IsEmpty() )
  2134. {
  2135. if( m_clrBrackets != COLORREF(-1L) )
  2136. {
  2137. INT i, nPos = 0;
  2138. CString _strBrackets = _T("()[]{}");
  2139. INT nBrackLen = _strBrackets.GetLength();
  2140. for( i = 0; i < nBrackLen; i++ )
  2141. {
  2142. nPos = 0;
  2143. for( ; true; )
  2144. {
  2145. nPos = strText.Find( _strBrackets[i], nPos );
  2146. if( nPos == -1 )
  2147. break;
  2148. Rich_SetSel( nPos, ( nPos + 1 ) );
  2149. Rich_SetSelectionColor( m_clrBrackets ); 
  2150. nPos ++;
  2151. }
  2152. }
  2153. }
  2154. }
  2155. }
  2156. } // if( nTextLen > 0 )
  2157. }
  2158. Rich_SetSel( crRestore );
  2159. Rich_HideSelection( false, false );
  2160. m_bRichPainting = false;
  2161. }
  2163. /////////////////////////////////////////////////////////////////////////////
  2164. // CExtEditSystemCurrency window
  2166. IMPLEMENT_DYNCREATE( CExtEditSystemCurrency, CExtEditSystemNumberCurrencyBase );
  2168. CExtEditSystemCurrency::CExtEditSystemCurrency(
  2169. INT nMaxWholeDigits, // = __EXT_MFC_DEFAULT_MAX_WHOLE_DIGITS
  2170. INT nMaxFractionDigits // = __EXT_MFC_DEFAULT_FRACTION_WHOLE_DIGITS
  2171. )
  2172. : CExtEditSystemNumberCurrencyBase( nMaxWholeDigits, nMaxFractionDigits )
  2173. {
  2174. _Init();
  2175. }
  2177. CExtEditSystemCurrency::~CExtEditSystemCurrency()
  2178. {
  2179. }
  2181. BEGIN_MESSAGE_MAP( CExtEditSystemCurrency, CExtEditSystemNumberCurrencyBase )
  2182. //{{AFX_MSG_MAP(CExtEditSystemNumberCurrencyBase)
  2183. //}}AFX_MSG_MAP
  2184. __EXT_MFC_SAFE_ON_WM_SETTINGCHANGE()
  2185. END_MESSAGE_MAP()
  2187. void CExtEditSystemCurrency::_Init()
  2188. {
  2189. ASSERT_VALID( this );
  2190. // negative sign
  2191. if( g_ResourceManager->GetLocaleInfo( LOCALE_SNEGATIVESIGN, NULL, 0 ) )
  2192. {
  2193. g_ResourceManager->GetLocaleInfo( LOCALE_SNEGATIVESIGN, m_strNegativeSign.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  2194. m_strNegativeSign.ReleaseBuffer();
  2195. }
  2196. if( g_ResourceManager->GetLocaleInfo( LOCALE_SCURRENCY, NULL, 0 ) )
  2197. {
  2198. g_ResourceManager->GetLocaleInfo( LOCALE_SCURRENCY, m_strCurrencySymbol.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  2199. m_strCurrencySymbol.ReleaseBuffer();
  2200. }
  2201. // decimal point
  2202. if( g_ResourceManager->GetLocaleInfo( LOCALE_SMONDECIMALSEP, NULL, 0 ) )
  2203. {
  2204. g_ResourceManager->GetLocaleInfo( LOCALE_SMONDECIMALSEP, m_strDecimalPoint.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  2205. m_strDecimalPoint.ReleaseBuffer();
  2206. }
  2207. // group separator
  2208. if( g_ResourceManager->GetLocaleInfo( LOCALE_SMONTHOUSANDSEP, NULL, 0 ) )
  2209. {
  2210. g_ResourceManager->GetLocaleInfo( LOCALE_SMONTHOUSANDSEP, m_strGroupSeparator.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  2211. m_strGroupSeparator.ReleaseBuffer();
  2212. }
  2213. TCHAR cPosCurFormatIndex = _T('0');
  2214. if( g_ResourceManager->GetLocaleInfo( LOCALE_ICURRENCY, NULL, 0 ) )
  2215. g_ResourceManager->GetLocaleInfo( LOCALE_ICURRENCY, &cPosCurFormatIndex, sizeof( cPosCurFormatIndex ) / sizeof(TCHAR) );
  2216. m_nPositiveFormatIndex = _ttoi( & cPosCurFormatIndex );
  2217. CExtSafeString strNegCurFormatIndex = _T("0");
  2218. if( g_ResourceManager->GetLocaleInfo( LOCALE_INEGCURR, NULL, 0 ) )
  2219. {
  2220. g_ResourceManager->GetLocaleInfo( LOCALE_INEGCURR, strNegCurFormatIndex.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  2221. strNegCurFormatIndex.ReleaseBuffer();
  2222. }
  2223. CExtSafeString strDigitGrouping = _T("0");
  2224. if( g_ResourceManager->GetLocaleInfo( LOCALE_SMONGROUPING, NULL, 0 ) )
  2225. {
  2226. g_ResourceManager->GetLocaleInfo( LOCALE_SMONGROUPING, strDigitGrouping.GetBuffer( _MAX_PATH + 1 ), _MAX_PATH );
  2227. strDigitGrouping.ReleaseBuffer();
  2228. INT nStrLen = INT( strDigitGrouping.GetLength() );
  2229. CExtSafeString _strGroup = _T("");
  2230. INT nGroup = 0;
  2231. if( m_listDigitGrouping.GetCount() > 0 )
  2232. m_listDigitGrouping.RemoveAll();
  2233. for( INT i = 0; i < nStrLen; i++ )
  2234. {
  2235. TCHAR ch = strDigitGrouping[i];
  2236. if( ch == _T(';') )
  2237. {
  2238. nGroup = _ttoi( _strGroup );
  2239. m_listDigitGrouping.AddTail( nGroup );
  2240. _strGroup = _T("");
  2241. nGroup = 0;
  2242. }
  2243. else
  2244. _strGroup = _strGroup + ch;
  2245. }
  2246. nGroup = _ttoi( _strGroup );
  2247. m_listDigitGrouping.AddTail( nGroup );
  2248. }
  2249. m_nNegativeFormatIndex = _ttoi( strNegCurFormatIndex );
  2250. TCHAR cNoOfDigitsAfterDecimal = _T('0');
  2251. if( g_ResourceManager->GetLocaleInfo( LOCALE_ICURRDIGITS, NULL, 0 ) )
  2252. g_ResourceManager->GetLocaleInfo( LOCALE_ICURRDIGITS, &cNoOfDigitsAfterDecimal, sizeof( cNoOfDigitsAfterDecimal ) / sizeof(TCHAR) );
  2253. m_nMaxFractionDigits = _ttoi( & cNoOfDigitsAfterDecimal );
  2254. TCHAR cDisplayLeadingZeros = _T('0');
  2255. if( g_ResourceManager->GetLocaleInfo( LOCALE_ILZERO, NULL, 0 ) )
  2256. g_ResourceManager->GetLocaleInfo( LOCALE_ILZERO, &cDisplayLeadingZeros, sizeof( cDisplayLeadingZeros ) / sizeof(TCHAR) );
  2257. m_nDisplayLeadingZeros = _ttoi( & cDisplayLeadingZeros );
  2258. TCHAR cDigitGrouping[20] = _T("");
  2259. if( g_ResourceManager->GetLocaleInfo( LOCALE_SGROUPING, NULL, 0 ) )
  2260. g_ResourceManager->GetLocaleInfo( LOCALE_SGROUPING, cDigitGrouping, sizeof( cDigitGrouping ) / sizeof( cDigitGrouping[0] ) );
  2261. // ensure the separators are not the same
  2262. if( m_strDecimalPoint == m_strGroupSeparator )
  2263. m_strGroupSeparator = ( m_strDecimalPoint == _T(",") ? _T(".") : _T(",") );
  2264. }
  2266. void CExtEditSystemCurrency::OnSettingChange( UINT uFlags, __EXT_MFC_SAFE_LPCTSTR lpszSection )
  2267. {
  2268. ASSERT_VALID( this );
  2269. CExtEditSystemNumberCurrencyBase::OnSettingChange( uFlags, lpszSection );
  2270. if( _tcscmp( lpszSection, _T("intl") ) == 0 )
  2271. {
  2272. long double lfSaved = LongDoubleGet();
  2273. _Init();
  2274. LongDoubleSet( lfSaved );
  2275. SetSel( -1, -1 );
  2276. }
  2277. }
  2279. CExtSafeString CExtEditSystemCurrency::_GetNumericText(
  2280. const CExtSafeString & strText, 
  2281. bool bUseMathSymbols // = false
  2282. ) const
  2283. {
  2284. ASSERT_VALID( this );
  2285. CExtSafeString strNewText;
  2286. bool bIsNegative = _IsNegative( strText );
  2287. bool bHasDecimalPoint = false;
  2288. INT nDecimalSignLen = INT( m_strDecimalPoint.GetLength() );
  2289. INT nDecimalSignPos = INT( strText.Find( m_strDecimalPoint ) );
  2290. INT nPos, nLen;
  2291. for( nPos = 0, nLen = INT( strText.GetLength() ); nPos < nLen; nPos++ )
  2292. {
  2293. TCHAR c = strText[nPos];
  2294. if( _istdigit(c) )
  2295. strNewText += c;
  2296. else if( nPos == nDecimalSignPos && !bHasDecimalPoint )
  2297. {
  2298. bHasDecimalPoint = true;
  2299. strNewText += ( bUseMathSymbols ? _T(".") : m_strDecimalPoint );
  2300. nPos += nDecimalSignLen - 1;
  2301. }
  2302. }
  2303. if( bUseMathSymbols )
  2304. {
  2305. if( bIsNegative )
  2306. strNewText.Insert( 0, _T("-") );
  2307. }
  2308. else
  2309. {
  2310. CExtSafeString _strBefore = _T("");
  2311. CExtSafeString _strAfter = _T("");
  2312. _GetSignStrings( _strBefore, _strAfter, bIsNegative && AllowNegativeGet() );
  2313. if( ! _strAfter.IsEmpty() )
  2314. strNewText.Insert( strNewText.GetLength(), _strAfter );
  2315. if( ! _strBefore.IsEmpty() )
  2316. strNewText.Insert( 0, _strBefore );
  2317. }
  2318. return strNewText;
  2319. }
  2321. CExtSafeString CExtEditSystemCurrency::_GetDoubleText( long double lfValue, bool bTrimTrailingZeros /*= true*/ ) const
  2322. {
  2323. ASSERT_VALID( this );
  2324. CExtSafeString strText;
  2325. strText.Format( _T("%lf"), lfValue );
  2326. if( m_strDecimalPoint != _T(".") )
  2327. strText.Replace( _T("."), m_strDecimalPoint );
  2328. if( bTrimTrailingZeros )
  2329. {
  2330. strText.TrimRight( _T("0") );
  2331. strText.TrimRight( m_strDecimalPoint );
  2332. }
  2333. bool bNegative = ( strText.Find( _T("-") ) == 0 ) ? true : false;
  2334. if( bNegative )
  2335. strText.Delete( 0 );
  2336. CExtSafeString _strBefore = _T("");
  2337. CExtSafeString _strAfter = _T("");
  2338. _GetSignStrings( _strBefore, _strAfter, bNegative && AllowNegativeGet() );
  2339. INT nLen = INT( strText.GetLength() );
  2340. if( ! _strAfter.IsEmpty() )
  2341. strText.Insert( nLen, _strAfter );
  2342. if( ! _strBefore.IsEmpty() )
  2343. strText.Insert( 0, _strBefore );
  2344. return strText;
  2345. }
  2347. void CExtEditSystemCurrency::IntSet( INT nVal )
  2348. {
  2349. ASSERT_VALID( this );
  2350. CExtSafeString strText;
  2351. strText.Format( _T("%d"), nVal );
  2352. bool bNegative = ( strText.Find( _T("-") ) == 0 ) ? true : false;
  2353. strText.Delete( 0 );
  2354. CExtSafeString _strBefore = _T("");
  2355. CExtSafeString _strAfter = _T("");
  2356. _GetSignStrings( _strBefore, _strAfter, bNegative && AllowNegativeGet() );
  2357. INT nLen = INT( strText.GetLength() );
  2358. if( ! _strAfter.IsEmpty() )
  2359. strText.Insert( nLen, _strAfter );
  2360. if( ! _strBefore.IsEmpty() )
  2361. strText.Insert( 0, _strBefore );
  2362. m_pEditWithBehaviorWnd->SetWindowText(strText);
  2363. }
  2365. long double CExtEditSystemCurrency::LongDoubleGet() const
  2366. {
  2367. ASSERT_VALID( this );
  2368. // return _tcstod( _GetNumericText( m_pEditWithBehaviorWnd->TextGet(), true ), NULL );
  2369. CExtSafeString str = _GetNumericText( m_pEditWithBehaviorWnd->TextGet(), true );
  2370. if( str.IsEmpty()
  2371.    || str == _T(".")
  2372.    || str == LPCTSTR(m_strDecimalPoint)
  2373.    || ( str.GetLength() == 1 && m_strDecimalPoint.GetLength() > 0 && str[0] == m_strDecimalPoint[0] )
  2374.    )
  2375.    return 0.0;
  2376. LCID _LCID = LANG_USER_DEFAULT;
  2377. if( g_ResourceManager->IsCustomLangAllowed() )
  2378. _LCID = g_ResourceManager->GetLangIdDesired();
  2379. COleCurrency _oleCurrency;
  2380. VERIFY( _oleCurrency.ParseCurrency( LPCTSTR(str), 0, _LCID ) );
  2381. long double lfVal = ((long double)_oleCurrency.m_cur.int64) / ((long double)10000.0);
  2382. return lfVal;
  2383. }
  2385. INT CExtEditSystemCurrency::IntGet() const
  2386. {
  2387. ASSERT_VALID( this );
  2388. // return (INT)_ttoi( _GetNumericText( m_pEditWithBehaviorWnd->TextGet() ) );
  2389. CExtSafeString str = _GetNumericText( m_pEditWithBehaviorWnd->TextGet(), true );
  2390. if( str.IsEmpty() )
  2391. return 0;
  2392. LCID _LCID = LANG_USER_DEFAULT;
  2393. if( g_ResourceManager->IsCustomLangAllowed() )
  2394. _LCID = g_ResourceManager->GetLangIdDesired();
  2395. COleCurrency _oleCurrency;
  2396. VERIFY( _oleCurrency.ParseCurrency( LPCTSTR(str), 0, _LCID ) );
  2397. __int64 nVal = ((__int64)_oleCurrency.m_cur.int64) / ((__int64)10000);
  2398. return INT(nVal);
  2399. }
  2401. CExtSafeString CExtEditSystemCurrency::Behavior_GetValidText(
  2402. bool bSetSel // = false
  2403. ) const
  2404. {
  2405. ASSERT_VALID( this );
  2406. CExtSafeString strText = m_pEditWithBehaviorWnd->TextGet();
  2407. CExtSafeString strNewText = strText;
  2408. bool bIsNegative = _IsNegative( strText );
  2409. INT nStart, nEnd;
  2410. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  2411. _GetTextWithoutMarks( strNewText, nStart, nEnd );
  2412. _GetTextWithMarks( strNewText, nStart, nEnd, ( bIsNegative && AllowNegativeGet() ) );
  2413. if( bSetSel && ( ! m_bRichPainting ) )
  2414. {
  2415. CExtSafeString strCurrentText = m_pEditWithBehaviorWnd->TextGet();
  2416. if( strNewText != strCurrentText )
  2417. m_pEditWithBehaviorWnd->SetWindowText( strNewText );
  2418. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  2419. }
  2420. return strNewText;
  2421. }
  2423. void CExtEditSystemCurrency::Behavior_OnChar( UINT uChar, UINT nRepCnt, UINT nFlags )
  2424. {
  2425. ASSERT_VALID( this );
  2426. if( m_pEditWithBehaviorWnd->GetStyle() & ES_READONLY )
  2427. return;
  2428. TCHAR c = static_cast<TCHAR>( uChar );
  2429. INT nStart, nEnd;
  2430. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  2431. CExtSafeString strText = m_pEditWithBehaviorWnd->TextGet();
  2432. CExtSafeString strNumericText = _GetNumericText( strText );
  2433. INT nDecimalPos = INT( strText.Find( m_strDecimalPoint ) );
  2434. INT nNumericDecimalPos = INT( strNumericText.Find( m_strDecimalPoint ) );
  2435. INT nLen = INT( strText.GetLength() );
  2436. INT nNumericLen = INT( strNumericText.GetLength() );
  2437. INT nSepCount = _GetGroupSeparatorCount( strText );
  2438. bool bNeedAdjustment = false;
  2439. bool bIsNegative = false;
  2440. bool bIsDecimalPoint = false;
  2441. if( ( c == m_strNegativeSign[0] )
  2442. || ( ( m_nNegativeFormatIndex == 0
  2443. || m_nNegativeFormatIndex == 4
  2444. || m_nNegativeFormatIndex == 14
  2445. || m_nNegativeFormatIndex == 15
  2446. )
  2447. && c == _T('(') 
  2448. )
  2449. || ( c == _T('-') )
  2450. )
  2451. {
  2452. bIsNegative = true;
  2453. }
  2454. // test whether it is a negative sign
  2455. if( bIsNegative && AllowNegativeGet() )
  2456. {
  2457. bool bNegative = _IsNegative( strText );
  2458. CExtSafeString _strBefore = _T(""), _strAfter = _T("");
  2459. _GetSignStrings( _strBefore, _strAfter, bNegative );
  2460. INT nBeforLen = INT( _strBefore.GetLength() );
  2461. INT nAfterLen = INT( _strAfter.GetLength() );
  2462. CExtSafeString strNewText = strText;
  2463. m_pEditWithBehaviorWnd->GetSel( nStart, nEnd );
  2464. if( nStart < nBeforLen )
  2465. nStart = nBeforLen;
  2466. if( nEnd > ( nLen - nAfterLen ) )
  2467. nEnd = ( nLen - nAfterLen );
  2468. _GetTextWithoutMarks( strNewText, nStart, nEnd );
  2469. _GetTextWithMarks( strNewText, nStart, nEnd, ! bNegative );
  2470. CExtSafeString strCurrentText = m_pEditWithBehaviorWnd->TextGet();
  2471. if( strNewText != strCurrentText )
  2472. m_pEditWithBehaviorWnd->SetWindowText( strNewText );
  2473. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  2474. return;
  2475. }
  2476. // test whether it is a decimal point (only one is enabled)
  2477. else if( c == m_strDecimalPoint[0] && m_nMaxFractionDigits > 0 )
  2478. {
  2479. if( nDecimalPos >= 0 )
  2480. {
  2481. // test decimal point replacement
  2482. if( nDecimalPos >= nStart && nDecimalPos < nEnd )
  2483. {
  2484. bNeedAdjustment = true;
  2485. bIsDecimalPoint = true;
  2486. }
  2487. else
  2488. { // else set caret
  2489. m_pEditWithBehaviorWnd->SetSel( nDecimalPos + m_strDecimalPoint.GetLength(), nDecimalPos + m_strDecimalPoint.GetLength() );
  2490. //m_pEditWithBehaviorWnd->SetSel( nDecimalPos + 1, nDecimalPos + 1 );
  2491. return;
  2492. }
  2493. }
  2494. else
  2495. {
  2496. bNeedAdjustment = true;
  2497. bIsDecimalPoint = true;
  2498. }
  2499. }
  2500. // test if it's a digit
  2501. else if( _istdigit(c) )
  2502. {
  2503. // test whether we're on the right of the decimal point
  2504. if( nDecimalPos >= 0 && nDecimalPos < nStart )
  2505. {
  2506. bool bIsNegative = _IsNegative( strNumericText );
  2507. CExtSafeString _strBeforeCurrency = _T("");
  2508. CExtSafeString _strAfterCurrency = _T("");
  2509. _GetSignStrings( _strBeforeCurrency, _strAfterCurrency, bIsNegative && AllowNegativeGet() );
  2510. INT nNegLength = INT( _strAfterCurrency.GetLength() );
  2511. if( ! _strAfterCurrency.IsEmpty() )
  2512. {
  2513. INT nNegSignPos = -1;
  2514. if( ! _strAfterCurrency.IsEmpty() )
  2515. nNegSignPos = INT( strText.Find( _strAfterCurrency ) );
  2516. if( ( nStart > nNegSignPos ) && ( nStart <= nLen ) && nNegSignPos != -1 )
  2517. {
  2518. nStart = nNegSignPos;
  2519. m_pEditWithBehaviorWnd->SetSel( nStart, nStart );
  2520. }
  2521. }
  2522. INT nDecimalSeparatorLen = INT( m_strDecimalPoint.GetLength() );
  2523. if( nDecimalPos <= nStart && nStart < ( nDecimalPos + nDecimalSeparatorLen ) )
  2524. {
  2525. INT nPrevStart = nStart;
  2526. nStart = ( nDecimalPos + nDecimalSeparatorLen );
  2527. if( nEnd == nPrevStart 
  2528. || nEnd < nPrevStart 
  2529. || ( nEnd > nPrevStart 
  2530. && nEnd < nStart
  2531. )
  2532. )
  2533. nEnd = nStart;
  2534. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  2535. }
  2536. if( strNumericText.Mid( /*nDecimalPos */nNumericDecimalPos + nDecimalSeparatorLen ).GetLength() == ( m_nMaxFractionDigits + nNegLength ) )
  2537. {
  2538. if( nStart <= ( nDecimalPos + m_nMaxFractionDigits + nDecimalSeparatorLen - 1 ) )
  2539. {
  2540. //nEnd = ( ( ( nEnd == nLen ) || ( nEnd > nStart ) ) ? nEnd : (nStart + 1) );
  2541. nEnd = ( ( ( nEnd == nLen ) || ( nEnd > ( nStart + 1 ) ) ) ? nEnd : (nStart + 1) );
  2542. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  2543. m_pEditWithBehaviorWnd->ReplaceSel( CExtSafeString(c), TRUE );
  2544. }
  2545. return;
  2546. }
  2547. else if( strNumericText.Mid( nNumericDecimalPos + nDecimalSeparatorLen ).GetLength() > ( m_nMaxFractionDigits + nNegLength ) )
  2548. {
  2549. ASSERT(false);
  2550. return;
  2551. }
  2552. }
  2553. // we're on the left side of the decimal point
  2554. else
  2555. {
  2556. bool bIsNegative = _IsNegative( strNumericText );
  2557. CExtSafeString _strBeforeCurrency = _T("");
  2558. CExtSafeString _strAfterCurrency = _T("");
  2559. _GetSignStrings( _strBeforeCurrency, _strAfterCurrency, bIsNegative && AllowNegativeGet() );
  2560. INT nNegLength = INT( _strBeforeCurrency.GetLength() );
  2561. INT nAfterSignsLength = INT( _strAfterCurrency.GetLength() );
  2562. if( nNegLength > 0 )
  2563. {
  2564. if( ( nStart >= 0 ) && ( nStart < nNegLength ) )
  2565. {
  2566. nStart = nNegLength;
  2567. if( nStart > nEnd )
  2568. nEnd = nStart;
  2569. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  2570. }
  2571. }
  2572. if( nAfterSignsLength > 0 )
  2573. {
  2574. if( ( nEnd >= ( nLen - nAfterSignsLength ) ) && ( nEnd <= nLen ) )
  2575. {
  2576. nEnd = nLen - nAfterSignsLength;
  2577. if( nStart > nEnd )
  2578. nStart = nEnd;
  2579. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  2580. }
  2581. if( ( nStart >= ( nLen - nAfterSignsLength ) ) && ( nStart <= nLen ) )
  2582. {
  2583. nStart = nLen - nAfterSignsLength;
  2584. m_pEditWithBehaviorWnd->SetSel( nStart, nStart );
  2585. }
  2586. }
  2587. INT nGroupSeparatorLen = INT( m_strGroupSeparator.GetLength() );
  2588. INT nDecimalSignLen = INT( m_strDecimalPoint.GetLength() );
  2589. // ensure we can still enter digits
  2590. INT nDecPos = m_nMaxWholeDigits + nNegLength + ( nSepCount * nGroupSeparatorLen );
  2591. if( nStart == nDecPos )
  2592. {
  2593. UINT nFlags = CBehaviorBase::m_nBehaviorFlags;
  2594. if(  nFlags & __ESE_ADD_DECIMAL_AFTER_MAX_WHOLE_DIGITS && m_nMaxFractionDigits > 0 )
  2595. {
  2596. nEnd = ( ( ( nEnd == nLen ) || ( ( nEnd > nStart ) && ( ( nEnd - nStart ) > 1 ) ) ) ? nEnd : ( nStart + nDecimalSignLen + 1 ) );
  2598. if( _strAfterCurrency.GetLength() > 0 )
  2599. {
  2600. m_pEditWithBehaviorWnd->SetSel( nStart, strText.GetLength() );
  2601. m_pEditWithBehaviorWnd->ReplaceSel( _T(""), TRUE );
  2602. }
  2603. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  2604. m_pEditWithBehaviorWnd->ReplaceSel( m_strDecimalPoint + c, TRUE );
  2605. if( _strAfterCurrency.GetLength() > 0 )
  2606. {
  2607. CExtSafeString strChangedText = m_pEditWithBehaviorWnd->TextGet();
  2608. INT nEnd = INT( strChangedText.GetLength() );
  2609. m_pEditWithBehaviorWnd->SetSel( nEnd, nEnd );
  2610. m_pEditWithBehaviorWnd->ReplaceSel( _strAfterCurrency, TRUE );
  2611. m_pEditWithBehaviorWnd->SetSel( nEnd, nEnd );
  2612. }
  2613. CExtSafeString strReplaceText = Behavior_GetValidText( true );
  2614. }
  2615. return;
  2616. }
  2617. if( strNumericText.Mid( 
  2618. 0, 
  2619. ( ( nNumericDecimalPos >= 0 )
  2620. ? nNumericDecimalPos
  2621. : nNumericLen
  2622. )
  2623. ).GetLength()
  2624. == ( m_nMaxWholeDigits + nNegLength )
  2625. )
  2626. {
  2627. INT nPos = 0;
  2628. for( ; true; )
  2629. {
  2630. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  2631. if( nPos == -1 )
  2632. break;
  2633. if( nPos <= nStart && nStart < ( nPos + nGroupSeparatorLen ) )
  2634. {
  2635. nStart = nPos + nGroupSeparatorLen;
  2636. break;
  2637. }
  2638. nPos ++;
  2639. }
  2640. INT _nNegativeSignLen = nNegLength;
  2641. if( nStart < _nNegativeSignLen )
  2642. nStart = _nNegativeSignLen;
  2643. nEnd = ( ( ( nEnd == nLen ) || ( nEnd > nStart ) ) ? nEnd : ( nStart + 1 ) );
  2644. if( _strAfterCurrency.GetLength() > 0 )
  2645. {
  2646. INT nNegSignPos = INT( strText.Find( _strAfterCurrency ) );
  2647. if( nEnd > nNegSignPos )
  2648. nEnd = nNegSignPos;
  2649. }
  2650. if( ! m_bRichPainting )
  2651. m_pEditWithBehaviorWnd->SetSel( nStart, nEnd );
  2652. m_pEditWithBehaviorWnd->ReplaceSel( CExtSafeString(c), TRUE );
  2653. CExtSafeString strReplaceText = Behavior_GetValidText(true);
  2654. return;
  2655. }
  2656. bNeedAdjustment = true;
  2657. }
  2658. }
  2659. // test whether it is a non-printable character (i.e. backspace, ctrl+c )
  2660. else if( ! ( _istprint( c ) || IsCharAlphaNumeric( c ) ) )
  2661. bNeedAdjustment = true;
  2662. else
  2663. return;
  2664. if( ! m_bBackspace )
  2665. {
  2666. //CExtEditSystemNumberCurrencyBase::CBehaviorBase::Behavior_OnChar( uChar, nRepCnt, nFlags );
  2667. CBehaviorBase::Behavior_OnChar( uChar, nRepCnt, nFlags );
  2669. // if the decimal point was added/removed or a separator needs adding/removing, adjust the text
  2670. if( bNeedAdjustment )
  2671. _AdjustSeparators( nSepCount, bIsDecimalPoint );
  2672. }
  2673. else
  2674. m_bBackspace = false;
  2675. }
  2677. bool CExtEditSystemCurrency::_DeleteSymbols( 
  2678. CExtSafeString & strText, 
  2679. INT & nStart, 
  2680. INT & nEnd, 
  2681. bool bBackspace // = false
  2682. )
  2683. {
  2684. ASSERT_VALID( this );
  2685. ASSERT( ! m_bRichPainting );
  2686. INT nLen = INT( strText.GetLength() );
  2687. bool bNegative = _IsNegative( strText );
  2688. CExtSafeString strTextLen = strText;
  2689. INT nStLen = 0, nEndLen = 0;
  2690. _GetTextWithoutMarks( strTextLen, nStLen, nEndLen );
  2691. INT nTextLen = INT( strTextLen.GetLength() );
  2692. INT nDecSepPosLen = INT( strTextLen.Find( m_strDecimalPoint ) );
  2693. INT nGroupSeparatorLen = INT( m_strGroupSeparator.GetLength() );
  2694. INT nDecimalSeparatorLen = INT( m_strDecimalPoint.GetLength() );
  2695. INT nDecimalSeparatorPos = INT( strText.Find( m_strDecimalPoint ) );
  2696. INT _nPos = 0, _nGroupSignBeforeStart = 0, _nGroupSignCount = (INT)_GetGroupSeparatorCount( strText );
  2697. for( ; true; )
  2698. {
  2699. _nPos = (INT)strText.Find( m_strGroupSeparator, _nPos );
  2700. if( _nPos < 0 )
  2701. break;
  2702. if( _nPos < nStart )
  2703. _nGroupSignBeforeStart ++;
  2704. _nPos ++;
  2705. }
  2706. _nGroupSignBeforeStart = _nGroupSignCount - _nGroupSignBeforeStart;
  2707. if( bBackspace )
  2708. {
  2709. if( nStart == 0 && nStart == nEnd )
  2710. return false;
  2711. INT nPos = 0;
  2712. if( nStart >= 0 )
  2713. {
  2714. if( ( nDecimalSeparatorPos < nStart
  2715. || ( nDecimalSeparatorPos == nStart
  2716. && nStart != nEnd
  2717. )
  2718. )
  2719. && nStart <= ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  2720. && nEnd <= ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  2721. && nDecSepPosLen == m_nMaxWholeDigits
  2722. && ( nTextLen > ( nDecSepPosLen + nDecimalSeparatorLen )
  2723. && nDecSepPosLen != -1
  2724. )
  2725. )
  2726. {
  2727. nStart = nDecimalSeparatorPos;
  2728. nEnd = nDecimalSeparatorPos;
  2729. m_bBackspace = true;
  2730. return false;
  2731. }
  2732. for( ; true; )
  2733. {
  2734. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  2735. if( nPos == -1 )
  2736. break;
  2737. if( ( nPos < nStart 
  2738. || ( nPos == nStart 
  2739. && nStart != nEnd
  2740. )
  2741. )
  2742. && nStart <= ( nPos + nGroupSeparatorLen )
  2743. && nEnd <= ( nPos + nGroupSeparatorLen )
  2744. )
  2745. {
  2746. nStart = nPos;
  2747. nEnd = nPos;
  2748. m_bBackspace = true;
  2749. return false;
  2750. }
  2752. nPos ++;
  2753. }
  2754. }
  2755. }
  2756. else
  2757. {
  2758. if( nStart == nLen )
  2759. return false;
  2760. INT nPos = 0;
  2761. if( nStart < nLen )
  2762. {
  2763. if( nDecimalSeparatorPos <= nStart
  2764. && nStart < ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  2765. && nEnd <= ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  2766. && nDecSepPosLen == m_nMaxWholeDigits
  2767. && ( nTextLen > ( nDecSepPosLen + nDecimalSeparatorLen )
  2768. && nDecSepPosLen != -1
  2769. )
  2770. )
  2771. {
  2772. nStart = nDecimalSeparatorPos + nDecimalSeparatorLen;
  2773. nEnd = nDecimalSeparatorPos + nDecimalSeparatorLen;
  2774. return false;
  2775. }
  2776. for( ; true; )
  2777. {
  2778. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  2779. if( nPos == -1 )
  2780. break;
  2781. if( nPos <= nStart 
  2782. && nStart < ( nPos + nGroupSeparatorLen )
  2783. && nEnd <= ( nPos + nGroupSeparatorLen )
  2784. )
  2785. {
  2786. nStart = nPos + nGroupSeparatorLen;
  2787. nEnd = nPos + nGroupSeparatorLen;
  2788. return false;
  2789. }
  2790. nPos ++;
  2791. }
  2792. }
  2793. }
  2794. if( nStart != nEnd )
  2795. {
  2796. if( nDecimalSeparatorPos < nStart
  2797. && nStart < ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  2798. )
  2799. {
  2800. nStart = nDecimalSeparatorPos + nDecimalSeparatorLen;
  2801. if( nStart > nEnd )
  2802. nEnd = nStart;
  2803. }
  2804. if( nDecimalSeparatorPos < nEnd
  2805. && nEnd <= ( nDecimalSeparatorPos + nDecimalSeparatorLen )
  2806. )
  2807. nEnd = nDecimalSeparatorPos;
  2808. INT nPos = 0;
  2809. for( ; true; )
  2810. {
  2811. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  2812. if( nPos == -1 )
  2813. break;
  2814. if( nPos < nStart 
  2815. && nStart < ( nPos + nGroupSeparatorLen )
  2816. )
  2817. {
  2818. nStart = nPos + nGroupSeparatorLen;
  2819. if( nStart >= nEnd )
  2820. {
  2821. nEnd = nStart;
  2822. break;
  2823. }
  2824. }
  2825. if( nPos < nEnd 
  2826. && nEnd < ( nPos + nGroupSeparatorLen )
  2827. )
  2828. {
  2829. nEnd = nPos;
  2830. if( nEnd < nStart )
  2831. nStart = nEnd;
  2832. if( nEnd >= nStart )
  2833. break;
  2834. }
  2835. nPos ++;
  2836. }
  2837. }
  2839. {
  2840. CExtSafeString _strBefore = _T("");
  2841. CExtSafeString _strAfter = _T("");
  2842. _GetSignStrings( _strBefore, _strAfter, bNegative && AllowNegativeGet() );
  2843. INT nBeforeLen = INT( _strBefore.GetLength() );
  2844. INT nAfterLen = INT( _strAfter.GetLength() );
  2845. bool bNegDel = false;
  2846. if( bNegative )
  2847. {
  2848. if( ( nStart < nBeforeLen
  2849. || ( nStart == nBeforeLen
  2850. && nStart == nEnd  
  2851. && bBackspace 
  2852. ) 
  2853. ) 
  2854. && nBeforeLen > 0
  2855. )
  2856. {
  2857. bNegative = false;
  2858. bNegDel = true;
  2859. }
  2860. if( ( ( nStart >= ( nLen - nAfterLen ) && ! bBackspace ) 
  2861. || ( nStart > ( nLen - nAfterLen ) && bBackspace ) 
  2862. || ( nStart == nLen  && nStart == nEnd  && bBackspace ) 
  2863. || nEnd > ( nLen - nAfterLen )
  2864. ) 
  2865. && nAfterLen > 0
  2866. )
  2867. {
  2868. bNegative = false;
  2869. bNegDel = true;
  2870. }
  2871. }
  2872. else
  2873. {
  2874. if( ( ( nStart < nBeforeLen
  2875. && nEnd <= nBeforeLen
  2876. )
  2877. || ( nStart == nBeforeLen
  2878. && nStart == nEnd  
  2879. && bBackspace 
  2880. ) 
  2881. ) 
  2882. && nBeforeLen > 0
  2883. )
  2884. {
  2885. nStart = nBeforeLen;
  2886. return true;
  2887. }
  2888. if( ( ( nStart >= ( nLen - nAfterLen ) && ! bBackspace ) 
  2889. || ( nStart > ( nLen - nAfterLen ) && bBackspace ) 
  2890. || ( nStart == nLen  && nStart == nEnd  && bBackspace ) 
  2891. ) 
  2892. && nAfterLen > 0
  2893. )
  2894. {
  2895. nStart = nLen - nAfterLen;
  2896. return true;
  2897. }
  2898. if( nEnd > ( nLen - nAfterLen ) 
  2899. && nAfterLen > 0
  2900. )
  2901. nEnd = nLen - nAfterLen;
  2902. }
  2903. _GetTextWithoutMarks( strText, nStart, nEnd );
  2904. if( bBackspace )
  2905. {
  2906. bool bSelect = ( nStart != nEnd ) ? true : false;
  2907. strText.Delete( ( nStart != nEnd ) ? nStart : ( nStart - 1 ), ( nStart != nEnd ) ? ( nEnd - nStart ) : ( bNegDel ? 0 : 1 ) );
  2908. if( ! bSelect && ! bNegDel )
  2909. nStart --;
  2910. m_bBackspace = true;
  2911. }
  2912. else
  2913. {
  2914. INT _nDecimalPointPos = INT( strText.Find( m_strDecimalPoint ) );
  2915. if( _nDecimalPointPos != -1 )
  2916. {
  2917. if( nStart > _nDecimalPointPos 
  2918. && nStart < ( _nDecimalPointPos + nDecimalSeparatorLen )
  2919. )
  2920. nStart = _nDecimalPointPos;
  2921. if( nEnd > _nDecimalPointPos 
  2922. && nEnd < ( _nDecimalPointPos + nDecimalSeparatorLen )
  2923. )
  2924. nEnd = _nDecimalPointPos + nDecimalSeparatorLen;
  2925. }
  2926. strText.Delete( nStart, ( nStart != nEnd ) ? ( nEnd - nStart ) : ( bNegDel ? 0 : 1 ) );
  2927. }
  2928. _GetTextWithoutMarks( strText, nStart, nEnd );
  2929. _GetTextWithMarks( strText, nStart, nEnd, bNegative );
  2930. if( m_bBackspace && ( nStart - nGroupSeparatorLen ) >= 0 )
  2931. {
  2932. INT nGroupSepPos = (INT)strText.Find( m_strGroupSeparator, ( nStart - nGroupSeparatorLen ) );
  2933. if( nGroupSepPos >= 0 )
  2934. {
  2935. INT _nPos = 0;
  2936. INT _nGroupSignBeforeStartAfterDelete = 0;
  2937. bool _bChangePos = false;
  2938. INT _nGroupSignCountAfterDelete = (INT)_GetGroupSeparatorCount( strText );
  2939. for( ; true; )
  2940. {
  2941. _nPos = (INT)strText.Find( m_strGroupSeparator, _nPos );
  2942. if( _nPos < 0 )
  2943. break;
  2944. if( _nPos < nStart )
  2945. _nGroupSignBeforeStartAfterDelete ++;
  2946. _nPos ++;
  2947. }
  2948. _nGroupSignBeforeStartAfterDelete = _nGroupSignCountAfterDelete - _nGroupSignBeforeStartAfterDelete;
  2949. if( ( _nGroupSignBeforeStart - 1 ) == _nGroupSignBeforeStartAfterDelete )
  2950. _bChangePos = true;
  2951. if( nGroupSepPos == ( nStart - nGroupSeparatorLen ) && _bChangePos )
  2952. nStart = nGroupSepPos;
  2953. }
  2954. }
  2955. }
  2956. return true;
  2957. }
  2959. INT CExtEditSystemCurrency::_GetSignLengthBeforeCurrency( 
  2960. bool bNegative // = false 
  2961. ) const
  2962. {
  2963. ASSERT_VALID( this );
  2964. INT nCurSignLength = INT( m_strCurrencySymbol.GetLength() );
  2965. INT nNegSignLenBeforeCur = 0;
  2966. INT nPosSignLenBeforeCur = 0;
  2967. INT nSpecificSymbLength = 1; // Bracket or Space
  2968. if( bNegative )
  2969. {
  2970. CExtSafeString strBefore = _T("");
  2971. CExtSafeString strAfter = _T("");
  2972. _GetSignStrings( strBefore, strAfter );
  2973. nNegSignLenBeforeCur = INT( strBefore.GetLength() );
  2974. }
  2975. switch( m_nPositiveFormatIndex )
  2976. {
  2977. case 0:
  2978. nPosSignLenBeforeCur = nCurSignLength;
  2979. break;
  2980. case 2:
  2981. nPosSignLenBeforeCur = nCurSignLength + nSpecificSymbLength;
  2982. break;
  2983. }
  2984. return bNegative ? nNegSignLenBeforeCur : nPosSignLenBeforeCur;
  2985. }
  2987. void CExtEditSystemCurrency::_GetSignStrings( 
  2988. CExtSafeString & strBeforeCurrency, 
  2989. CExtSafeString & strAfterCurrency,
  2990. bool bNegative // = true
  2991. ) const
  2992. {
  2993. ASSERT_VALID( this );
  2994. CExtSafeString strBefore = _T("");
  2995. CExtSafeString strAfter = _T("");
  2996. if( bNegative )
  2997. {
  2998. switch( m_nNegativeFormatIndex )
  2999. {
  3000. case 0:
  3001. strBefore = _T("(") + m_strCurrencySymbol;
  3002. strAfter = _T(")");
  3003. break;
  3004. case 1:
  3005. strBefore = m_strNegativeSign + m_strCurrencySymbol;
  3006. break;
  3007. case 2:
  3008. strBefore = m_strCurrencySymbol + m_strNegativeSign;
  3009. break;
  3010. case 3:
  3011. strBefore = m_strCurrencySymbol;
  3012. strAfter = m_strNegativeSign;
  3013. break;
  3014. case 4:
  3015. strBefore = _T("(");
  3016. strAfter = m_strCurrencySymbol + _T(")");
  3017. break;
  3018. case 5:
  3019. strBefore = m_strNegativeSign;
  3020. strAfter = m_strCurrencySymbol;
  3021. break;
  3022. case 6:
  3023. strAfter = m_strNegativeSign + m_strCurrencySymbol;
  3024. break;
  3025. case 7:
  3026. strAfter = m_strCurrencySymbol + m_strNegativeSign;
  3027. break;
  3028. case 8:
  3029. strBefore = m_strNegativeSign;
  3030. strAfter = _T(" ") + m_strCurrencySymbol;
  3031. break;
  3032. case 9:
  3033. strBefore = m_strNegativeSign + m_strCurrencySymbol + _T(" ");
  3034. break;
  3035. case 10:
  3036. strAfter = _T(" ") + m_strCurrencySymbol + m_strNegativeSign;
  3037. break;
  3038. case 11:
  3039. strBefore = m_strCurrencySymbol + _T(" ");
  3040. strAfter = m_strNegativeSign;
  3041. break;
  3042. case 12:
  3043. strBefore = m_strCurrencySymbol + _T(" ") + m_strNegativeSign;
  3044. break;
  3045. case 13:
  3046. strAfter = m_strNegativeSign + _T(" ") + m_strCurrencySymbol;
  3047. break;
  3048. case 14:
  3049. strBefore = _T("(") + m_strCurrencySymbol + _T(" ");
  3050. strAfter = _T(")");
  3051. break;
  3052. case 15:
  3053. strBefore = _T("(");
  3054. strAfter = _T(" ") + m_strCurrencySymbol + _T(")");
  3055. break;
  3056. }
  3057. }
  3058. else
  3059. {
  3060. switch( m_nPositiveFormatIndex )
  3061. {
  3062. case 0:
  3063. strBefore = m_strCurrencySymbol;
  3064. break;
  3065. case 1:
  3066. strAfter = m_strCurrencySymbol;
  3067. break;
  3068. case 2:
  3069. strBefore = m_strCurrencySymbol + _T(" ");
  3070. break;
  3071. case 3:
  3072. strAfter = _T(" ") + m_strCurrencySymbol;
  3073. break;
  3074. }
  3075. }
  3076. strBeforeCurrency = strBefore;
  3077. strAfterCurrency = strAfter;
  3078. }
  3080. void CExtEditSystemCurrency::_GetTextWithoutMarks( 
  3081. CExtSafeString & strText, 
  3082. INT & nStart, 
  3083. INT & nEnd, 
  3084. bool bCutDecimalPoint // = false 
  3085. ) const
  3086. {
  3087. ASSERT_VALID( this );
  3088. CExtSafeString strCurrentText;
  3089. INT nStartPos = nStart, nEndPos = nEnd;
  3090. INT nSignCountBeforeStartPos ,nSignCountBeforeEndPos ,nSignCount;
  3091. bool bIsNegative = _IsNegative(strText);
  3092. INT nDecimalSeparatorLen = INT( m_strDecimalPoint.GetLength() );
  3093. INT nDecimalSeparatorPos = INT( strText.Find( m_strDecimalPoint ) );
  3094. CExtSafeString _strBefore = _T("");
  3095. CExtSafeString _strAfter = _T("");
  3096. _GetSignStrings( _strBefore, _strAfter, bIsNegative );
  3097. INT nStrLen = INT( strText.GetLength() );
  3098. if( nEndPos > INT( strText.GetLength() ) )
  3099. nEndPos = INT( strText.GetLength() );
  3100. nSignCountBeforeStartPos = nSignCountBeforeEndPos = nSignCount = 0;
  3101. for( INT i = 0; i < nStrLen; i++ )
  3102. {
  3103. TCHAR _tchr = strText[i];
  3104. bool bUseSymbol = false;
  3105. if( _T('0') <= _tchr && _tchr <= _T('9') )
  3106. {
  3107. strCurrentText += _tchr;
  3108. bUseSymbol = true;
  3109. }
  3110. if( i >= nDecimalSeparatorPos && i < ( nDecimalSeparatorPos + nDecimalSeparatorLen ) && ! bCutDecimalPoint && nDecimalSeparatorPos != -1 )
  3111. {
  3112. strCurrentText += _tchr;
  3114. bUseSymbol = true;
  3115. }
  3116. if( ! bUseSymbol )
  3117. nSignCount++;
  3118. if( i == ( nStartPos - 1 ) )
  3119. nSignCountBeforeStartPos = nSignCount;
  3120. else if( i == ( nEndPos - 1 ) )
  3121. nSignCountBeforeEndPos = nSignCount;
  3122. }
  3123. nStartPos -= nSignCountBeforeStartPos;
  3124. nEndPos -= nSignCountBeforeEndPos;
  3125. if( nStartPos < 0 )
  3126. nStartPos = 0;
  3127. if( nEndPos < 0 )
  3128. nEndPos = 0;
  3129. strText = strCurrentText;
  3130. if( nStart != nEnd )
  3131. {
  3132. nStart = nStartPos;
  3133. nEnd = nEndPos;
  3134. }
  3135. else
  3136. nStart = nEnd = nStartPos;
  3137. }
  3139. void CExtEditSystemCurrency::_GetTextWithMarks( 
  3140. CExtSafeString & strText, 
  3141. INT & nStart, 
  3142. INT & nEnd, 
  3143. bool bInsertNegSign  // = false
  3144. ) const
  3145. {
  3146. ASSERT_VALID( this );
  3147. if( strText.IsEmpty() )
  3148. return;
  3149. INT nTextLen = INT( strText.GetLength() );
  3150. CExtSafeString strTextChange;
  3151. INT nGroupSeparatorLen = INT( m_strGroupSeparator.GetLength() );
  3152. INT nDecimalSeparatorLen = INT( m_strDecimalPoint.GetLength() );
  3153. INT nPositionDecimalPoint = INT( strText.Find( m_strDecimalPoint ) );
  3154. INT nMaxLen = m_nMaxWholeDigits + m_nMaxFractionDigits + ( ( nPositionDecimalPoint >= 0 ) ? nDecimalSeparatorLen : 0 );
  3155. bool bStartBehindEnd = ( nStart > INT( strText.GetLength() ) );
  3156. bool bEndBehindEnd = ( nEnd > INT( strText.GetLength() ) );
  3157. if( nTextLen > nMaxLen )
  3158. {
  3159. if( nPositionDecimalPoint >= 0 )
  3160. {
  3161. CExtSafeString _strDecimalPoint = _T("");
  3162. _strDecimalPoint = m_strDecimalPoint;
  3163. strText.Replace( _strDecimalPoint, _T("") );
  3165. if( nPositionDecimalPoint > m_nMaxWholeDigits )
  3166. {
  3167. strText.Insert( m_nMaxWholeDigits, m_strDecimalPoint );
  3168. }
  3169. else
  3170. strText.Insert( nPositionDecimalPoint, m_strDecimalPoint );
  3171. }
  3172. nTextLen = INT( strText.GetLength() );
  3173. }
  3174. INT nWholeNumber = ( ( nPositionDecimalPoint >= 0 ) ? ( ( nPositionDecimalPoint < m_nMaxWholeDigits ) ? nPositionDecimalPoint : m_nMaxWholeDigits ) : ( ( m_nMaxWholeDigits >= nTextLen ) ?  nTextLen : m_nMaxWholeDigits ) );
  3175. INT nDecimalPointLen = nDecimalSeparatorLen; // 1
  3176. INT nCorectTextLen = nWholeNumber + nDecimalPointLen + m_nMaxFractionDigits;
  3177. nCorectTextLen = ( nCorectTextLen > nTextLen ) ? nTextLen : nCorectTextLen;
  3178. INT nCountDigitGroups = INT( m_listDigitGrouping.GetCount() );
  3179. CList < INT, INT > _listPos;
  3180. bool bLastZiro = ( m_listDigitGrouping.GetAt( m_listDigitGrouping.FindIndex( nCountDigitGroups - 1 ) ) == 0 ) ? true : false;
  3181. ASSERT( nWholeNumber <= m_nMaxWholeDigits );
  3182. INT nPos = nWholeNumber;
  3183. INT i = 0;
  3184. INT nPreviousCount = -1;
  3185. for( ; true; )
  3186. {
  3187. INT nCount = m_listDigitGrouping.GetAt(m_listDigitGrouping.FindIndex(i));
  3188. if( nCount == 0 && i < ( nCountDigitGroups - 1 ) )
  3189. break;
  3190. if( nCount == 0 && i == ( nCountDigitGroups - 1 ) )
  3191. {
  3192. ASSERT( nPreviousCount != -1 );
  3193. nCount = nPreviousCount;
  3194. }
  3195. nPos -= nCount;
  3196. if( nPos > 0 )
  3197. _listPos.AddHead( nPos - 1 );
  3198. else
  3199. break;
  3200. if( i == ( nCountDigitGroups - 1 ) && ! bLastZiro )
  3201. break;
  3202. if( i < ( nCountDigitGroups - 1 ) )
  3203. i ++;
  3204. nPreviousCount = nCount;
  3205. }
  3206. INT nSignCountBeforeStart = 0;
  3207. INT nSignCountBeforeEnd = 0;
  3208. bool bInsertedDecimalSignBeforeStart = false;
  3209. bool bInsertedDecimalSignBeforeEnd = false;
  3210. INT nCurDigitPos = 0;
  3211. INT nPosCount = INT( _listPos.GetCount() );
  3212. bool bCanPastGroupSep = ( nPosCount > 0 );
  3213. for( i = 0; i < nCorectTextLen; i++ )
  3214. {
  3215. TCHAR _tchr = strText[i];
  3216. strTextChange += _tchr;
  3217. bool bInsertSign = false;
  3218. INT nPosCur = 0;
  3219. if( bCanPastGroupSep )
  3220. nPosCur = _listPos.GetAt( _listPos.FindIndex( nCurDigitPos ) );
  3221. if( ( i <= nWholeNumber )
  3222. && ( i != ( nCorectTextLen - 1 ) )
  3223. && ( i == nPosCur )
  3224. && bCanPastGroupSep
  3225. )
  3226. {
  3227. strTextChange += m_strGroupSeparator;
  3228. bInsertSign = true;
  3229. if( nCurDigitPos < ( nPosCount - 1 ) )
  3230. nCurDigitPos ++;
  3231. else
  3232. bCanPastGroupSep = false;
  3233. }
  3234. if( i == ( nWholeNumber - 1 ) && ( nPositionDecimalPoint == -1 ) && ( i != nCorectTextLen - 1 ) )
  3235. {
  3236. strTextChange += m_strDecimalPoint;
  3237. if( i < ( nStart - 1 ) )
  3238. bInsertedDecimalSignBeforeStart  = true;
  3239. if( i < ( nEnd - 1 ) )
  3240. bInsertedDecimalSignBeforeEnd = true;
  3241. }
  3242. if( bInsertSign )
  3243. {
  3244. if( i < nStart )
  3245. nSignCountBeforeStart ++;
  3246. if( i < nEnd )
  3247. nSignCountBeforeEnd ++;
  3248. }
  3249. }
  3250. CExtSafeString _strSignBefore = _T("");
  3251. CExtSafeString _strSignAfter = _T("");
  3252. _GetSignStrings( _strSignBefore, _strSignAfter, bInsertNegSign && AllowNegativeGet() );
  3253. if( _strSignAfter.GetLength() > 0 )
  3254. {
  3255. strTextChange.Insert( strTextChange.GetLength(), _strSignAfter );
  3256. if( bStartBehindEnd )
  3257. nStart += INT( _strSignAfter.GetLength() );
  3258. if( bEndBehindEnd )
  3259. nEnd += INT( _strSignAfter.GetLength() );
  3260. }
  3261. if( _strSignBefore.GetLength() > 0 )
  3262. {
  3263. strTextChange.Insert( 0, _strSignBefore );
  3264. nStart += INT( _strSignBefore.GetLength() );
  3265. nEnd += INT( _strSignBefore.GetLength() );
  3266. }
  3267. strText = strTextChange;
  3268. nStart += nGroupSeparatorLen * nSignCountBeforeStart + ( bInsertedDecimalSignBeforeStart ? nDecimalSeparatorLen : 0 );
  3269. nEnd += nGroupSeparatorLen * nSignCountBeforeEnd + ( bInsertedDecimalSignBeforeEnd ? nDecimalSeparatorLen : 0 );
  3270. }
  3272. bool CExtEditSystemCurrency::_IsNegative( __EXT_MFC_SAFE_LPCTSTR strText ) const
  3273. {
  3274. ASSERT_VALID( this );
  3275. CExtSafeString _strText = strText;
  3276. bool bRetVal = ( ( _strText.Find( m_strNegativeSign ) >= 0 ) ? true: false );
  3277. if( m_nNegativeFormatIndex == 0 
  3278. || m_nNegativeFormatIndex == 4
  3279. || m_nNegativeFormatIndex == 14
  3280. || m_nNegativeFormatIndex == 15
  3281. )
  3282. bRetVal = ( ( _strText.Find( _T('(') ) >= 0 ) ? true: false );
  3283. return bRetVal;
  3284. }
  3286. void CExtEditSystemCurrency::_AdjustWithinRange()
  3287. {
  3288. ASSERT_VALID( this );
  3289. if( _IsValid() )
  3290. return;
  3291. if( m_pEditWithBehaviorWnd->TextGet().IsEmpty() )
  3292. m_pEditWithBehaviorWnd->SetWindowText( _T(" ") );
  3293. else
  3294. _Redraw();
  3295. long double dValue = LongDoubleGet();
  3296.     if( dValue < m_lfMin )
  3297. LongDoubleSet( m_lfMin );
  3298.     else if( dValue > m_lfMax )
  3299. LongDoubleSet( m_lfMax );
  3300. CExtSafeString _strText = m_pEditWithBehaviorWnd->TextGet();
  3301. bool bNegative = _IsNegative( _strText );
  3302. CExtSafeString _strBefore = _T("");
  3303. CExtSafeString _strAfter = _T("");
  3304. _GetSignStrings( _strBefore, _strAfter, bNegative );
  3305. INT nNegSignPos = -1;
  3306. INT nLen = INT( _strText.GetLength() );
  3307. if( ! _strAfter.IsEmpty() )
  3308. nNegSignPos = INT( _strText.Find( _strAfter ) );
  3309. if( ! m_bRichPainting )
  3310. {
  3311. if( nNegSignPos >= 0 )
  3312. m_pEditWithBehaviorWnd->SetSel( nNegSignPos, nNegSignPos );
  3313. else
  3314. m_pEditWithBehaviorWnd->SetSel( nLen, nLen );
  3315. }
  3316. }
  3318. void CExtEditSystemCurrency::_Rich_OnDraw()
  3319. {
  3320. if( ! m_bRichMode )
  3321. return;
  3322. if( GetSafeHwnd() == NULL )
  3323. return;
  3324. if( m_bRichPainting )
  3325. return;
  3326. m_bRichPainting = true;
  3327. CHARRANGE crRestore;
  3328. Rich_GetSel( crRestore );
  3329. CHARFORMAT cfDefault;
  3330. ::memset( &cfDefault, 0, sizeof(CHARFORMAT) );
  3331. cfDefault.dwMask = CFM_BOLD|CFM_ITALIC|CFM_UNDERLINE|CFM_STRIKEOUT|CFM_FACE|CFM_SIZE|CFM_CHARSET|CFM_PROTECTED|CFM_COLOR;
  3332. cfDefault.dwEffects = CFE_PROTECTED; 
  3333. //cfDefault.yHeight = 180;
  3334. //cfDefault.crTextColor = ::GetSysColor( COLOR_WINDOWTEXT );
  3335. CFont * pFont = GetFont();
  3336. if( pFont->GetSafeHandle() == NULL )
  3337. {
  3338. CWnd * pWndParent = GetParent();
  3339. if( pWndParent->GetSafeHwnd() != NULL )
  3340. pFont = pWndParent->GetFont();
  3341. if( pFont->GetSafeHandle() == NULL )
  3342. pFont = &(PmBridge_GetPM()->m_FontNormal);
  3343. }
  3344. LOGFONT _lf; ::memset( &_lf, 0, sizeof(LOGFONT) );
  3345. pFont->GetLogFont( &_lf );
  3346. #if (! defined _RICHEDIT_VER )
  3347. USES_CONVERSION;
  3348. strcpy( cfDefault.szFaceName, T2CA(_lf.lfFaceName) );
  3349. #else
  3350. #if ( _RICHEDIT_VER < 0x0200 )
  3351. USES_CONVERSION;
  3352. strcpy( cfDefault.szFaceName, T2CA(_lf.lfFaceName) );
  3353. #else
  3354. __EXT_MFC_STRCPY( cfDefault.szFaceName, sizeof(cfDefault.szFaceName)/sizeof(cfDefault.szFaceName[0]), _lf.lfFaceName );
  3355. #endif
  3356. #endif
  3357. CWindowDC dcDesktop( NULL );
  3358. cfDefault.yHeight = ::MulDiv( _lf.lfHeight, 72 * 20, dcDesktop.GetDeviceCaps( LOGPIXELSY ) );
  3359. cfDefault.yHeight = abs( cfDefault.yHeight );
  3360. bool bEnabled = IsWindowEnabled() ? true : false, bReadOnly = ( ( GetStyle() & ES_READONLY ) != 0 ) ? true : false;
  3361. cfDefault.crTextColor = OnQueryTextColor();
  3362. if( cfDefault.crTextColor == COLORREF(-1L) )
  3363. {
  3364. cfDefault.crTextColor = bEnabled ? ( bReadOnly ? m_clrRichTextReadOnly : m_clrRichTextNormal ) : m_clrRichTextDisabled;
  3365. if( cfDefault.crTextColor == COLORREF(-1L) )
  3366. {
  3367. if( bEnabled )
  3368. {
  3369. if( bReadOnly )
  3370. cfDefault.crTextColor = ::GetSysColor( COLOR_3DSHADOW );
  3371. else
  3372. cfDefault.crTextColor = ::GetSysColor( COLOR_WINDOWTEXT );
  3373. }
  3374. else
  3375. cfDefault.crTextColor = ::GetSysColor( COLOR_GRAYTEXT );
  3376. }
  3377. }
  3378. COLORREF clrBack = OnQueryBackColor();
  3379. if( clrBack == COLORREF(-1L) )
  3380. {
  3381. clrBack = bEnabled ? ( bReadOnly ? m_clrRichBackReadOnly : m_clrRichBackNormal ) : m_clrRichBackDisabled;
  3382. if( clrBack == COLORREF(-1L) )
  3383. {
  3384. if( bEnabled )
  3385. {
  3386. if( bReadOnly )
  3387. clrBack = ::GetSysColor( COLOR_3DFACE );
  3388. else
  3389. clrBack = ::GetSysColor( COLOR_WINDOW );
  3390. }
  3391. else
  3392. clrBack = ::GetSysColor( COLOR_3DFACE );
  3393. }
  3394. }
  3395. Rich_SetBackgroundColor( FALSE, clrBack );
  3396. Rich_HideSelection( true, false );
  3397. Rich_SetSel( 0, -1 ); 
  3398. SendMessage( EM_SETCHARFORMAT, SCF_DEFAULT, LPARAM(&cfDefault) );
  3399. SendMessage( EM_SETCHARFORMAT, SCF_SELECTION, LPARAM(&cfDefault) );
  3400. Rich_SetSelectionColor( cfDefault.crTextColor );
  3401. COLORREF clrSign = m_clrSign;
  3402. if( clrSign == COLORREF(-1L) )
  3403. clrSign = cfDefault.crTextColor;
  3404. COLORREF clrBrackets = m_clrBrackets;
  3405. if( clrSign == COLORREF(-1L) )
  3406. clrBrackets = cfDefault.crTextColor;
  3407. INT nGroupSeparatorLen = INT( m_strGroupSeparator.GetLength() );
  3408. INT nDecimalSignLen = INT( m_strDecimalPoint.GetLength() );
  3409. if( m_clrNumber != COLORREF(-1L)
  3410. || m_clrFraction != COLORREF(-1L)
  3411. || m_clrGroupSeparator != COLORREF(-1L)
  3412. || m_clrDecimalSeparator != COLORREF(-1L)
  3413. || m_clrSign != COLORREF(-1L)
  3414. || m_clrBrackets != COLORREF(-1L)
  3415. )
  3416. {
  3417. CExtSafeString strText = TextGet();
  3418. INT nTextLen = INT( strText.GetLength() );
  3419. if( nTextLen > 0 )
  3420. {
  3421. bool bNegative = _IsNegative( strText );
  3422. INT nPositionDecimalPoint = INT( strText.Find( m_strDecimalPoint ) );
  3423. CExtSafeString _strBefore = _T(""), _strAfter = _T("");
  3424. _GetSignStrings( _strBefore, _strAfter, bNegative );
  3425. INT nBeforLen = _strBefore.GetLength();
  3426. INT nAfterLen = _strAfter.GetLength();
  3427. // whole number
  3428. if( m_clrNumber != COLORREF(-1L) )
  3429. {
  3430. Rich_SetSel( nBeforLen, ( nPositionDecimalPoint != -1 ) ? nPositionDecimalPoint : ( nTextLen - nAfterLen ) );
  3431. Rich_SetSelectionColor( m_clrNumber );
  3432. }
  3433. if( nPositionDecimalPoint != -1 )
  3434. {
  3435. if( m_clrDecimalSeparator != COLORREF(-1L) )
  3436. {
  3437. Rich_SetSel( nPositionDecimalPoint, ( nPositionDecimalPoint + nDecimalSignLen ) );
  3438. Rich_SetSelectionColor( m_clrDecimalSeparator );
  3439. }
  3440. if( m_clrFraction != COLORREF(-1L) )
  3441. {
  3442. Rich_SetSel( nPositionDecimalPoint + nDecimalSignLen, nTextLen - nAfterLen );
  3443. Rich_SetSelectionColor( m_clrFraction );
  3444. }
  3445. }
  3446. if( m_clrGroupSeparator != COLORREF(-1L) )
  3447. {
  3448. INT nPos = 0;
  3449. for( ; true; )
  3450. {
  3451. nPos = INT( strText.Find( m_strGroupSeparator, nPos ) );
  3452. if( nPos == -1 )
  3453. break;
  3454. Rich_SetSel( nPos, ( nPos + nGroupSeparatorLen ) );
  3455. Rich_SetSelectionColor( m_clrGroupSeparator ); 
  3456. nPos ++;
  3457. }
  3458. }
  3459. INT nNegSignPos = INT( strText.Find( m_strNegativeSign ) );
  3460. INT nNegSignLen = INT( m_strNegativeSign.GetLength() );
  3461. if( nNegSignPos >= 0 )
  3462. {
  3463. if( m_clrSign != COLORREF(-1L) )
  3464. {
  3465. Rich_SetSel( nNegSignPos, nNegSignPos + nNegSignLen );
  3466. Rich_SetSelectionColor( m_clrSign );
  3467. }
  3468. }
  3469. if( m_clrBrackets != COLORREF(-1L) )
  3470. {
  3471. INT nPos = 0;
  3472. CExtSafeString _strBrackets = _T("()[]{}");
  3473. INT nBrackLen = INT( _strBrackets.GetLength() );
  3474. for( INT i = 0; i < nBrackLen; i++ )
  3475. {
  3476. nPos = 0;
  3477. for( ; true; )
  3478. {
  3479. nPos = INT( strText.Find( _strBrackets[i], nPos ) );
  3480. if( nPos == -1 )
  3481. break;
  3482. Rich_SetSel( nPos, ( nPos + 1 ) );
  3483. Rich_SetSelectionColor( m_clrBrackets ); 
  3484. nPos ++;
  3485. }
  3486. }
  3487. }
  3488. } // if( nTextLen > 0 )
  3489. }
  3490. Rich_SetSel( crRestore );
  3491. Rich_HideSelection( false, false );
  3492. m_bRichPainting = false;
  3493. }