text: ﻿#include "StdAfx.h"
  #include "UIRichEdit.h"
  
  #ifdef _USEIMM
      #include <imm.h>
      #pragma comment(lib, "imm32.lib")
  #endif
  // These constants are for backward compatibility. They are the
  // sizes used for initialization and reset in RichEdit 1.0
  
  namespace DuiLib {
  
  #define ID_RICH_UNDO            101
  #define ID_RICH_CUT             102
  #define ID_RICH_COPY            103
  #define ID_RICH_PASTE           104
  #define ID_RICH_CLEAR           105
  #define ID_RICH_SELECTALL       106
  #define ID_RICH_REDO            107
  
      const LONG cInitTextMax = (32 * 1024) - 1;
  
      EXTERN_C const IID IID_ITextServices = { // 8d33f740-cf58-11ce-a89d-00aa006cadc5
          0x8d33f740,
          0xcf58,
          0x11ce,
          {0xa8, 0x9d, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5}
      };
  
      EXTERN_C const IID IID_ITextHost = { /* c5bdd8d0-d26e-11ce-a89e-00aa006cadc5 */
          0xc5bdd8d0,
          0xd26e,
          0x11ce,
          {0xa8, 0x9e, 0x00, 0xaa, 0x00, 0x6c, 0xad, 0xc5}
      };
  
  #ifndef LY_PER_INCH
      #define LY_PER_INCH 1440
  #endif
  
  #ifndef HIMETRIC_PER_INCH
      #define HIMETRIC_PER_INCH 2540
  #endif
  
  #include <textserv.h>
  
      class CTxtWinHost : public ITextHost {
        public:
          CTxtWinHost();
          BOOL Init(CRichEditUI *re, const CREATESTRUCT *pcs);
          virtual ~CTxtWinHost();
  
          ITextServices *GetTextServices(void) {
              return pserv;
          }
          void SetClientRect(RECT *prc);
          RECT *GetClientRect() {
              return &rcClient;
          }
          BOOL IsWordWrap(void) {
              return fWordWrap;
          }
          void SetWordWrap(BOOL fIsWordWrap);
          BOOL IsReadOnly();
          void SetReadOnly(BOOL fReadOnly);
  
          void SetFont(HFONT hFont);
          void SetColor(DWORD dwColor);
          SIZEL *GetExtent();
          void SetExtent(SIZEL *psizelExtent);
          void LimitText(LONG nChars);
          BOOL IsCaptured();
          BOOL IsShowCaret();
          void NeedFreshCaret();
          INT GetCaretWidth();
          INT GetCaretHeight();
  
          BOOL GetAllowBeep();
          void SetAllowBeep(BOOL fIsAllowBeep);
          WORD GetDefaultAlign();
          void SetDefaultAlign(WORD wNewAlign);
          BOOL GetRichTextFlag();
          void SetRichTextFlag(BOOL fNew);
          LONG GetDefaultLeftIndent();
          void SetDefaultLeftIndent(LONG lNewIndent);
          BOOL SetSaveSelection(BOOL fSaveSelection);
          HRESULT OnTxInPlaceDeactivate();
          HRESULT OnTxInPlaceActivate(LPCRECT prcClient);
          BOOL GetActiveState(void) {
              return fInplaceActive;
          }
          BOOL DoSetCursor(RECT *prc, POINT *pt);
          void SetTransparent(BOOL fTransparent);
          void GetControlRect(LPRECT prc);
          LONG SetAccelPos(LONG laccelpos);
          WCHAR SetPasswordChar(WCHAR chPasswordChar);
          void SetDisabled(BOOL fOn);
          LONG SetSelBarWidth(LONG lSelBarWidth);
          BOOL GetTimerState();
  
          void SetCharFormat(CHARFORMAT2W &c);
          void SetParaFormat(PARAFORMAT2 &p);
  
          // -----------------------------
          //  IUnknown interface
          // -----------------------------
          virtual HRESULT _stdcall QueryInterface(REFIID riid, void **ppvObject);
          virtual ULONG _stdcall AddRef(void);
          virtual ULONG _stdcall Release(void);
  
          // -----------------------------
          //  ITextHost interface
          // -----------------------------
          virtual HDC TxGetDC();
          virtual INT TxReleaseDC(HDC hdc);
          virtual BOOL TxShowScrollBar(INT fnBar, BOOL fShow);
          virtual BOOL TxEnableScrollBar (INT fuSBFlags, INT fuArrowflags);
          virtual BOOL TxSetScrollRange(INT fnBar, LONG nMinPos, INT nMaxPos, BOOL fRedraw);
          virtual BOOL TxSetScrollPos (INT fnBar, INT nPos, BOOL fRedraw);
          virtual void TxInvalidateRect(LPCRECT prc, BOOL fMode);
          virtual void TxViewChange(BOOL fUpdate);
          virtual BOOL TxCreateCaret(HBITMAP hbmp, INT xWidth, INT yHeight);
          virtual BOOL TxShowCaret(BOOL fShow);
          virtual BOOL TxSetCaretPos(INT x, INT y);
          virtual BOOL TxSetTimer(UINT idTimer, UINT uTimeout);
          virtual void TxKillTimer(UINT idTimer);
          virtual void TxScrollWindowEx (INT dx, INT dy, LPCRECT lprcScroll, LPCRECT lprcClip, HRGN hrgnUpdate, LPRECT lprcUpdate, UINT fuScroll);
          virtual void TxSetCapture(BOOL fCapture);
          virtual void TxSetFocus();
          virtual void TxSetCursor(HCURSOR hcur, BOOL fText);
          virtual BOOL TxScreenToClient (LPPOINT lppt);
          virtual BOOL TxClientToScreen (LPPOINT lppt);
          virtual HRESULT TxActivate( LONG *plOldState );
          virtual HRESULT TxDeactivate( LONG lNewState );
          virtual HRESULT TxGetClientRect(LPRECT prc);
          virtual HRESULT TxGetViewInset(LPRECT prc);
          virtual HRESULT TxGetCharFormat(const CHARFORMATW **ppCF );
          virtual HRESULT TxGetParaFormat(const PARAFORMAT **ppPF);
          virtual COLORREF TxGetSysColor(int nIndex);
          virtual HRESULT TxGetBackStyle(TXTBACKSTYLE *pstyle);
          virtual HRESULT TxGetMaxLength(DWORD *plength);
          virtual HRESULT TxGetScrollBars(DWORD *pdwScrollBar);
          virtual HRESULT TxGetPasswordChar(TCHAR *pch);
          virtual HRESULT TxGetAcceleratorPos(LONG *pcp);
          virtual HRESULT TxGetExtent(LPSIZEL lpExtent);
          virtual HRESULT OnTxCharFormatChange (const CHARFORMATW *pcf);
          virtual HRESULT OnTxParaFormatChange (const PARAFORMAT *ppf);
          virtual HRESULT TxGetPropertyBits(DWORD dwMask, DWORD *pdwBits);
          virtual HRESULT TxNotify(DWORD iNotify, void *pv);
          virtual HIMC TxImmGetContext(void);
          virtual void TxImmReleaseContext(HIMC himc);
          virtual HRESULT TxGetSelectionBarWidth (LONG *lSelBarWidth);
  
        private:
          CRichEditUI *m_re;
          ULONG   cRefs;                  // Reference Count
          ITextServices   *pserv;         // pointer to Text Services object
          // Properties
  
          DWORD       dwStyle;                // style bits
  
          unsigned    fEnableAutoWordSel  : 1; // enable Word style auto word selection?
          unsigned    fWordWrap           : 1; // Whether control should word wrap
          unsigned    fAllowBeep          : 1; // Whether beep is allowed
          unsigned    fRich               : 1; // Whether control is rich text
          unsigned    fSaveSelection      : 1; // Whether to save the selection when inactive
          unsigned    fInplaceActive      : 1; // Whether control is inplace active
          unsigned    fTransparent        : 1; // Whether control is transparent
          unsigned    fTimer              : 1; // A timer is set
          unsigned    fCaptured           : 1;
          unsigned    fShowCaret          : 1;
          unsigned    fNeedFreshCaret     : 1; // 修正改变大小后点击其他位置原来光标不能消除的问题
  
          INT         iCaretWidth;
          INT         iCaretHeight;
          INT         iCaretLastWidth;
          INT         iCaretLastHeight;
          LONG        lSelBarWidth;           // Width of the selection bar
          LONG        cchTextMost;            // maximum text size
          DWORD       dwEventMask;            // DoEvent mask to pass on to parent window
          LONG        icf;
          LONG        ipf;
          RECT        rcClient;               // Client Rect for this control
          SIZEL       sizelExtent;            // Extent array
          CHARFORMAT2W cf;                    // Default character format
          PARAFORMAT2 pf;                     // Default paragraph format
          LONG        laccelpos;              // Accelerator position
          WCHAR       chPasswordChar;         // Password character
      };
  
      // Convert Pixels on the X axis to Himetric
      LONG DXtoHimetricX(LONG dx, LONG xPerInch) {
          return (LONG) MulDiv(dx, HIMETRIC_PER_INCH, xPerInch);
      }
  
      // Convert Pixels on the Y axis to Himetric
      LONG DYtoHimetricY(LONG dy, LONG yPerInch) {
          return (LONG) MulDiv(dy, HIMETRIC_PER_INCH, yPerInch);
      }
  
      HRESULT InitDefaultCharFormat(CRichEditUI *re, CHARFORMAT2W *pcf, HFONT hfont) {
          memset(pcf, 0, sizeof(CHARFORMAT2W));
  
          if(hfont == NULL) {
              hfont = re->GetManager()->GetFont(re->GetFont());
          }
  
          LOGFONT lf;
          ::GetObject(hfont, sizeof(LOGFONT), &lf);
  
          DWORD dwColor = re->GetTextColor();
  
          if(re->GetManager()->IsLayered()) {
              CRenderEngine::CheckAlphaColor(dwColor);
          }
  
          pcf->cbSize = sizeof(CHARFORMAT2W);
          pcf->crTextColor = RGB(GetBValue(dwColor), GetGValue(dwColor), GetRValue(dwColor));
          LONG yPixPerInch = GetDeviceCaps(re->GetManager()->GetPaintDC(), LOGPIXELSY);
          pcf->yHeight = -lf.lfHeight * LY_PER_INCH / yPixPerInch;
          pcf->yOffset = 0;
          pcf->dwEffects = 0;
          pcf->dwMask = CFM_SIZE | CFM_OFFSET | CFM_FACE | CFM_CHARSET | CFM_COLOR | CFM_BOLD | CFM_ITALIC | CFM_UNDERLINE;
  
          if(lf.lfWeight >= FW_BOLD)
              pcf->dwEffects |= CFE_BOLD;
  
          if(lf.lfItalic)
              pcf->dwEffects |= CFE_ITALIC;
  
          if(lf.lfUnderline)
              pcf->dwEffects |= CFE_UNDERLINE;
  
          pcf->bCharSet = lf.lfCharSet;
          pcf->bPitchAndFamily = lf.lfPitchAndFamily;
  #ifdef _UNICODE
          _tcscpy(pcf->szFaceName, lf.lfFaceName);
  #else
          //need to thunk pcf->szFaceName to a standard char string.in this case it's easy because our thunk is also our copy
          MultiByteToWideChar(CP_ACP, 0, lf.lfFaceName, LF_FACESIZE, pcf->szFaceName, LF_FACESIZE) ;
  #endif
  
          return S_OK;
      }
  
      HRESULT InitDefaultParaFormat(CRichEditUI *re, PARAFORMAT2 *ppf) {
          memset(ppf, 0, sizeof(PARAFORMAT2));
          ppf->cbSize = sizeof(PARAFORMAT2);
          ppf->dwMask = PFM_ALL;
          ppf->wAlignment = PFA_LEFT;
          ppf->cTabCount = 1;
          ppf->rgxTabs[0] = lDefaultTab;
  
          return S_OK;
      }
  
      HRESULT CreateHost(CRichEditUI *re, const CREATESTRUCT *pcs, CTxtWinHost **pptec) {
          HRESULT hr = E_FAIL;
          CTxtWinHost *phost = new CTxtWinHost();
  
          if(phost) {
              if (phost->Init(re, pcs)) {
                  *pptec = phost;
                  hr = S_OK;
              }
          }
  
          if (FAILED(hr)) {
              delete phost;
          }
  
          return TRUE;
      }
  
      CTxtWinHost::CTxtWinHost() : m_re(NULL) {
          ::ZeroMemory(&cRefs, sizeof(CTxtWinHost) - offsetof(CTxtWinHost, cRefs));
          cchTextMost = cInitTextMax;
          laccelpos = -1;
      }
  
      CTxtWinHost::~CTxtWinHost() {
          pserv->OnTxInPlaceDeactivate();
          pserv->Release();
      }
  
      ////////////////////// Create/Init/Destruct Commands ///////////////////////
  
      BOOL CTxtWinHost::Init(CRichEditUI *re, const CREATESTRUCT *pcs) {
          IUnknown *pUnk = NULL;
          HRESULT hr;
  
          m_re = re;
          // Initialize Reference count
          cRefs = 1;
  
          // Create and cache CHARFORMAT for this control
          if(FAILED(InitDefaultCharFormat(re, &cf, NULL)))
              goto err;
  
          // Create and cache PARAFORMAT for this control
          if(FAILED(InitDefaultParaFormat(re, &pf)))
              goto err;
  
          // edit controls created without a window are multiline by default
          // so that paragraph formats can be
          dwStyle = ES_MULTILINE;
  
          // edit controls are rich by default
          fRich = re->IsRich();
  
          cchTextMost = re->GetLimitText();
  
          if (pcs ) {
              dwStyle = pcs->style;
  
              if ( !(dwStyle & (ES_AUTOHSCROLL | WS_HSCROLL)) ) {
                  fWordWrap = TRUE;
              }
          }
  
          if( !(dwStyle & ES_LEFT) ) {
              if(dwStyle & ES_CENTER)
                  pf.wAlignment = PFA_CENTER;
              else if(dwStyle & ES_RIGHT)
                  pf.wAlignment = PFA_RIGHT;
          }
  
          fInplaceActive = TRUE;
  
          PCreateTextServices TextServicesProc = NULL;
  #ifdef _UNICODE
          HMODULE hmod = LoadLibrary(_T("Msftedit.dll"));
  #else
          HMODULE hmod = LoadLibrary(_T("Riched20.dll"));
  #endif
  
          if (hmod) {
              TextServicesProc = (PCreateTextServices)GetProcAddress(hmod, "CreateTextServices");
          }
  
          if (TextServicesProc != NULL) {
              TextServicesProc(NULL, this, &pUnk);
          }
  
          hr = pUnk->QueryInterface(IID_ITextServices, (void **)&pserv);
  
          // Whether the previous call succeeded or failed we are done
          // with the private interface.
          pUnk->Release();
  
          if(FAILED(hr)) {
              goto err;
          }
  
          // Set window text
          if(pcs && pcs->lpszName) {
  #ifdef _UNICODE
  
              if(FAILED(pserv->TxSetText((TCHAR *)pcs->lpszName)))
                  goto err;
  
  #else
              size_t iLen = _tcslen(pcs->lpszName);
              LPWSTR lpText = new WCHAR[iLen + 1];
              ::ZeroMemory(lpText, (iLen + 1) * sizeof(WCHAR));
              ::MultiByteToWideChar(CP_ACP, 0, pcs->lpszName, -1, (LPWSTR)lpText, iLen) ;
  
              if(FAILED(pserv->TxSetText((LPWSTR)lpText))) {
                  delete[] lpText;
                  goto err;
              }
  
              delete[] lpText;
  #endif
          }
  
          return TRUE;
  
      err:
          return FALSE;
      }
  
      /////////////////////////////////  IUnknown ////////////////////////////////
  
  
      HRESULT CTxtWinHost::QueryInterface(REFIID riid, void **ppvObject) {
          HRESULT hr = E_NOINTERFACE;
          *ppvObject = NULL;
  
          if (IsEqualIID(riid, IID_IUnknown)
                  || IsEqualIID(riid, IID_ITextHost)) {
              AddRef();
              *ppvObject = (ITextHost *) this;
              hr = S_OK;
          }
  
          return hr;
      }
  
      ULONG CTxtWinHost::AddRef(void) {
          return ++cRefs;
      }
  
      ULONG CTxtWinHost::Release(void) {
          ULONG c_Refs = --cRefs;
  
          if (c_Refs == 0) {
              delete this;
          }
  
          return c_Refs;
      }
  
      /////////////////////////////////  Far East Support  //////////////////////////////////////
  
      HIMC CTxtWinHost::TxImmGetContext(void) {
          return NULL;
      }
  
      void CTxtWinHost::TxImmReleaseContext(HIMC himc) {
          //::ImmReleaseContext( hwnd, himc );
      }
  
      //////////////////////////// ITextHost Interface  ////////////////////////////
  
      HDC CTxtWinHost::TxGetDC() {
          return m_re->GetManager()->GetPaintDC();
      }
  
      int CTxtWinHost::TxReleaseDC(HDC hdc) {
          return 1;
      }
  
      BOOL CTxtWinHost::TxShowScrollBar(INT fnBar, BOOL fShow) {
          CScrollBarUI *pVerticalScrollBar = m_re->GetVerticalScrollBar();
          CScrollBarUI *pHorizontalScrollBar = m_re->GetHorizontalScrollBar();
  
          if( fnBar == SB_VERT && pVerticalScrollBar ) {
              pVerticalScrollBar->SetVisible(fShow == TRUE);
          } else if( fnBar == SB_HORZ && pHorizontalScrollBar ) {
              pHorizontalScrollBar->SetVisible(fShow == TRUE);
          } else if( fnBar == SB_BOTH ) {
              if( pVerticalScrollBar ) pVerticalScrollBar->SetVisible(fShow == TRUE);
  
              if( pHorizontalScrollBar ) pHorizontalScrollBar->SetVisible(fShow == TRUE);
          }
  
          return TRUE;
      }
  
      BOOL CTxtWinHost::TxEnableScrollBar (INT fuSBFlags, INT fuArrowflags) {
          if( fuSBFlags == SB_VERT ) {
              m_re->EnableScrollBar(true, m_re->GetHorizontalScrollBar() != NULL);
              m_re->GetVerticalScrollBar()->SetVisible(fuArrowflags != ESB_DISABLE_BOTH);
          } else if( fuSBFlags == SB_HORZ ) {
              m_re->EnableScrollBar(m_re->GetVerticalScrollBar() != NULL, true);
              m_re->GetHorizontalScrollBar()->SetVisible(fuArrowflags != ESB_DISABLE_BOTH);
          } else if( fuSBFlags == SB_BOTH ) {
              m_re->EnableScrollBar(true, true);
              m_re->GetVerticalScrollBar()->SetVisible(fuArrowflags != ESB_DISABLE_BOTH);
              m_re->GetHorizontalScrollBar()->SetVisible(fuArrowflags != ESB_DISABLE_BOTH);
          }
  
          return TRUE;
      }
  
      BOOL CTxtWinHost::TxSetScrollRange(INT fnBar, LONG nMinPos, INT nMaxPos, BOOL fRedraw) {
          CScrollBarUI *pVerticalScrollBar = m_re->GetVerticalScrollBar();
          CScrollBarUI *pHorizontalScrollBar = m_re->GetHorizontalScrollBar();
  
          if( fnBar == SB_VERT && pVerticalScrollBar ) {
              if( nMaxPos - nMinPos - rcClient.bottom + rcClient.top <= 0 ) {
                  pVerticalScrollBar->SetVisible(false);
              } else {
                  pVerticalScrollBar->SetVisible(true);
                  pVerticalScrollBar->SetScrollRange(nMaxPos - nMinPos - rcClient.bottom + rcClient.top);
              }
          } else if( fnBar == SB_HORZ && pHorizontalScrollBar ) {
              if( nMaxPos - nMinPos - rcClient.right + rcClient.left <= 0 ) {
                  pHorizontalScrollBar->SetVisible(false);
              } else {
                  pHorizontalScrollBar->SetVisible(true);
                  pHorizontalScrollBar->SetScrollRange(nMaxPos - nMinPos - rcClient.right + rcClient.left);
              }
          }
  
          return TRUE;
      }
  
      BOOL CTxtWinHost::TxSetScrollPos (INT fnBar, INT nPos, BOOL fRedraw) {
          CScrollBarUI *pVerticalScrollBar = m_re->GetVerticalScrollBar();
          CScrollBarUI *pHorizontalScrollBar = m_re->GetHorizontalScrollBar();
  
          if( fnBar == SB_VERT && pVerticalScrollBar ) {
              pVerticalScrollBar->SetScrollPos(nPos);
          } else if( fnBar == SB_HORZ && pHorizontalScrollBar ) {
              pHorizontalScrollBar->SetScrollPos(nPos);
          }
  
          return TRUE;
      }
  
      void CTxtWinHost::TxInvalidateRect(LPCRECT prc, BOOL fMode) {
          if( prc == NULL ) {
              m_re->GetManager()->Invalidate(rcClient);
              return;
          }
  
          RECT rc = *prc;
          m_re->GetManager()->Invalidate(rc);
      }
  
      void CTxtWinHost::TxViewChange(BOOL fUpdate) {
          if( m_re->OnTxViewChanged() ) m_re->Invalidate();
      }
  
      BOOL CTxtWinHost::TxCreateCaret(HBITMAP hbmp, INT xWidth, INT yHeight) {
          iCaretWidth = xWidth;
          iCaretHeight = yHeight;
          return ::CreateCaret(m_re->GetManager()->GetPaintWindow(), hbmp, xWidth, yHeight);
      }
  
      BOOL CTxtWinHost::TxShowCaret(BOOL fShow) {
          fShowCaret = fShow;
  
          if(fShow)
              return ::ShowCaret(m_re->GetManager()->GetPaintWindow());
          else
              return ::HideCaret(m_re->GetManager()->GetPaintWindow());
      }
  
      BOOL CTxtWinHost::TxSetCaretPos(INT x, INT y) {
          POINT ptCaret = { 0 };
          ::GetCaretPos(&ptCaret);
          RECT rcCaret = { ptCaret.x, ptCaret.y, ptCaret.x + iCaretLastWidth, ptCaret.y + iCaretLastHeight };
  
          if( m_re->GetManager()->IsLayered() ) m_re->GetManager()->Invalidate(rcCaret);
          else if( fNeedFreshCaret == TRUE ) {
              m_re->GetManager()->Invalidate(rcCaret);
              fNeedFreshCaret = FALSE;
          }
  
          rcCaret.left = x;
          rcCaret.top = y;
          rcCaret.right = x + iCaretWidth;
          rcCaret.bottom = y + iCaretHeight;
  
          if( m_re->GetManager()->IsLayered() ) m_re->GetManager()->Invalidate(rcCaret);
  
          iCaretLastWidth = iCaretWidth;
          iCaretLastHeight = iCaretHeight;
          return ::SetCaretPos(x, y);
      }
  
      BOOL CTxtWinHost::TxSetTimer(UINT idTimer, UINT uTimeout) {
          fTimer = TRUE;
          return m_re->GetManager()->SetTimer(m_re, idTimer, uTimeout) == TRUE;
      }
  
      void CTxtWinHost::TxKillTimer(UINT idTimer) {
          m_re->GetManager()->KillTimer(m_re, idTimer);
          fTimer = FALSE;
      }
  
      void CTxtWinHost::TxScrollWindowEx (INT dx, INT dy, LPCRECT lprcScroll, LPCRECT lprcClip,   HRGN hrgnUpdate, LPRECT lprcUpdate, UINT fuScroll) {
          return;
      }
  
      void CTxtWinHost::TxSetCapture(BOOL fCapture) {
          if (fCapture) m_re->GetManager()->SetCapture();
          else m_re->GetManager()->ReleaseCapture();
  
          fCaptured = fCapture;
      }
  
      void CTxtWinHost::TxSetFocus() {
          m_re->SetFocus();
      }
  
      void CTxtWinHost::TxSetCursor(HCURSOR hcur, BOOL fText) {
          ::SetCursor(hcur);
      }
  
      BOOL CTxtWinHost::TxScreenToClient(LPPOINT lppt) {
          return ::ScreenToClient(m_re->GetManager()->GetPaintWindow(), lppt);
      }
  
      BOOL CTxtWinHost::TxClientToScreen(LPPOINT lppt) {
          return ::ClientToScreen(m_re->GetManager()->GetPaintWindow(), lppt);
      }
  
      HRESULT CTxtWinHost::TxActivate(LONG *plOldState) {
          return S_OK;
      }
  
      HRESULT CTxtWinHost::TxDeactivate(LONG lNewState) {
          return S_OK;
      }
  
      HRESULT CTxtWinHost::TxGetClientRect(LPRECT prc) {
          *prc = rcClient;
          GetControlRect(prc);
          return NOERROR;
      }
  
      HRESULT CTxtWinHost::TxGetViewInset(LPRECT prc) {
          prc->left = prc->right = prc->top = prc->bottom = 0;
          return NOERROR;
      }
  
      HRESULT CTxtWinHost::TxGetCharFormat(const CHARFORMATW **ppCF) {
          *ppCF = &cf;
          return NOERROR;
      }
  
      HRESULT CTxtWinHost::TxGetParaFormat(const PARAFORMAT **ppPF) {
          *ppPF = &pf;
          return NOERROR;
      }
  
      COLORREF CTxtWinHost::TxGetSysColor(int nIndex) {
          return ::GetSysColor(nIndex);
      }
  
      HRESULT CTxtWinHost::TxGetBackStyle(TXTBACKSTYLE *pstyle) {
          *pstyle = !fTransparent ? TXTBACK_OPAQUE : TXTBACK_TRANSPARENT;
          return NOERROR;
      }
  
      HRESULT CTxtWinHost::TxGetMaxLength(DWORD *pLength) {
          *pLength = cchTextMost;
          return NOERROR;
      }
  
      HRESULT CTxtWinHost::TxGetScrollBars(DWORD *pdwScrollBar) {
          *pdwScrollBar =  dwStyle & (WS_VSCROLL | WS_HSCROLL | ES_AUTOVSCROLL |
                                      ES_AUTOHSCROLL | ES_DISABLENOSCROLL);
  
          return NOERROR;
      }
  
      HRESULT CTxtWinHost::TxGetPasswordChar(TCHAR *pch) {
  #ifdef _UNICODE
          *pch = chPasswordChar;
  #else
          ::WideCharToMultiByte(CP_ACP, 0, &chPasswordChar, 1, pch, 1, NULL, NULL) ;
  #endif
          return NOERROR;
      }
  
      HRESULT CTxtWinHost::TxGetAcceleratorPos(LONG *pcp) {
          *pcp = laccelpos;
          return S_OK;
      }
  
      HRESULT CTxtWinHost::OnTxCharFormatChange(const CHARFORMATW *pcf) {
          return S_OK;
      }
  
      HRESULT CTxtWinHost::OnTxParaFormatChange(const PARAFORMAT *ppf) {
          return S_OK;
      }
  
      HRESULT CTxtWinHost::TxGetPropertyBits(DWORD dwMask, DWORD *pdwBits) {
          DWORD dwProperties = 0;
  
          if (fRich) {
              dwProperties = TXTBIT_RICHTEXT;
          }
  
          if (dwStyle & ES_MULTILINE) {
              dwProperties |= TXTBIT_MULTILINE;
          }
  
          if (dwStyle & ES_READONLY) {
              dwProperties |= TXTBIT_READONLY;
          }
  
          if (dwStyle & ES_PASSWORD) {
              dwProperties |= TXTBIT_USEPASSWORD;
          }
  
          if (!(dwStyle & ES_NOHIDESEL)) {
              dwProperties |= TXTBIT_HIDESELECTION;
          }
  
          if (fEnableAutoWordSel) {
              dwProperties |= TXTBIT_AUTOWORDSEL;
          }
  
          if (fWordWrap) {
              dwProperties |= TXTBIT_WORDWRAP;
          }
  
          if (fAllowBeep) {
              dwProperties |= TXTBIT_ALLOWBEEP;
          }
  
          if (fSaveSelection) {
              dwProperties |= TXTBIT_SAVESELECTION;
          }
  
          *pdwBits = dwProperties & dwMask;
          return NOERROR;
      }
  
  
      HRESULT CTxtWinHost::TxNotify(DWORD iNotify, void *pv) {
          if( iNotify == EN_REQUESTRESIZE ) {
              RECT rc;
              REQRESIZE *preqsz = (REQRESIZE *)pv;
              GetControlRect(&rc);
              rc.bottom = rc.top + preqsz->rc.bottom;
              rc.right  = rc.left + preqsz->rc.right;
              SetClientRect(&rc);
              return S_OK;
          }
  
          m_re->OnTxNotify(iNotify, pv);
          return S_OK;
      }
  
      HRESULT CTxtWinHost::TxGetExtent(LPSIZEL lpExtent) {
          *lpExtent = sizelExtent;
          return S_OK;
      }
  
      HRESULT CTxtWinHost::TxGetSelectionBarWidth (LONG *plSelBarWidth) {
          *plSelBarWidth = lSelBarWidth;
          return S_OK;
      }
  
      void CTxtWinHost::SetWordWrap(BOOL fIsWordWrap) {
          fWordWrap = fIsWordWrap;
          pserv->OnTxPropertyBitsChange(TXTBIT_WORDWRAP, fWordWrap ? TXTBIT_WORDWRAP : 0);
      }
  
      BOOL CTxtWinHost::IsReadOnly() {
          return (dwStyle & ES_READONLY) != 0;
      }
  
      void CTxtWinHost::SetReadOnly(BOOL fReadOnly) {
          if (fReadOnly) {
              dwStyle |= ES_READONLY;
          } else {
              dwStyle &= ~ES_READONLY;
          }
  
          pserv->OnTxPropertyBitsChange(TXTBIT_READONLY,
                                        fReadOnly ? TXTBIT_READONLY : 0);
      }
  
      void CTxtWinHost::SetFont(HFONT hFont) {
          if( hFont == NULL ) return;
  
          LOGFONT lf;
          ::GetObject(hFont, sizeof(LOGFONT), &lf);
          LONG yPixPerInch = ::GetDeviceCaps(m_re->GetManager()->GetPaintDC(), LOGPIXELSY);
          cf.yHeight = -lf.lfHeight * LY_PER_INCH / yPixPerInch;
  
          if(lf.lfWeight >= FW_BOLD) cf.dwEffects |= CFE_BOLD;
          else cf.dwEffects &= ~CFE_BOLD;
  
          if(lf.lfItalic) cf.dwEffects |= CFE_ITALIC;
          else cf.dwEffects &= ~CFE_ITALIC;
  
          if(lf.lfUnderline) cf.dwEffects |= CFE_UNDERLINE;
          else cf.dwEffects &= ~CFE_UNDERLINE;
  
          cf.bCharSet = lf.lfCharSet;
          cf.bPitchAndFamily = lf.lfPitchAndFamily;
  #ifdef _UNICODE
          _tcscpy(cf.szFaceName, lf.lfFaceName);
  #else
          //need to thunk pcf->szFaceName to a standard char string.in this case it's easy because our thunk is also our copy
          MultiByteToWideChar(CP_ACP, 0, lf.lfFaceName, LF_FACESIZE, cf.szFaceName, LF_FACESIZE) ;
  #endif
  
          pserv->OnTxPropertyBitsChange(TXTBIT_CHARFORMATCHANGE,
                                        TXTBIT_CHARFORMATCHANGE);
      }
  
      void CTxtWinHost::SetColor(DWORD dwColor) {
          cf.crTextColor = RGB(GetBValue(dwColor), GetGValue(dwColor), GetRValue(dwColor));
          pserv->OnTxPropertyBitsChange(TXTBIT_CHARFORMATCHANGE,
                                        TXTBIT_CHARFORMATCHANGE);
      }
  
      SIZEL *CTxtWinHost::GetExtent() {
          return &sizelExtent;
      }
  
      void CTxtWinHost::SetExtent(SIZEL *psizelExtent) {
          sizelExtent = *psizelExtent;
          pserv->OnTxPropertyBitsChange(TXTBIT_EXTENTCHANGE, TXTBIT_EXTENTCHANGE);
      }
  
      void CTxtWinHost::LimitText(LONG nChars) {
          cchTextMost = nChars;
  
          if( cchTextMost <= 0 ) cchTextMost = cInitTextMax;
  
          pserv->OnTxPropertyBitsChange(TXTBIT_MAXLENGTHCHANGE, TXTBIT_MAXLENGTHCHANGE);
      }
  
      BOOL CTxtWinHost::IsCaptured() {
          return fCaptured;
      }
  
      BOOL CTxtWinHost::IsShowCaret() {
          return fShowCaret;
      }
  
      void CTxtWinHost::NeedFreshCaret() {
          fNeedFreshCaret = TRUE;
      }
  
      INT CTxtWinHost::GetCaretWidth() {
          return iCaretWidth;
      }
  
      INT CTxtWinHost::GetCaretHeight() {
          return iCaretHeight;
      }
  
      BOOL CTxtWinHost::GetAllowBeep() {
          return fAllowBeep;
      }
  
      void CTxtWinHost::SetAllowBeep(BOOL fIsAllowBeep) {
          fAllowBeep = fIsAllowBeep;
  
          pserv->OnTxPropertyBitsChange(TXTBIT_ALLOWBEEP,
                                        fAllowBeep ? TXTBIT_ALLOWBEEP : 0);
      }
  
      WORD CTxtWinHost::GetDefaultAlign() {
          return pf.wAlignment;
      }
  
      void CTxtWinHost::SetDefaultAlign(WORD wNewAlign) {
          pf.wAlignment = wNewAlign;
  
          // Notify control of property change
          pserv->OnTxPropertyBitsChange(TXTBIT_PARAFORMATCHANGE, 0);
      }
  
      BOOL CTxtWinHost::GetRichTextFlag() {
          return fRich;
      }
  
      void CTxtWinHost::SetRichTextFlag(BOOL fNew) {
          fRich = fNew;
  
          pserv->OnTxPropertyBitsChange(TXTBIT_RICHTEXT,
                                        fNew ? TXTBIT_RICHTEXT : 0);
      }
  
      LONG CTxtWinHost::GetDefaultLeftIndent() {
          return pf.dxOffset;
      }
  
      void CTxtWinHost::SetDefaultLeftIndent(LONG lNewIndent) {
          pf.dxOffset = lNewIndent;
  
          pserv->OnTxPropertyBitsChange(TXTBIT_PARAFORMATCHANGE, 0);
      }
  
      void CTxtWinHost::SetClientRect(RECT *prc) {
          rcClient = *prc;
  
          LONG xPerInch = ::GetDeviceCaps(m_re->GetManager()->GetPaintDC(), LOGPIXELSX);
          LONG yPerInch = ::GetDeviceCaps(m_re->GetManager()->GetPaintDC(), LOGPIXELSY);
          sizelExtent.cx = DXtoHimetricX(rcClient.right - rcClient.left, xPerInch);
          sizelExtent.cy = DYtoHimetricY(rcClient.bottom - rcClient.top, yPerInch);
  
          pserv->OnTxPropertyBitsChange(TXTBIT_VIEWINSETCHANGE, TXTBIT_VIEWINSETCHANGE);
      }
  
      BOOL CTxtWinHost::SetSaveSelection(BOOL f_SaveSelection) {
          BOOL fResult = f_SaveSelection;
  
          fSaveSelection = f_SaveSelection;
  
          // notify text services of property change
          pserv->OnTxPropertyBitsChange(TXTBIT_SAVESELECTION,
                                        fSaveSelection ? TXTBIT_SAVESELECTION : 0);
  
          return fResult;
      }
  
      HRESULT CTxtWinHost::OnTxInPlaceDeactivate() {
          HRESULT hr = pserv->OnTxInPlaceDeactivate();
  
          if (SUCCEEDED(hr)) {
              fInplaceActive = FALSE;
          }
  
          return hr;
      }
  
      HRESULT CTxtWinHost::OnTxInPlaceActivate(LPCRECT prcClient) {
          fInplaceActive = TRUE;
  
          HRESULT hr = pserv->OnTxInPlaceActivate(prcClient);
  
          if (FAILED(hr)) {
              fInplaceActive = FALSE;
          }
  
          return hr;
      }
  
      BOOL CTxtWinHost::DoSetCursor(RECT *prc, POINT *pt) {
          RECT rc = prc ? *prc : rcClient;
  
          // Is this in our rectangle?
          if (PtInRect(&rc, *pt)) {
              RECT *prcClient = (!fInplaceActive || prc) ? &rc : NULL;
              pserv->OnTxSetCursor(DVASPECT_CONTENT,  -1, NULL, NULL,  m_re->GetManager()->GetPaintDC(),
                                   NULL, prcClient, pt->x, pt->y);
  
              return TRUE;
          }
  
          return FALSE;
      }
  
      void CTxtWinHost::GetControlRect(LPRECT prc) {
          prc->top = rcClient.top;
          prc->bottom = rcClient.bottom;
          prc->left = rcClient.left;
          prc->right = rcClient.right;
      }
  
      void CTxtWinHost::SetTransparent(BOOL f_Transparent) {
          fTransparent = f_Transparent;
  
          // notify text services of property change
          pserv->OnTxPropertyBitsChange(TXTBIT_BACKSTYLECHANGE, 0);
      }
  
      LONG CTxtWinHost::SetAccelPos(LONG l_accelpos) {
          LONG laccelposOld = l_accelpos;
  
          laccelpos = l_accelpos;
  
          // notify text services of property change
          pserv->OnTxPropertyBitsChange(TXTBIT_SHOWACCELERATOR, 0);
  
          return laccelposOld;
      }
  
      WCHAR CTxtWinHost::SetPasswordChar(WCHAR ch_PasswordChar) {
          WCHAR chOldPasswordChar = chPasswordChar;
  
          chPasswordChar = ch_PasswordChar;
  
          // notify text services of property change
          pserv->OnTxPropertyBitsChange(TXTBIT_USEPASSWORD,
                                        (chPasswordChar != 0) ? TXTBIT_USEPASSWORD : 0);
  
          return chOldPasswordChar;
      }
  
      void CTxtWinHost::SetDisabled(BOOL fOn) {
          cf.dwMask    |= CFM_COLOR | CFM_DISABLED;
          cf.dwEffects |= CFE_AUTOCOLOR | CFE_DISABLED;
  
          if( !fOn ) {
              cf.dwEffects &= ~CFE_DISABLED;
          }
  
          pserv->OnTxPropertyBitsChange(TXTBIT_CHARFORMATCHANGE,
                                        TXTBIT_CHARFORMATCHANGE);
      }
  
      LONG CTxtWinHost::SetSelBarWidth(LONG l_SelBarWidth) {
          LONG lOldSelBarWidth = lSelBarWidth;
  
          lSelBarWidth = l_SelBarWidth;
  
          if (lSelBarWidth) {
              dwStyle |= ES_SELECTIONBAR;
          } else {
              dwStyle &= (~ES_SELECTIONBAR);
          }
  
          pserv->OnTxPropertyBitsChange(TXTBIT_SELBARCHANGE, TXTBIT_SELBARCHANGE);
  
          return lOldSelBarWidth;
      }
  
      BOOL CTxtWinHost::GetTimerState() {
          return fTimer;
      }
  
      void CTxtWinHost::SetCharFormat(CHARFORMAT2W &c) {
          cf = c;
      }
  
      void CTxtWinHost::SetParaFormat(PARAFORMAT2 &p) {
          pf = p;
      }
  
      /////////////////////////////////////////////////////////////////////////////////////
      //
      //
      IMPLEMENT_DUICONTROL(CRichEditUI)
      CRichEditUI::CRichEditUI() : m_pTwh(NULL), m_bVScrollBarFixing(false), m_bWantTab(true), m_bWantReturn(true),
          m_bWantCtrlReturn(true), m_bTransparent(true), m_bRich(true), m_bReadOnly(false), m_bWordWrap(false), m_dwTextColor(0), m_iFont(-1),
          m_iLimitText(cInitTextMax), m_lTwhStyle(ES_MULTILINE), m_bDrawCaret(true), m_bInited(false), m_chLeadByte(0), m_uButtonState(0),
          m_dwTipValueColor(0xFFBAC0C5), m_uTipValueAlign(DT_SINGLELINE | DT_LEFT) {
  #ifndef _UNICODE
          m_fAccumulateDBC = true;
  #else
          m_fAccumulateDBC = false;
  #endif
          ::ZeroMemory(&m_rcTextPadding, sizeof(m_rcTextPadding));
      }
  
      CRichEditUI::~CRichEditUI() {
          if( m_pTwh ) {
              m_pTwh->Release();
              m_pManager->RemoveMessageFilter(this);
          }
      }
  
      LPCTSTR CRichEditUI::GetClass() const {
          return DUI_CTR_RICHEDIT;
      }
  
      LPVOID CRichEditUI::GetInterface(LPCTSTR pstrName) {
          if( _tcscmp(pstrName, DUI_CTR_RICHEDIT) == 0 ) return static_cast<CRichEditUI *>(this);
  
          return CContainerUI::GetInterface(pstrName);
      }
  
      UINT CRichEditUI::GetControlFlags() const {
          if( !IsEnabled() ) return CControlUI::GetControlFlags();
  
          return UIFLAG_SETCURSOR | UIFLAG_TABSTOP;
      }
  
      bool CRichEditUI::IsMultiLine() {
          return (m_lTwhStyle & ES_MULTILINE) == ES_MULTILINE;
      }
  
      void CRichEditUI::SetMultiLine(bool bMultiLine) {
          if(!bMultiLine) m_lTwhStyle &= ~ES_MULTILINE;
          else  m_lTwhStyle |= ES_MULTILINE;
      }
  
      bool CRichEditUI::IsWantTab() {
          return m_bWantTab;
      }
  
      void CRichEditUI::SetWantTab(bool bWantTab) {
          m_bWantTab = bWantTab;
      }
  
      bool CRichEditUI::IsWantReturn() {
          return m_bWantReturn;
      }
  
      void CRichEditUI::SetWantReturn(bool bWantReturn) {
          m_bWantReturn = bWantReturn;
      }
  
      bool CRichEditUI::IsWantCtrlReturn() {
          return m_bWantCtrlReturn;
      }
  
      void CRichEditUI::SetWantCtrlReturn(bool bWantCtrlReturn) {
          m_bWantCtrlReturn = bWantCtrlReturn;
      }
  
      bool CRichEditUI::IsTransparent() {
          return m_bTransparent;
      }
  
      void CRichEditUI::SetTransparent(bool bTransparent) {
          m_bTransparent = bTransparent;
  
          if( m_pTwh ) m_pTwh->SetTransparent(bTransparent);
      }
  
      bool CRichEditUI::IsRich() {
          return m_bRich;
      }
  
      void CRichEditUI::SetRich(bool bRich) {
          m_bRich = bRich;
  
          if( m_pTwh ) m_pTwh->SetRichTextFlag(bRich);
      }
  
      bool CRichEditUI::IsReadOnly() {
          return m_bReadOnly;
      }
  
      void CRichEditUI::SetReadOnly(bool bReadOnly) {
          m_bReadOnly = bReadOnly;
  
          if( m_pTwh ) m_pTwh->SetReadOnly(bReadOnly);
      }
  
      bool CRichEditUI::IsWordWrap() {
          return m_bWordWrap;
      }
  
      void CRichEditUI::SetWordWrap(bool bWordWrap) {
          m_bWordWrap = bWordWrap;
  
          if( m_pTwh ) m_pTwh->SetWordWrap(bWordWrap);
      }
  
      int CRichEditUI::GetFont() {
          return m_iFont;
      }
  
      void CRichEditUI::SetFont(int index) {
          m_iFont = index;
  
          if( m_pTwh ) {
              m_pTwh->SetFont(GetManager()->GetFont(m_iFont));
          }
      }
  
      void CRichEditUI::SetFont(LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic) {
          if( m_pTwh ) {
              LOGFONT lf = { 0 };
              ::GetObject(::GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONT), &lf);
              _tcsncpy(lf.lfFaceName, pStrFontName, LF_FACESIZE);
              lf.lfCharSet = DEFAULT_CHARSET;
              lf.lfHeight = -nSize;
  
              if( bBold ) lf.lfWeight += FW_BOLD;
  
              if( bUnderline ) lf.lfUnderline = TRUE;
  
              if( bItalic ) lf.lfItalic = TRUE;
  
              HFONT hFont = ::CreateFontIndirect(&lf);
  
              if( hFont == NULL ) return;
  
              m_pTwh->SetFont(hFont);
              ::DeleteObject(hFont);
          }
      }
  
      LONG CRichEditUI::GetWinStyle() {
          return m_lTwhStyle;
      }
  
      void CRichEditUI::SetWinStyle(LONG lStyle) {
          m_lTwhStyle = lStyle;
      }
  
      DWORD CRichEditUI::GetTextColor() {
          return m_dwTextColor;
      }
  
      void CRichEditUI::SetTextColor(DWORD dwTextColor) {
          m_dwTextColor = dwTextColor;
  
          if( m_pTwh ) {
              m_pTwh->SetColor(dwTextColor);
          }
      }
  
      int CRichEditUI::GetLimitText() {
          return m_iLimitText;
      }
  
      void CRichEditUI::SetLimitText(int iChars) {
          m_iLimitText = iChars;
  
          if( m_pTwh ) {
              m_pTwh->LimitText(m_iLimitText);
          }
      }
  
      long CRichEditUI::GetTextLength(DWORD dwFlags) const {
          GETTEXTLENGTHEX textLenEx;
          textLenEx.flags = dwFlags;
  #ifdef _UNICODE
          textLenEx.codepage = 1200;
  #else
          textLenEx.codepage = CP_ACP;
  #endif
          LRESULT lResult;
          TxSendMessage(EM_GETTEXTLENGTHEX, (WPARAM)&textLenEx, 0, &lResult);
          return (long)lResult;
      }
  
      CDuiString CRichEditUI::GetText() const {
          long lLen = GetTextLength(GTL_DEFAULT);
          LPTSTR lpText = NULL;
          GETTEXTEX gt;
          gt.flags = GT_DEFAULT;
  #ifdef _UNICODE
          gt.cb = sizeof(TCHAR) * (lLen + 1) ;
          gt.codepage = 1200;
          lpText = new TCHAR[lLen + 1];
          ::ZeroMemory(lpText, (lLen + 1) * sizeof(TCHAR));
  #else
          gt.cb = sizeof(TCHAR) * lLen * 2 + 1;
          gt.codepage = CP_ACP;
          lpText = new TCHAR[lLen * 2 + 1];
          ::ZeroMemory(lpText, (lLen * 2 + 1) * sizeof(TCHAR));
  #endif
          gt.lpDefaultChar = NULL;
          gt.lpUsedDefChar = NULL;
          TxSendMessage(EM_GETTEXTEX, (WPARAM)&gt, (LPARAM)lpText, 0);
          CDuiString sText(lpText);
          delete[] lpText;
          return sText;
      }
  
      void CRichEditUI::SetText(LPCTSTR pstrText) {
          m_sText = pstrText;
  
          if( !m_pTwh ) return;
  
          SetSel(0, -1);
          ReplaceSel(pstrText, FALSE);
      }
  
      bool CRichEditUI::IsModify() const {
          if( !m_pTwh ) return false;
  
          LRESULT lResult;
          TxSendMessage(EM_GETMODIFY, 0, 0, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      void CRichEditUI::SetModify(bool bModified) const {
          TxSendMessage(EM_SETMODIFY, bModified, 0, 0);
      }
  
      void CRichEditUI::GetSel(CHARRANGE &cr) const {
          TxSendMessage(EM_EXGETSEL, 0, (LPARAM)&cr, 0);
      }
  
      void CRichEditUI::GetSel(long &nStartChar, long &nEndChar) const {
          CHARRANGE cr;
          TxSendMessage(EM_EXGETSEL, 0, (LPARAM)&cr, 0);
          nStartChar = cr.cpMin;
          nEndChar = cr.cpMax;
      }
  
      int CRichEditUI::SetSel(CHARRANGE &cr) {
          LRESULT lResult;
          TxSendMessage(EM_EXSETSEL, 0, (LPARAM)&cr, &lResult);
          return (int)lResult;
      }
  
      int CRichEditUI::SetSel(long nStartChar, long nEndChar) {
          CHARRANGE cr;
          cr.cpMin = nStartChar;
          cr.cpMax = nEndChar;
          LRESULT lResult;
          TxSendMessage(EM_EXSETSEL, 0, (LPARAM)&cr, &lResult);
          return (int)lResult;
      }
  
      void CRichEditUI::ReplaceSel(LPCTSTR lpszNewText, bool bCanUndo) {
  #ifdef _UNICODE
          TxSendMessage(EM_REPLACESEL, (WPARAM) bCanUndo, (LPARAM)lpszNewText, 0);
  #else
          int iLen = _tcslen(lpszNewText);
          LPWSTR lpText = new WCHAR[iLen + 1];
          ::ZeroMemory(lpText, (iLen + 1) * sizeof(WCHAR));
          ::MultiByteToWideChar(CP_ACP, 0, lpszNewText, -1, (LPWSTR)lpText, iLen) ;
          TxSendMessage(EM_REPLACESEL, (WPARAM) bCanUndo, (LPARAM)lpText, 0);
          delete[] lpText;
  #endif
      }
  
      void CRichEditUI::ReplaceSelW(LPCWSTR lpszNewText, bool bCanUndo) {
          TxSendMessage(EM_REPLACESEL, (WPARAM) bCanUndo, (LPARAM)lpszNewText, 0);
      }
  
      CDuiString CRichEditUI::GetSelText() const {
          if( !m_pTwh ) return CDuiString();
  
          CHARRANGE cr;
          cr.cpMin = cr.cpMax = 0;
          TxSendMessage(EM_EXGETSEL, 0, (LPARAM)&cr, 0);
          LPWSTR lpText = NULL;
          lpText = new WCHAR[cr.cpMax - cr.cpMin + 1];
          ::ZeroMemory(lpText, (cr.cpMax - cr.cpMin + 1) * sizeof(WCHAR));
          TxSendMessage(EM_GETSELTEXT, 0, (LPARAM)lpText, 0);
          CDuiString sText;
          sText = (LPCWSTR)lpText;
          delete[] lpText;
          return sText;
      }
  
      int CRichEditUI::SetSelAll() {
          return SetSel(0, -1);
      }
  
      int CRichEditUI::SetSelNone() {
          return SetSel(-1, 0);
      }
  
      bool CRichEditUI::GetZoom(int &nNum, int &nDen) const {
          LRESULT lResult;
          TxSendMessage(EM_GETZOOM, (WPARAM)&nNum, (LPARAM)&nDen, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      bool CRichEditUI::SetZoom(int nNum, int nDen) {
          if (nNum < 0 || nNum > 64) return false;
  
          if (nDen < 0 || nDen > 64) return false;
  
          LRESULT lResult;
          TxSendMessage(EM_SETZOOM, nNum, nDen, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      bool CRichEditUI::SetZoomOff() {
          LRESULT lResult;
          TxSendMessage(EM_SETZOOM, 0, 0, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      WORD CRichEditUI::GetSelectionType() const {
          LRESULT lResult;
          TxSendMessage(EM_SELECTIONTYPE, 0, 0, &lResult);
          return (WORD)lResult;
      }
  
      bool CRichEditUI::GetAutoURLDetect() const {
          LRESULT lResult;
          TxSendMessage(EM_GETAUTOURLDETECT, 0, 0, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      bool CRichEditUI::SetAutoURLDetect(bool bAutoDetect) {
          LRESULT lResult;
          TxSendMessage(EM_AUTOURLDETECT, bAutoDetect, 0, &lResult);
          return (BOOL)lResult == FALSE;
      }
  
      DWORD CRichEditUI::GetEventMask() const {
          LRESULT lResult;
          TxSendMessage(EM_GETEVENTMASK, 0, 0, &lResult);
          return (DWORD)lResult;
      }
  
      DWORD CRichEditUI::SetEventMask(DWORD dwEventMask) {
          LRESULT lResult;
          TxSendMessage(EM_SETEVENTMASK, 0, dwEventMask, &lResult);
          return (DWORD)lResult;
      }
  
      CDuiString CRichEditUI::GetTextRange(long nStartChar, long nEndChar) const {
          TEXTRANGEW tr = { 0 };
          tr.chrg.cpMin = nStartChar;
          tr.chrg.cpMax = nEndChar;
          LPWSTR lpText = NULL;
          lpText = new WCHAR[nEndChar - nStartChar + 1];
          ::ZeroMemory(lpText, (nEndChar - nStartChar + 1) * sizeof(WCHAR));
          tr.lpstrText = lpText;
          TxSendMessage(EM_GETTEXTRANGE, 0, (LPARAM)&tr, 0);
          CDuiString sText;
          sText = (LPCWSTR)lpText;
          delete[] lpText;
          return sText;
      }
  
      void CRichEditUI::HideSelection(bool bHide, bool bChangeStyle) {
          TxSendMessage(EM_HIDESELECTION, bHide, bChangeStyle, 0);
      }
  
      void CRichEditUI::ScrollCaret() {
          TxSendMessage(EM_SCROLLCARET, 0, 0, 0);
      }
  
      int CRichEditUI::InsertText(long nInsertAfterChar, LPCTSTR lpstrText, bool bCanUndo) {
          int nRet = SetSel(nInsertAfterChar, nInsertAfterChar);
          ReplaceSel(lpstrText, bCanUndo);
          return nRet;
      }
  
      int CRichEditUI::AppendText(LPCTSTR lpstrText, bool bCanUndo) {
          int nRet = SetSel(-1, -1);
          ReplaceSel(lpstrText, bCanUndo);
          return nRet;
      }
  
      DWORD CRichEditUI::GetDefaultCharFormat(CHARFORMAT2 &cf) const {
          cf.cbSize = sizeof(CHARFORMAT2);
          LRESULT lResult;
          TxSendMessage(EM_GETCHARFORMAT, 0, (LPARAM)&cf, &lResult);
          return (DWORD)lResult;
      }
  
      bool CRichEditUI::SetDefaultCharFormat(CHARFORMAT2 &cf) {
          if( !m_pTwh ) return false;
  
          cf.cbSize = sizeof(CHARFORMAT2);
          LRESULT lResult;
          TxSendMessage(EM_SETCHARFORMAT, 0, (LPARAM)&cf, &lResult);
  
          if( (BOOL)lResult == TRUE ) {
              CHARFORMAT2W cfw;
              cfw.cbSize = sizeof(CHARFORMAT2W);
              TxSendMessage(EM_GETCHARFORMAT, 1, (LPARAM)&cfw, 0);
              m_pTwh->SetCharFormat(cfw);
              return true;
          }
  
          return false;
      }
  
      DWORD CRichEditUI::GetSelectionCharFormat(CHARFORMAT2 &cf) const {
          cf.cbSize = sizeof(CHARFORMAT2);
          LRESULT lResult;
          TxSendMessage(EM_GETCHARFORMAT, 1, (LPARAM)&cf, &lResult);
          return (DWORD)lResult;
      }
  
      bool CRichEditUI::SetSelectionCharFormat(CHARFORMAT2 &cf) {
          if( !m_pTwh ) return false;
  
          cf.cbSize = sizeof(CHARFORMAT2);
          LRESULT lResult;
          TxSendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      bool CRichEditUI::SetWordCharFormat(CHARFORMAT2 &cf) {
          if( !m_pTwh ) return false;
  
          cf.cbSize = sizeof(CHARFORMAT2);
          LRESULT lResult;
          TxSendMessage(EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD, (LPARAM)&cf, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      DWORD CRichEditUI::GetParaFormat(PARAFORMAT2 &pf) const {
          pf.cbSize = sizeof(PARAFORMAT2);
          LRESULT lResult;
          TxSendMessage(EM_GETPARAFORMAT, 0, (LPARAM)&pf, &lResult);
          return (DWORD)lResult;
      }
  
      bool CRichEditUI::SetParaFormat(PARAFORMAT2 &pf) {
          if( !m_pTwh ) return false;
  
          pf.cbSize = sizeof(PARAFORMAT2);
          LRESULT lResult;
          TxSendMessage(EM_SETPARAFORMAT, 0, (LPARAM)&pf, &lResult);
  
          if( (BOOL)lResult == TRUE ) {
              m_pTwh->SetParaFormat(pf);
              return true;
          }
  
          return false;
      }
  
      bool CRichEditUI::CanUndo() {
          if( !m_pTwh ) return false;
  
          LRESULT lResult;
          TxSendMessage(EM_CANUNDO, 0, 0, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      bool CRichEditUI::CanRedo() {
          if( !m_pTwh ) return false;
  
          LRESULT lResult;
          TxSendMessage(EM_CANREDO, 0, 0, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      bool CRichEditUI::CanPaste() {
          if( !m_pTwh ) return false;
  
          LRESULT lResult;
          TxSendMessage(EM_CANPASTE, 0, 0, &lResult);
          return (BOOL)lResult == TRUE;
      }
      bool CRichEditUI::Redo() {
          if( !m_pTwh ) return false;
  
          LRESULT lResult;
          TxSendMessage(EM_REDO, 0, 0, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      bool CRichEditUI::Undo() {
          if( !m_pTwh ) return false;
  
          LRESULT lResult;
          TxSendMessage(EM_UNDO, 0, 0, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      void CRichEditUI::Clear() {
          TxSendMessage(WM_CLEAR, 0, 0, 0);
      }
  
      void CRichEditUI::Copy() {
          TxSendMessage(WM_COPY, 0, 0, 0);
      }
  
      void CRichEditUI::Cut() {
          TxSendMessage(WM_CUT, 0, 0, 0);
      }
  
      void CRichEditUI::Paste() {
          TxSendMessage(WM_PASTE, 0, 0, 0);
      }
  
      int CRichEditUI::GetLineCount() const {
          if( !m_pTwh ) return 0;
  
          LRESULT lResult;
          TxSendMessage(EM_GETLINECOUNT, 0, 0, &lResult);
          return (int)lResult;
      }
  
      CDuiString CRichEditUI::GetLine(int nIndex, int nMaxLength) const {
          LPWSTR lpText = NULL;
          lpText = new WCHAR[nMaxLength + 1];
          ::ZeroMemory(lpText, (nMaxLength + 1) * sizeof(WCHAR));
          *(LPWORD)lpText = (WORD)nMaxLength;
          TxSendMessage(EM_GETLINE, nIndex, (LPARAM)lpText, 0);
          CDuiString sText;
          sText = (LPCWSTR)lpText;
          delete[] lpText;
          return sText;
      }
  
      int CRichEditUI::LineIndex(int nLine) const {
          LRESULT lResult;
          TxSendMessage(EM_LINEINDEX, nLine, 0, &lResult);
          return (int)lResult;
      }
  
      int CRichEditUI::LineLength(int nLine) const {
          LRESULT lResult;
          TxSendMessage(EM_LINELENGTH, nLine, 0, &lResult);
          return (int)lResult;
      }
  
      bool CRichEditUI::LineScroll(int nLines, int nChars) {
          LRESULT lResult;
          TxSendMessage(EM_LINESCROLL, nChars, nLines, &lResult);
          return (BOOL)lResult == TRUE;
      }
  
      CDuiPoint CRichEditUI::GetCharPos(long lChar) const {
          CDuiPoint pt;
          TxSendMessage(EM_POSFROMCHAR, (WPARAM)&pt, (LPARAM)lChar, 0);
          return pt;
      }
  
      long CRichEditUI::LineFromChar(long nIndex) const {
          if( !m_pTwh ) return 0L;
  
          LRESULT lResult;
          TxSendMessage(EM_EXLINEFROMCHAR, 0, nIndex, &lResult);
          return (long)lResult;
      }
  
      CDuiPoint CRichEditUI::PosFromChar(UINT nChar) const {
          POINTL pt;
          TxSendMessage(EM_POSFROMCHAR, (WPARAM)&pt, nChar, 0);
          return CDuiPoint(pt.x, pt.y);
      }
  
      int CRichEditUI::CharFromPos(CDuiPoint pt) const {
          POINTL ptl = {pt.x, pt.y};
  
          if( !m_pTwh ) return 0;
  
          LRESULT lResult;
          TxSendMessage(EM_CHARFROMPOS, 0, (LPARAM)&ptl, &lResult);
          return (int)lResult;
      }
  
      void CRichEditUI::EmptyUndoBuffer() {
          TxSendMessage(EM_EMPTYUNDOBUFFER, 0, 0, 0);
      }
  
      UINT CRichEditUI::SetUndoLimit(UINT nLimit) {
          if( !m_pTwh ) return 0;
  
          LRESULT lResult;
          TxSendMessage(EM_SETUNDOLIMIT, (WPARAM) nLimit, 0, &lResult);
          return (UINT)lResult;
      }
  
      long CRichEditUI::StreamIn(int nFormat, EDITSTREAM &es) {
          if( !m_pTwh ) return 0L;
  
          LRESULT lResult;
          TxSendMessage(EM_STREAMIN, nFormat, (LPARAM)&es, &lResult);
          return (long)lResult;
      }
  
      long CRichEditUI::StreamOut(int nFormat, EDITSTREAM &es) {
          if( !m_pTwh ) return 0L;
  
          LRESULT lResult;
          TxSendMessage(EM_STREAMOUT, nFormat, (LPARAM)&es, &lResult);
          return (long)lResult;
      }
  
      void CRichEditUI::SetAccumulateDBCMode( bool bDBCMode ) {
          m_fAccumulateDBC = bDBCMode;
      }
  
      bool CRichEditUI::IsAccumulateDBCMode() {
          return m_fAccumulateDBC;
      }
  
      void CRichEditUI::DoInit() {
          if(m_bInited)
              return ;
  
          CREATESTRUCT cs;
          cs.style = m_lTwhStyle;
          cs.x = 0;
          cs.y = 0;
          cs.cy = 0;
          cs.cx = 0;
          cs.lpszName = m_sText;
          CreateHost(this, &cs, &m_pTwh);
  
          if( m_pTwh ) {
              if( m_bTransparent ) m_pTwh->SetTransparent(TRUE);
  
              LRESULT lResult;
              m_pTwh->GetTextServices()->TxSendMessage(EM_SETLANGOPTIONS, 0, 0, &lResult);
              m_pTwh->GetTextServices()->TxSendMessage(EM_SETEVENTMASK, 0, ENM_DROPFILES | ENM_LINK | ENM_CHANGE, &lResult);
              m_pTwh->OnTxInPlaceActivate(NULL);
              m_pManager->AddMessageFilter(this);
  
              if( m_pManager->IsLayered() ) m_pManager->SetTimer(this, DEFAULT_TIMERID, ::GetCaretBlinkTime());
  
              if (!m_bEnabled) {
                  m_pTwh->SetColor(m_pManager->GetDefaultDisabledColor());
              }
          }
  
          m_bInited = true;
      }
  
      HRESULT CRichEditUI::TxSendMessage(UINT msg, WPARAM wparam, LPARAM lparam, LRESULT *plresult) const {
          if( m_pTwh ) {
              if( msg == WM_KEYDOWN && TCHAR(wparam) == VK_RETURN ) {
                  if( !m_bWantReturn || (::GetKeyState(VK_CONTROL) < 0 && !m_bWantCtrlReturn) ) {
                      if( m_pManager != NULL ) m_pManager->SendNotify((CControlUI *)this, DUI_MSGTYPE_RETURN);
  
                      return S_OK;
                  }
              }
  
              return m_pTwh->GetTextServices()->TxSendMessage(msg, wparam, lparam, plresult);
          }
  
          return S_FALSE;
      }
  
      IDropTarget *CRichEditUI::GetTxDropTarget() {
          IDropTarget *pdt = NULL;
  
          if( m_pTwh->GetTextServices()->TxGetDropTarget(&pdt) == NOERROR ) return pdt;
  
          return NULL;
      }
  
      bool CRichEditUI::OnTxViewChanged() {
          return true;
      }
  
      bool CRichEditUI::SetDropAcceptFile(bool bAccept) {
          LRESULT lResult;
          TxSendMessage(EM_SETEVENTMASK, 0, ENM_DROPFILES | ENM_LINK, // ENM_CHANGE| ENM_CORRECTTEXT | ENM_DRAGDROPDONE | ENM_DROPFILES | ENM_IMECHANGE | ENM_LINK | ENM_OBJECTPOSITIONS | ENM_PROTECTED | ENM_REQUESTRESIZE | ENM_SCROLL | ENM_SELCHANGE | ENM_UPDATE,
                        &lResult);
          return (BOOL)lResult == FALSE;
      }
  
      void CRichEditUI::OnTxNotify(DWORD iNotify, void *pv) {
          switch(iNotify) {
              case EN_CHANGE: {
                      GetManager()->SendNotify(this, DUI_MSGTYPE_TEXTCHANGED);
                      break;
                  }
  
              case EN_DROPFILES:
              case EN_MSGFILTER:
              case EN_OLEOPFAILED:
              case EN_PROTECTED:
              case EN_SAVECLIPBOARD:
              case EN_SELCHANGE:
              case EN_STOPNOUNDO:
              case EN_LINK:
              case EN_OBJECTPOSITIONS:
              case EN_DRAGDROPDONE: {
                      if(pv) {                      // Fill out NMHDR portion of pv
                          LONG nId =  GetWindowLong(this->GetManager()->GetPaintWindow(), GWL_ID);
                          NMHDR  *phdr = (NMHDR *)pv;
                          phdr->hwndFrom = this->GetManager()->GetPaintWindow();
                          phdr->idFrom = nId;
                          phdr->code = iNotify;
  
                          if(SendMessage(this->GetManager()->GetPaintWindow(), WM_NOTIFY, (WPARAM) nId, (LPARAM) pv)) {
                              //hr = S_FALSE;
                          }
                      }
                  }
                  break;
          }
      }
  
      // 多行非rich格式的richedit有一个滚动条bug，在最后一行是空行时，LineDown和SetScrollPos无法滚动到最后
      // 引入iPos就是为了修正这个bug
      void CRichEditUI::SetScrollPos(SIZE szPos, bool bMsg) {
          int cx = 0;
          int cy = 0;
  
          if( m_pVerticalScrollBar && m_pVerticalScrollBar->IsVisible() ) {
              int iLastScrollPos = m_pVerticalScrollBar->GetScrollPos();
              m_pVerticalScrollBar->SetScrollPos(szPos.cy);
              cy = m_pVerticalScrollBar->GetScrollPos() - iLastScrollPos;
          }
  
          if( m_pHorizontalScrollBar && m_pHorizontalScrollBar->IsVisible() ) {
              int iLastScrollPos = m_pHorizontalScrollBar->GetScrollPos();
              m_pHorizontalScrollBar->SetScrollPos(szPos.cx);
              cx = m_pHorizontalScrollBar->GetScrollPos() - iLastScrollPos;
          }
  
          if( cy != 0 ) {
              int iPos = 0;
  
              if( m_pTwh && !m_bRich && m_pVerticalScrollBar && m_pVerticalScrollBar->IsVisible() )
                  iPos = m_pVerticalScrollBar->GetScrollPos();
  
              WPARAM wParam = MAKEWPARAM(SB_THUMBPOSITION, m_pVerticalScrollBar->GetScrollPos());
              TxSendMessage(WM_VSCROLL, wParam, 0L, 0);
  
              if( m_pTwh && !m_bRich && m_pVerticalScrollBar && m_pVerticalScrollBar->IsVisible() ) {
                  if( cy > 0 && m_pVerticalScrollBar->GetScrollPos() <= iPos )
                      m_pVerticalScrollBar->SetScrollPos(iPos);
              }
          }
  
          if( cx != 0 ) {
              WPARAM wParam = MAKEWPARAM(SB_THUMBPOSITION, m_pHorizontalScrollBar->GetScrollPos());
              TxSendMessage(WM_HSCROLL, wParam, 0L, 0);
          }
      }
  
      void CRichEditUI::LineUp() {
          TxSendMessage(WM_VSCROLL, SB_LINEUP, 0L, 0);
      }
  
      void CRichEditUI::LineDown() {
          int iPos = 0;
  
          if( m_pTwh && !m_bRich && m_pVerticalScrollBar && m_pVerticalScrollBar->IsVisible() )
              iPos = m_pVerticalScrollBar->GetScrollPos();
  
          TxSendMessage(WM_VSCROLL, SB_LINEDOWN, 0L, 0);
  
          if( m_pTwh && !m_bRich && m_pVerticalScrollBar && m_pVerticalScrollBar->IsVisible() ) {
              if( m_pVerticalScrollBar->GetScrollPos() <= iPos )
                  m_pVerticalScrollBar->SetScrollPos(m_pVerticalScrollBar->GetScrollRange());
          }
      }
  
      void CRichEditUI::PageUp() {
          TxSendMessage(WM_VSCROLL, SB_PAGEUP, 0L, 0);
      }
  
      void CRichEditUI::PageDown() {
          TxSendMessage(WM_VSCROLL, SB_PAGEDOWN, 0L, 0);
      }
  
      void CRichEditUI::HomeUp() {
          TxSendMessage(WM_VSCROLL, SB_TOP, 0L, 0);
      }
  
      void CRichEditUI::EndDown() {
          TxSendMessage(WM_VSCROLL, SB_BOTTOM, 0L, 0);
      }
  
      void CRichEditUI::LineLeft() {
          TxSendMessage(WM_HSCROLL, SB_LINELEFT, 0L, 0);
      }
  
      void CRichEditUI::LineRight() {
          TxSendMessage(WM_HSCROLL, SB_LINERIGHT, 0L, 0);
      }
  
      void CRichEditUI::PageLeft() {
          TxSendMessage(WM_HSCROLL, SB_PAGELEFT, 0L, 0);
      }
  
      void CRichEditUI::PageRight() {
          TxSendMessage(WM_HSCROLL, SB_PAGERIGHT, 0L, 0);
      }
  
      void CRichEditUI::HomeLeft() {
          TxSendMessage(WM_HSCROLL, SB_LEFT, 0L, 0);
      }
  
      void CRichEditUI::EndRight() {
          TxSendMessage(WM_HSCROLL, SB_RIGHT, 0L, 0);
      }
  
      void CRichEditUI::DoEvent(TEventUI &event) {
          if( !IsMouseEnabled() && event.Type > UIEVENT__MOUSEBEGIN && event.Type < UIEVENT__MOUSEEND ) {
              if( m_pParent != NULL ) m_pParent->DoEvent(event);
              else CControlUI::DoEvent(event);
  
              return;
          }
  
          if( event.Type == UIEVENT_SETCURSOR && IsEnabled() ) {
              if( m_pTwh && m_pTwh->DoSetCursor(NULL, &event.ptMouse) ) {
                  return;
              }
          } else if( event.Type == UIEVENT_WINDOWSIZE ) {
              if( m_pTwh ) m_pTwh->NeedFreshCaret();
          } else if( event.Type == UIEVENT_SETFOCUS ) {
              if( m_pTwh ) {
                  m_pTwh->OnTxInPlaceActivate(NULL);
                  m_pTwh->GetTextServices()->TxSendMessage(WM_SETFOCUS, 0, 0, 0);
              }
  
              m_bFocused = true;
              Invalidate();
              return;
          }
  
          if( event.Type == UIEVENT_KILLFOCUS )  {
              if( m_pTwh ) {
                  m_pTwh->OnTxInPlaceActivate(NULL);
                  m_pTwh->GetTextServices()->TxSendMessage(WM_KILLFOCUS, 0, 0, 0);
              }
  
              m_bFocused = false;
              Invalidate();
              return;
          } else if( event.Type == UIEVENT_TIMER ) {
              if( event.wParam == DEFAULT_TIMERID ) {
                  if( m_pTwh && m_pManager->IsLayered() && IsFocused() ) {
                      if (::GetFocus() != m_pManager->GetPaintWindow()) return;
  
                      m_bDrawCaret = !m_bDrawCaret;
                      POINT ptCaret;
                      ::GetCaretPos(&ptCaret);
                      RECT rcCaret = { ptCaret.x, ptCaret.y, ptCaret.x + m_pTwh->GetCaretWidth(),
                                       ptCaret.y + m_pTwh->GetCaretHeight()
                                     };
                      RECT rcTemp = rcCaret;
  
                      if( !::IntersectRect(&rcCaret, &rcTemp, &m_rcItem) ) return;
  
                      CControlUI *pParent = this;
                      RECT rcParent;
  
                      while( !!(pParent = pParent->GetParent()) ) {
                          rcTemp = rcCaret;
                          rcParent = pParent->GetPos();
  
                          if( !::IntersectRect(&rcCaret, &rcTemp, &rcParent) ) {
                              return;
                          }
                      }
  
                      m_pManager->Invalidate(rcCaret);
                  }
  
                  return;
              }
  
              if( m_pTwh ) {
                  m_pTwh->GetTextServices()->TxSendMessage(WM_TIMER, event.wParam, event.lParam, 0);
              }
  
              return;
          }
  
          if( event.Type == UIEVENT_SCROLLWHEEL ) {
              if( (event.wKeyState & MK_CONTROL) != 0  ) {
                  return;
              }
          }
  
          if( event.Type == UIEVENT_BUTTONDOWN || event.Type == UIEVENT_DBLCLICK ) {
              return;
          }
  
          if( event.Type == UIEVENT_MOUSEMOVE ) {
              return;
          }
  
          if( event.Type == UIEVENT_BUTTONUP ) {
              return;
          }
  
          if( event.Type > UIEVENT__KEYBEGIN && event.Type < UIEVENT__KEYEND ) {
              return;
          }
  
          CContainerUI::DoEvent(event);
      }
  
      SIZE CRichEditUI::EstimateSize(SIZE szAvailable) {
          //return CDuiSize(m_rcItem); // 这种方式在第一次设置大小之后就大小不变了
          return CContainerUI::EstimateSize(szAvailable);
      }
  
      void CRichEditUI::SetPos(RECT rc, bool bNeedInvalidate) {
          CControlUI::SetPos(rc, bNeedInvalidate);
          rc = m_rcItem;
  
          rc.left += m_rcInset.left;
          rc.top += m_rcInset.top;
          rc.right -= m_rcInset.right;
          rc.bottom -= m_rcInset.bottom;
  
          RECT rcScrollView = rc;
  
          bool bVScrollBarVisiable = false;
  
          if( m_pVerticalScrollBar && m_pVerticalScrollBar->IsVisible() ) {
              bVScrollBarVisiable = true;
              rc.top -= m_pVerticalScrollBar->GetScrollPos();
              rc.bottom -= m_pVerticalScrollBar->GetScrollPos();
              rc.bottom += m_pVerticalScrollBar->GetScrollRange();
              rc.right -= m_pVerticalScrollBar->GetFixedWidth();
              rcScrollView.right -= m_pVerticalScrollBar->GetFixedWidth();
          }
  
          if( m_pHorizontalScrollBar && m_pHorizontalScrollBar->IsVisible() ) {
              rc.left -= m_pHorizontalScrollBar->GetScrollPos();
              rc.right -= m_pHorizontalScrollBar->GetScrollPos();
              rc.right += m_pHorizontalScrollBar->GetScrollRange();
              rc.bottom -= m_pHorizontalScrollBar->GetFixedHeight();
              rcScrollView.bottom -= m_pHorizontalScrollBar->GetFixedHeight();
          }
  
          if( m_pTwh != NULL ) {
              RECT rcScrollTextView = rcScrollView;
              rcScrollTextView.left += m_rcTextPadding.left;
              rcScrollTextView.right -= m_rcTextPadding.right;
              rcScrollTextView.top += m_rcTextPadding.top;
              rcScrollTextView.bottom -= m_rcTextPadding.bottom;
              RECT rcText = rc;
              rcText.left += m_rcTextPadding.left;
              rcText.right -= m_rcTextPadding.right;
              rcText.top += m_rcTextPadding.top;
              rcText.bottom -= m_rcTextPadding.bottom;
              m_pTwh->SetClientRect(&rcScrollTextView);
  
              if( bVScrollBarVisiable && (!m_pVerticalScrollBar->IsVisible() || m_bVScrollBarFixing) ) {
                  LONG lWidth = rcText.right - rcText.left + m_pVerticalScrollBar->GetFixedWidth();
                  LONG lHeight = 0;
                  SIZEL szExtent = { -1, -1 };
                  m_pTwh->GetTextServices()->TxGetNaturalSize(
                      DVASPECT_CONTENT,
                      GetManager()->GetPaintDC(),
                      NULL,
                      NULL,
                      TXTNS_FITTOCONTENT,
                      &szExtent,
                      &lWidth,
                      &lHeight);
  
                  if( lHeight > rcText.bottom - rcText.top ) {
                      m_pVerticalScrollBar->SetVisible(true);
                      m_pVerticalScrollBar->SetScrollPos(0);
                      m_bVScrollBarFixing = true;
                  } else {
                      if( m_bVScrollBarFixing ) {
                          m_pVerticalScrollBar->SetVisible(false);
                          m_bVScrollBarFixing = false;
                      }
                  }
              }
          }
  
          if( m_pVerticalScrollBar != NULL && m_pVerticalScrollBar->IsVisible() ) {
              RECT rcScrollBarPos = { rcScrollView.right, rcScrollView.top,
                                      rcScrollView.right + m_pVerticalScrollBar->GetFixedWidth(), rcScrollView.bottom
                                    };
              m_pVerticalScrollBar->SetPos(rcScrollBarPos, false);
          }
  
          if( m_pHorizontalScrollBar != NULL && m_pHorizontalScrollBar->IsVisible() ) {
              RECT rcScrollBarPos = { rcScrollView.left, rcScrollView.bottom, rcScrollView.right,
                                      rcScrollView.bottom + m_pHorizontalScrollBar->GetFixedHeight()
                                    };
              m_pHorizontalScrollBar->SetPos(rcScrollBarPos, false);
          }
  
          for( int it = 0; it < m_items.GetSize(); it++ ) {
              CControlUI *pControl = static_cast<CControlUI *>(m_items[it]);
  
              if( !pControl->IsVisible() ) continue;
  
              if( pControl->IsFloat() ) {
                  SetFloatPos(it);
              } else {
                  SIZE sz = { rc.right - rc.left, rc.bottom - rc.top };
  
                  if( sz.cx < pControl->GetMinWidth() ) sz.cx = pControl->GetMinWidth();
  
                  if( sz.cx > pControl->GetMaxWidth() ) sz.cx = pControl->GetMaxWidth();
  
                  if( sz.cy < pControl->GetMinHeight() ) sz.cy = pControl->GetMinHeight();
  
                  if( sz.cy > pControl->GetMaxHeight() ) sz.cy = pControl->GetMaxHeight();
  
                  RECT rcCtrl = { rc.left, rc.top, rc.left + sz.cx, rc.top + sz.cy };
                  pControl->SetPos(rcCtrl, false);
              }
          }
      }
  
      void CRichEditUI::Move(SIZE szOffset, bool bNeedInvalidate) {
          CContainerUI::Move(szOffset, bNeedInvalidate);
  
          if( m_pTwh != NULL ) {
              RECT rc = m_rcItem;
              rc.left += m_rcInset.left;
              rc.top += m_rcInset.top;
              rc.right -= m_rcInset.right;
              rc.bottom -= m_rcInset.bottom;
  
              if( m_pVerticalScrollBar && m_pVerticalScrollBar->IsVisible() ) rc.right -= m_pVerticalScrollBar->GetFixedWidth();
  
              if( m_pHorizontalScrollBar && m_pHorizontalScrollBar->IsVisible() ) rc.bottom -= m_pHorizontalScrollBar->GetFixedHeight();
  
              m_pTwh->SetClientRect(&rc);
          }
      }
  
      bool CRichEditUI::DoPaint(HDC hDC, const RECT &rcPaint, CControlUI *pStopControl) {
          RECT rcTemp = { 0 };
  
          if( !::IntersectRect(&rcTemp, &rcPaint, &m_rcItem) ) return true;
  
          CRenderClip clip;
          CRenderClip::GenerateClip(hDC, rcTemp, clip);
          CControlUI::DoPaint(hDC, rcPaint, pStopControl);
  
          if( m_pTwh ) {
              RECT rc;
              m_pTwh->GetControlRect(&rc);
              // Remember wparam is actually the hdc and lparam is the update
              // rect because this message has been preprocessed by the window.
              m_pTwh->GetTextServices()->TxDraw(
                  DVASPECT_CONTENT,       // Draw Aspect
                  /*-1*/0,                // Lindex
                  NULL,                   // Info for drawing optimazation
                  NULL,                   // target device information
                  hDC,                    // Draw device HDC
                  NULL,                   // Target device HDC
                  (RECTL *)&rc,           // Bounding client rectangle
                  NULL,                   // Clipping rectangle for metafiles
                  (RECT *)&rcPaint,       // Update rectangle
                  NULL,                   // Call back function
                  NULL,                   // Call back parameter
                  0);                     // What view of the object
  
              if( m_bVScrollBarFixing ) {
                  LONG lWidth = rc.right - rc.left + m_pVerticalScrollBar->GetFixedWidth();
                  LONG lHeight = 0;
                  SIZEL szExtent = { -1, -1 };
                  m_pTwh->GetTextServices()->TxGetNaturalSize(
                      DVASPECT_CONTENT,
                      GetManager()->GetPaintDC(),
                      NULL,
                      NULL,
                      TXTNS_FITTOCONTENT,
                      &szExtent,
                      &lWidth,
                      &lHeight);
  
                  if( lHeight <= rc.bottom - rc.top ) {
                      NeedUpdate();
                  }
              }
          }
  
          if( m_items.GetSize() > 0 ) {
              RECT rc = m_rcItem;
              rc.left += m_rcInset.left;
              rc.top += m_rcInset.top;
              rc.right -= m_rcInset.right;
              rc.bottom -= m_rcInset.bottom;
  
              if( m_pVerticalScrollBar && m_pVerticalScrollBar->IsVisible() ) rc.right -= m_pVerticalScrollBar->GetFixedWidth();
  
              if( m_pHorizontalScrollBar && m_pHorizontalScrollBar->IsVisible() ) rc.bottom -= m_pHorizontalScrollBar->GetFixedHeight();
  
              if( !::IntersectRect(&rcTemp, &rcPaint, &rc) ) {
                  for( int it = 0; it < m_items.GetSize(); it++ ) {
                      CControlUI *pControl = static_cast<CControlUI *>(m_items[it]);
  
                      if( pControl == pStopControl ) return false;
  
                      if( !pControl->IsVisible() ) continue;
  
                      if( !::IntersectRect(&rcTemp, &rcPaint, &pControl->GetPos()) ) continue;
  
                      if( pControl->IsFloat() ) {
                          if( !::IntersectRect(&rcTemp, &m_rcItem, &pControl->GetPos()) ) continue;
  
                          if( !pControl->Paint(hDC, rcPaint, pStopControl) ) return false;
                      }
                  }
              } else {
                  CRenderClip childClip;
                  CRenderClip::GenerateClip(hDC, rcTemp, childClip);
  
                  for( int it = 0; it < m_items.GetSize(); it++ ) {
                      CControlUI *pControl = static_cast<CControlUI *>(m_items[it]);
  
                      if( pControl == pStopControl ) return false;
  
                      if( !pControl->IsVisible() ) continue;
  
                      if( !::IntersectRect(&rcTemp, &rcPaint, &pControl->GetPos()) ) continue;
  
                      if( pControl->IsFloat() ) {
                          if( !::IntersectRect(&rcTemp, &m_rcItem, &pControl->GetPos()) ) continue;
  
                          CRenderClip::UseOldClipBegin(hDC, childClip);
  
                          if( !pControl->Paint(hDC, rcPaint, pStopControl) ) return false;
  
                          CRenderClip::UseOldClipEnd(hDC, childClip);
                      } else {
                          if( !::IntersectRect(&rcTemp, &rc, &pControl->GetPos()) ) continue;
  
                          if( !pControl->Paint(hDC, rcPaint, pStopControl) ) return false;
                      }
                  }
              }
          }
  
          if( m_pTwh && m_pTwh->IsShowCaret() && m_pManager->IsLayered() && IsFocused() && m_bDrawCaret ) {
              POINT ptCaret;
              ::GetCaretPos(&ptCaret);
  
              if( ::PtInRect(&m_rcItem, ptCaret) ) {
                  RECT rcCaret = { ptCaret.x, ptCaret.y, ptCaret.x, ptCaret.y + m_pTwh->GetCaretHeight() };
                  CRenderEngine::DrawLine(hDC, rcCaret, m_pTwh->GetCaretWidth(), 0xFF000000);
              }
          }
  
          if( m_pVerticalScrollBar != NULL ) {
              if( m_pVerticalScrollBar == pStopControl ) return false;
  
              if (m_pVerticalScrollBar->IsVisible()) {
                  if( ::IntersectRect(&rcTemp, &rcPaint, &m_pVerticalScrollBar->GetPos()) ) {
                      if( !m_pVerticalScrollBar->Paint(hDC, rcPaint, pStopControl) ) return false;
                  }
              }
          }
  
          if( m_pHorizontalScrollBar != NULL ) {
              if( m_pHorizontalScrollBar == pStopControl ) return false;
  
              if (m_pHorizontalScrollBar->IsVisible()) {
                  if( ::IntersectRect(&rcTemp, &rcPaint, &m_pHorizontalScrollBar->GetPos()) ) {
                      if( !m_pHorizontalScrollBar->Paint(hDC, rcPaint, pStopControl) ) return false;
                  }
              }
          }
  
          // 绘制提示文字
          CDuiString sDrawText = GetText();
  
          if(sDrawText.IsEmpty() && !m_bFocused) {
              DWORD dwTextColor = GetTipValueColor();
              CDuiString sTipValue = GetTipValue();
              RECT rc = m_rcItem;
              rc.left += m_rcTextPadding.left;
              rc.right -= m_rcTextPadding.right;
              rc.top += m_rcTextPadding.top;
              rc.bottom -= m_rcTextPadding.bottom;
              UINT uTextAlign = GetTipValueAlign();
  
              if(IsMultiLine()) uTextAlign |= DT_TOP;
              else uTextAlign |= DT_VCENTER;
  
              CRenderEngine::DrawText(hDC, m_pManager, rc, sTipValue, dwTextColor, m_iFont, uTextAlign);
          }
  
          return true;
      }
  
      LPCTSTR CRichEditUI::GetNormalImage() {
          return m_sNormalImage;
      }
  
      void CRichEditUI::SetNormalImage(LPCTSTR pStrImage) {
          m_sNormalImage = pStrImage;
          Invalidate();
      }
  
      LPCTSTR CRichEditUI::GetHotImage() {
          return m_sHotImage;
      }
  
      void CRichEditUI::SetHotImage(LPCTSTR pStrImage) {
          m_sHotImage = pStrImage;
          Invalidate();
      }
  
      LPCTSTR CRichEditUI::GetFocusedImage() {
          return m_sFocusedImage;
      }
  
      void CRichEditUI::SetFocusedImage(LPCTSTR pStrImage) {
          m_sFocusedImage = pStrImage;
          Invalidate();
      }
  
      LPCTSTR CRichEditUI::GetDisabledImage() {
          return m_sDisabledImage;
      }
  
      void CRichEditUI::SetDisabledImage(LPCTSTR pStrImage) {
          m_sDisabledImage = pStrImage;
          Invalidate();
      }
  
      RECT CRichEditUI::GetTextPadding() const {
          return m_rcTextPadding;
      }
  
      void CRichEditUI::SetTextPadding(RECT rc) {
          m_rcTextPadding = rc;
          Invalidate();
      }
  
      void CRichEditUI::SetTipValue( LPCTSTR pStrTipValue ) {
          m_sTipValue = pStrTipValue;
      }
  
      LPCTSTR CRichEditUI::GetTipValue() {
          return m_sTipValue;
      }
  
      void CRichEditUI::SetTipValueColor( LPCTSTR pStrColor ) {
          if( *pStrColor == _T('#')) pStrColor = ::CharNext(pStrColor);
  
          LPTSTR pstr = NULL;
          DWORD clrColor = _tcstoul(pStrColor, &pstr, 16);
  
          m_dwTipValueColor = clrColor;
      }
  
      DWORD CRichEditUI::GetTipValueColor() {
          return m_dwTipValueColor;
      }
  
      void CRichEditUI::SetTipValueAlign(UINT uAlign) {
          m_uTipValueAlign = uAlign;
  
          if(GetText().IsEmpty()) Invalidate();
      }
  
      UINT CRichEditUI::GetTipValueAlign() {
          return m_uTipValueAlign;
      }
  
      void CRichEditUI::PaintStatusImage(HDC hDC) {
          if( IsFocused() ) m_uButtonState |= UISTATE_FOCUSED;
          else m_uButtonState &= ~ UISTATE_FOCUSED;
  
          if( !IsEnabled() ) m_uButtonState |= UISTATE_DISABLED;
          else m_uButtonState &= ~ UISTATE_DISABLED;
  
          if( (m_uButtonState & UISTATE_DISABLED) != 0 ) {
              if( !m_sDisabledImage.IsEmpty() ) {
                  if( !DrawImage(hDC, (LPCTSTR)m_sDisabledImage) ) {}
                  else return;
              }
          } else if( (m_uButtonState & UISTATE_FOCUSED) != 0 ) {
              if( !m_sFocusedImage.IsEmpty() ) {
                  if( !DrawImage(hDC, (LPCTSTR)m_sFocusedImage) ) {}
                  else return;
              }
          } else if( (m_uButtonState & UISTATE_HOT ) != 0 ) {
              if( !m_sHotImage.IsEmpty() ) {
                  if( !DrawImage(hDC, (LPCTSTR)m_sHotImage) ) {}
                  else return;
              }
          }
  
          if( !m_sNormalImage.IsEmpty() ) {
              if( !DrawImage(hDC, (LPCTSTR)m_sNormalImage) ) {}
              else return;
          }
      }
  
      void CRichEditUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue) {
          if( _tcscmp(pstrName, _T("vscrollbar")) == 0 ) {
              if( _tcscmp(pstrValue, _T("true")) == 0 ) 
                  m_lTwhStyle |= ES_DISABLENOSCROLL | WS_VSCROLL;
          }
          else if( _tcscmp(pstrName, _T("autovscroll")) == 0 ) {
              if( _tcscmp(pstrValue, _T("true")) == 0 ) 
                  m_lTwhStyle |= ES_AUTOVSCROLL;
          } 
          else if( _tcscmp(pstrName, _T("hscrollbar")) == 0 ) {
              if( _tcscmp(pstrValue, _T("true")) == 0 ) 
                  m_lTwhStyle |= ES_DISABLENOSCROLL | WS_HSCROLL;
          }
          else if( _tcscmp(pstrName, _T("autohscroll")) == 0 ) {
              if( _tcscmp(pstrValue, _T("true")) == 0 ) 
                  m_lTwhStyle |= ES_AUTOHSCROLL;
          } 
          else if( _tcsicmp(pstrName, _T("multiline")) == 0 ) {
              SetMultiLine(_tcscmp(pstrValue, _T("true")) == 0);
          } 
          else if( _tcscmp(pstrName, _T("wanttab")) == 0 ) {
              SetWantTab(_tcscmp(pstrValue, _T("true")) == 0);
          } 
          else if( _tcscmp(pstrName, _T("wantreturn")) == 0 ) {
              SetWantReturn(_tcscmp(pstrValue, _T("true")) == 0);
          } 
          else if( _tcscmp(pstrName, _T("wantctrlreturn")) == 0 ) {
              SetWantCtrlReturn(_tcscmp(pstrValue, _T("true")) == 0);
          } 
          else if( _tcscmp(pstrName, _T("transparent")) == 0 ) {
              SetTransparent(_tcscmp(pstrValue, _T("true")) == 0);
          } 
          else if( _tcscmp(pstrName, _T("rich")) == 0 ) {
              SetRich(_tcscmp(pstrValue, _T("true")) == 0);
          } 
          else if( _tcscmp(pstrName, _T("multiline")) == 0 ) {
              if( _tcscmp(pstrValue, _T("false")) == 0 ) m_lTwhStyle &= ~ES_MULTILINE;
          }
          else if( _tcscmp(pstrName, _T("readonly")) == 0 ) {
              if( _tcscmp(pstrValue, _T("true")) == 0 ) {
                  m_lTwhStyle |= ES_READONLY;
                  m_bReadOnly = true;
              }
          } 
          else if( _tcscmp(pstrName, _T("password")) == 0 ) {
              if( _tcscmp(pstrValue, _T("true")) == 0 ) m_lTwhStyle |= ES_PASSWORD;
          } 
          else if( _tcscmp(pstrName, _T("align")) == 0 ) {
              if( _tcsstr(pstrValue, _T("left")) != NULL ) {
                  m_lTwhStyle &= ~(ES_CENTER | ES_RIGHT);
                  m_lTwhStyle |= ES_LEFT;
              }
  
              if( _tcsstr(pstrValue, _T("center")) != NULL ) {
                  m_lTwhStyle &= ~(ES_LEFT | ES_RIGHT);
                  m_lTwhStyle |= ES_CENTER;
              }
  
              if( _tcsstr(pstrValue, _T("right")) != NULL ) {
                  m_lTwhStyle &= ~(ES_LEFT | ES_CENTER);
                  m_lTwhStyle |= ES_RIGHT;
              }
          } 
          else if( _tcscmp(pstrName, _T("font")) == 0 ) 
              SetFont(_ttoi(pstrValue));
          else if( _tcscmp(pstrName, _T("textcolor")) == 0 ) {
              while( *pstrValue > _T('\0') && *pstrValue <= _T(' ') ) pstrValue = ::CharNext(pstrValue);
  
              if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
  
              LPTSTR pstr = NULL;
              DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
              SetTextColor(clrColor);
          } 
          else if( _tcsicmp(pstrName, _T("maxchar")) == 0 ) 
              SetLimitText(_ttoi(pstrValue));
          else if( _tcsicmp(pstrName, _T("normalimage")) == 0 )
              SetNormalImage(pstrValue);
          else if( _tcsicmp(pstrName, _T("hotimage")) == 0 )
              SetHotImage(pstrValue);
          else if( _tcsicmp(pstrName, _T("focusedimage")) == 0 )
              SetFocusedImage(pstrValue);
          else if( _tcsicmp(pstrName, _T("disabledimage")) == 0 )
              SetDisabledImage(pstrValue);
          else if( _tcsicmp(pstrName, _T("textpadding")) == 0 ) {
              RECT rcTextPadding = { 0 };
              LPTSTR pstr = NULL;
              rcTextPadding.left = _tcstol(pstrValue, &pstr, 10);
              ASSERT(pstr);
              rcTextPadding.top = _tcstol(pstr + 1, &pstr, 10);
              ASSERT(pstr);
              rcTextPadding.right = _tcstol(pstr + 1, &pstr, 10);
              ASSERT(pstr);
              rcTextPadding.bottom = _tcstol(pstr + 1, &pstr, 10);
              ASSERT(pstr);
              SetTextPadding(rcTextPadding);
          } 
          else if( _tcsicmp(pstrName, _T("tipvalue")) == 0 ) 
              SetTipValue(pstrValue);
          else if( _tcsicmp(pstrName, _T("tipvaluecolor")) == 0 ) 
              SetTipValueColor(pstrValue);
          else if( _tcsicmp(pstrName, _T("tipvaluealign")) == 0 ) {
              if( _tcsstr(pstrValue, _T("left")) != NULL ) {
                  m_uTipValueAlign = DT_SINGLELINE | DT_LEFT;
              }
  
              if( _tcsstr(pstrValue, _T("center")) != NULL ) {
                  m_uTipValueAlign = DT_SINGLELINE | DT_CENTER;
              }
  
              if( _tcsstr(pstrValue, _T("right")) != NULL ) {
                  m_uTipValueAlign = DT_SINGLELINE | DT_RIGHT;
              }
          }
          else {
              CContainerUI::SetAttribute(pstrName, pstrValue);
          }
      }
  
      LRESULT CRichEditUI::MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, bool &bHandled) {
          if( !IsVisible() || !IsEnabled() ) return 0;
  
          if( !IsMouseEnabled() && uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST ) return 0;
  
          if( uMsg == WM_MOUSEWHEEL && (LOWORD(wParam) & MK_CONTROL) == 0 ) return 0;
  
          if (uMsg == WM_IME_COMPOSITION) {
              // 解决微软输入法位置异常的问题
              HIMC hIMC = ImmGetContext(GetManager()->GetPaintWindow());
  
              if (hIMC)  {
                  POINT point;
                  GetCaretPos(&point);
  
                  COMPOSITIONFORM Composition;
                  Composition.dwStyle = CFS_POINT;
                  Composition.ptCurrentPos.x = point.x;
                  Composition.ptCurrentPos.y = point.y;
                  ImmSetCompositionWindow(hIMC, &Composition);
  
                  ImmReleaseContext(GetManager()->GetPaintWindow(), hIMC);
              }
  
              return 0;
          }
  
          bool bWasHandled = true;
  
          if( (uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST) || uMsg == WM_SETCURSOR ) {
              if( !m_pTwh->IsCaptured() ) {
                  switch (uMsg) {
                      case WM_LBUTTONDOWN:
                      case WM_LBUTTONUP:
                      case WM_LBUTTONDBLCLK:
                      case WM_RBUTTONDOWN:
                      case WM_RBUTTONUP: {
                              POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
                              CControlUI *pHover = GetManager()->FindControl(pt);
  
                              if(pHover != this) {
                                  bWasHandled = false;
                                  return 0;
                              }
                          }
                          break;
                  }
              }
  
              // Mouse message only go when captured or inside rect
              DWORD dwHitResult = m_pTwh->IsCaptured() ? HITRESULT_HIT : HITRESULT_OUTSIDE;
  
              if( dwHitResult == HITRESULT_OUTSIDE ) {
                  RECT rc;
                  m_pTwh->GetControlRect(&rc);
                  POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
  
                  if( uMsg == WM_SETCURSOR ) {
                      ::GetCursorPos(&pt);
                      ::ScreenToClient(GetManager()->GetPaintWindow(), &pt);
                  } else if( uMsg == WM_MOUSEWHEEL ) ::ScreenToClient(GetManager()->GetPaintWindow(), &pt);
  
                  if( ::PtInRect(&rc, pt) && !GetManager()->IsCaptured() ) dwHitResult = HITRESULT_HIT;
              }
  
              if( dwHitResult != HITRESULT_HIT ) return 0;
  
              if( uMsg == WM_SETCURSOR ) bWasHandled = false;
              else if( uMsg == WM_LBUTTONDOWN || uMsg == WM_LBUTTONDBLCLK || uMsg == WM_RBUTTONDOWN ) {
                  if (!GetManager()->IsNoActivate()) ::SetFocus(GetManager()->GetPaintWindow());
  
                  SetFocus();
              }
          }
  
  #ifdef _UNICODE
          else if( uMsg >= WM_KEYFIRST && uMsg <= WM_KEYLAST ) {
  #else
          else if( (uMsg >= WM_KEYFIRST && uMsg <= WM_KEYLAST) || uMsg == WM_CHAR || uMsg == WM_IME_CHAR ) {
  #endif
  
              if( !IsFocused() ) return 0;
          }
  
  #ifdef _USEIMM
          else if( uMsg == WM_IME_STARTCOMPOSITION ) {
              if( IsFocused() ) {
                  POINT ptCaret;
                  ::GetCaretPos(&ptCaret);
                  HIMC hMic = ::ImmGetContext(GetManager()->GetPaintWindow());
                  COMPOSITIONFORM cpf;
                  cpf.dwStyle = CFS_FORCE_POSITION;
                  cpf.ptCurrentPos.x = ptCaret.x + m_pTwh->GetCaretWidth();
                  cpf.ptCurrentPos.y = ptCaret.y;
                  ::ImmSetCompositionWindow(hMic, &cpf);
  
                  HFONT hFont = GetManager()->GetFont(m_iFont);
                  LOGFONT lf;
                  ::GetObject(hFont, sizeof(LOGFONT), &lf);
                  ::ImmSetCompositionFont(hMic, &lf);
  
                  ::ImmReleaseContext(GetManager()->GetPaintWindow(), hMic);
              }
  
              bWasHandled = false;
              return 0;
          }
  
  #endif
          else if( uMsg == WM_CONTEXTMENU ) {
              POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
              ::ScreenToClient(GetManager()->GetPaintWindow(), &pt);
              CControlUI *pHover = GetManager()->FindControl(pt);
  
              if(pHover != this) {
                  bWasHandled = false;
                  return 0;
              }
  
              //创建一个弹出式菜单
              HMENU hPopMenu = CreatePopupMenu();
              AppendMenu(hPopMenu, 0, ID_RICH_UNDO, _T("撤销(&U)"));
              AppendMenu(hPopMenu, 0, ID_RICH_REDO, _T("重做(&R)"));
              AppendMenu(hPopMenu, MF_SEPARATOR, 0, _T(""));
              AppendMenu(hPopMenu, 0, ID_RICH_CUT, _T("剪切(&X)"));
              AppendMenu(hPopMenu, 0, ID_RICH_COPY, _T("复制(&C)"));
              AppendMenu(hPopMenu, 0, ID_RICH_PASTE, _T("粘帖(&V)"));
              AppendMenu(hPopMenu, 0, ID_RICH_CLEAR, _T("清空(&L)"));
              AppendMenu(hPopMenu, MF_SEPARATOR, 0, _T(""));
              AppendMenu(hPopMenu, 0, ID_RICH_SELECTALL, _T("全选(&A)"));
  
              //初始化菜单项
              UINT uUndo = (CanUndo() ? 0 : MF_GRAYED);
              EnableMenuItem(hPopMenu, ID_RICH_UNDO, MF_BYCOMMAND | uUndo);
              UINT uRedo = (CanRedo() ? 0 : MF_GRAYED);
              EnableMenuItem(hPopMenu, ID_RICH_REDO, MF_BYCOMMAND | uRedo);
              UINT uSel = ((GetSelectionType() != SEL_EMPTY) ? 0 : MF_GRAYED);
              UINT uReadonly = IsReadOnly() ? MF_GRAYED : 0;
              EnableMenuItem(hPopMenu, ID_RICH_CUT, MF_BYCOMMAND | uSel | uReadonly);
              EnableMenuItem(hPopMenu, ID_RICH_COPY, MF_BYCOMMAND | uSel);
              EnableMenuItem(hPopMenu, ID_RICH_CLEAR, MF_BYCOMMAND | uSel | uReadonly);
              EnableMenuItem(hPopMenu, ID_RICH_PASTE, MF_BYCOMMAND | uReadonly);
              ::ClientToScreen(GetManager()->GetPaintWindow(), &pt);
              TrackPopupMenu(hPopMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, GetManager()->GetPaintWindow(), NULL);
              DestroyMenu(hPopMenu);
          } else if( uMsg == WM_COMMAND ) {
              bHandled = FALSE;
  
              if( !IsFocused() ) return 0;
  
              UINT uCmd = (UINT)wParam;
  
              switch(uCmd) {
                  case ID_RICH_UNDO: {
                          Undo();
                          break;
                      }
  
                  case ID_RICH_REDO: {
                          Redo();
                          break;
                      }
  
                  case ID_RICH_CUT: {
                          Cut();
                          break;
                      }
  
                  case ID_RICH_COPY: {
                          Copy();
                          break;
                      }
  
                  case ID_RICH_PASTE: {
                          Paste();
                          break;
                      }
  
                  case ID_RICH_CLEAR: {
                          Clear();
                          break;
                      }
  
                  case ID_RICH_SELECTALL: {
                          SetSelAll();
                          break;
                      }
  
                  default:
                      break;
              }
          } else {
              switch( uMsg ) {
                  case WM_HELP:
                      bWasHandled = false;
                      break;
  
                  default:
                      return 0;
              }
          }
  
          if(WM_CHAR == uMsg) {
  #ifndef _UNICODE
  
              // check if we are waiting for 2 consecutive WM_CHAR messages
              if ( IsAccumulateDBCMode() ) {
                  if ( (GetKeyState(VK_KANA) & 0x1) ) {
                      // turn off accumulate mode
                      SetAccumulateDBCMode ( false );
                      m_chLeadByte = 0;
                  } else {
                      if ( !m_chLeadByte ) {
                          // This is the first WM_CHAR message,
                          // accumulate it if this is a LeadByte.  Otherwise, fall thru to
                          // regular WM_CHAR processing.
                          if ( IsDBCSLeadByte ( (WORD)wParam ) ) {
                              // save the Lead Byte and don't process this message
                              m_chLeadByte = (WORD)wParam << 8 ;
  
                              //TCHAR a = (WORD)wParam << 8 ;
                              return 0;
                          }
                      } else {
                          // This is the second WM_CHAR message,
                          // combine the current byte with previous byte.
                          // This DBC will be handled as WM_IME_CHAR.
                          wParam |= m_chLeadByte;
                          uMsg = WM_IME_CHAR;
  
                          // setup to accumulate more WM_CHAR
                          m_chLeadByte = 0;
                      }
                  }
              }
  
  #endif
          }
  
          LRESULT lResult = 0;
          HRESULT Hr = TxSendMessage(uMsg, wParam, lParam, &lResult);
  
          if( Hr == S_OK ) bHandled = bWasHandled;
          else if( (uMsg >= WM_KEYFIRST && uMsg <= WM_KEYLAST) || uMsg == WM_CHAR || uMsg == WM_IME_CHAR )
              bHandled = bWasHandled;
          else if( uMsg >= WM_MOUSEFIRST && uMsg <= WM_MOUSELAST ) {
              if( m_pTwh->IsCaptured() ) bHandled = bWasHandled;
          }
  
          return lResult;
      }
  
  } // namespace DuiLib
  