IFWL method and param cleanup

xfa/fwl/core/ifwl_edit.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fwl/core/ifwl_edit.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 44 matching lines @@
 IFWL_Edit::IFWL_Edit(const IFWL_App* app,
                      std::unique_ptr<CFWL_WidgetProperties> properties,
                      IFWL_Widget* pOuter)
     : IFWL_Widget(app, std::move(properties), pOuter),
       m_fVAlignOffset(0.0f),
       m_fScrollOffsetX(0.0f),
       m_fScrollOffsetY(0.0f),
       m_bLButtonDown(false),
       m_nSelStart(0),
       m_nLimit(-1),
-      m_fSpaceAbove(0),
-      m_fSpaceBelow(0),
       m_fFontSize(0),
       m_bSetRange(false),
-      m_iMin(-1),
       m_iMax(0xFFFFFFF),
-      m_backColor(0),
-      m_updateBackColor(false),
       m_iCurRecord(-1),
       m_iMaxRecord(128) {
   m_rtClient.Reset();
   m_rtEngine.Reset();
   m_rtStatic.Reset();
 
   InitCaret();
-  if (!m_pEdtEngine)
-    InitEngine();
 }
 
 IFWL_Edit::~IFWL_Edit() {
   if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused)
     ShowCaret(false);
 
   ClearRecord();
 }
 
 FWL_Type IFWL_Edit::GetClassID() const {
   return FWL_Type::Edit;
 }
 
 void IFWL_Edit::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
   if (bAutoSize) {
     rect.Set(0, 0, 0, 0);
-    if (m_pEdtEngine) {
-      int32_t iTextLen = m_pEdtEngine->GetTextLength();
-      if (iTextLen > 0) {
-        CFX_WideString wsText;
-        m_pEdtEngine->GetText(wsText, 0);
-        CFX_SizeF sz = CalcTextSize(
-            wsText, m_pProperties->m_pThemeProvider,
-            !!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine));
-        rect.Set(0, 0, sz.x, sz.y);
-      }
+
+    int32_t iTextLen = m_EdtEngine.GetTextLength();
+    if (iTextLen > 0) {
+      CFX_WideString wsText;
+      m_EdtEngine.GetText(wsText, 0);
+      CFX_SizeF sz = CalcTextSize(
+          wsText, m_pProperties->m_pThemeProvider,
+          !!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine));
+      rect.Set(0, 0, sz.x, sz.y);
     }
     IFWL_Widget::GetWidgetRect(rect, true);
   } else {
     rect = m_pProperties->m_rtWidget;
     if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
       if (IsShowScrollBar(true)) {
         FX_FLOAT* pfWidth = static_cast<FX_FLOAT*>(
             GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
         rect.width += *pfWidth;
         rect.width += kEditMargin;
@@ skipping 55 matching lines @@
 
 void IFWL_Edit::AddSpellCheckObj(CFX_Path& PathData,
                                  int32_t nStart,
                                  int32_t nCount,
                                  FX_FLOAT fOffSetX,
                                  FX_FLOAT fOffSetY) {
   FX_FLOAT fStartX = 0.0f;
   FX_FLOAT fEndX = 0.0f;
   FX_FLOAT fY = 0.0f;
   FX_FLOAT fStep = 0.0f;
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   CFX_RectFArray rectArray;
   CFX_RectF rectText;
-  const FDE_TXTEDTPARAMS* txtEdtParams = m_pEdtEngine->GetEditParams();
+  const FDE_TXTEDTPARAMS* txtEdtParams = m_EdtEngine.GetEditParams();
   FX_FLOAT fAsent = (FX_FLOAT)txtEdtParams->pFont->GetAscent() *
                     txtEdtParams->fFontSize / 1000;
   pPage->CalcRangeRectArray(nStart, nCount, rectArray);
   for (int i = 0; i < rectArray.GetSize(); i++) {
     rectText = rectArray.GetAt(i);
     fY = rectText.top + fAsent + fOffSetY;
     fStep = txtEdtParams->fFontSize / 16.0f;
     fStartX = rectText.left + fOffSetX;
     fEndX = fStartX + rectText.Width();
     AddSquigglyPath(&PathData, fStartX, fEndX, fY, fStep);
   }
 }
-int32_t IFWL_Edit::GetWordAtPoint(CFX_PointF pointf, int32_t& nCount) {
-  return 0;
-}
-bool IFWL_Edit::GetSuggestWords(CFX_PointF pointf,
-                                std::vector<CFX_ByteString>& sSuggest) {
-  int32_t nWordCount = 0;
-  int32_t nWordStart = GetWordAtPoint(pointf, nWordCount);
-  if (nWordCount < 1) {
-    return false;
-  }
-  CFX_WideString wsSpell;
-  GetText(wsSpell, nWordStart, nWordCount);
-  CFX_ByteString sLatinWord;
-  for (int i = 0; i < nWordCount; i++) {
-    if (!FX_EDIT_ISLATINWORD(wsSpell[i])) {
-      break;
-    }
-    sLatinWord += (FX_CHAR)wsSpell[i];
-  }
-  if (sLatinWord.IsEmpty()) {
-    return false;
-  }
-  CFWL_EvtEdtCheckWord checkWordEvent;
-  checkWordEvent.m_pSrcTarget = this;
-  checkWordEvent.bsWord = sLatinWord;
-  checkWordEvent.bCheckWord = true;
-  DispatchEvent(&checkWordEvent);
-  if (checkWordEvent.bCheckWord) {
-    return false;
-  }
-  CFWL_EvtEdtGetSuggestWords suggestWordsEvent;
-  suggestWordsEvent.m_pSrcTarget = this;
-  suggestWordsEvent.bsWord = sLatinWord;
-  suggestWordsEvent.bsArraySuggestWords = sSuggest;
-  suggestWordsEvent.bSuggestWords = false;
-  DispatchEvent(&checkWordEvent);
-  return suggestWordsEvent.bSuggestWords;
-}
-bool IFWL_Edit::ReplaceSpellCheckWord(CFX_PointF pointf,
-                                      const CFX_ByteStringC& bsReplace) {
-  int32_t nWordCount = 0;
-  int32_t nWordStart = GetWordAtPoint(pointf, nWordCount);
-  if (nWordCount < 1) {
-    return false;
-  }
-  CFX_WideString wsSpell;
-  GetText(wsSpell, nWordStart, nWordCount);
-  for (int i = 0; i < nWordCount; i++) {
-    if (!FX_EDIT_ISLATINWORD(wsSpell[i])) {
-      nWordCount = i;
-      break;
-    }
-  }
-  int32_t nDestLen = bsReplace.GetLength();
-  CFX_WideString wsDest;
-  FX_WCHAR* pBuffer = wsDest.GetBuffer(nDestLen);
-  for (int32_t i = 0; i < nDestLen; i++) {
-    pBuffer[i] = bsReplace[i];
-  }
-  wsDest.ReleaseBuffer(nDestLen);
-  Replace(nWordStart, nWordCount, wsDest.AsStringC());
-  return true;
-}
 void IFWL_Edit::DrawSpellCheck(CFX_Graphics* pGraphics,
                                const CFX_Matrix* pMatrix) {
   pGraphics->SaveGraphState();
   if (pMatrix) {
     pGraphics->ConcatMatrix(const_cast<CFX_Matrix*>(pMatrix));
   }
   FX_ARGB cr = 0xFFFF0000;
   CFX_Color crLine(cr);
   CFWL_EvtEdtCheckWord checkWordEvent;
   checkWordEvent.m_pSrcTarget = this;
@@ skipping 50 matching lines @@
     return;
   if (!m_pProperties->m_pThemeProvider)
     return;
   if (m_rtClient.IsEmpty()) {
     return;
   }
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
   if (!m_pWidgetMgr->IsFormDisabled()) {
     DrawTextBk(pGraphics, pTheme, pMatrix);
   }
-  if (m_pEdtEngine) {
-    DrawContent(pGraphics, pTheme, pMatrix);
-  }
+
+  DrawContent(pGraphics, pTheme, pMatrix);
+
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) &&
       !(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly)) {
     DrawSpellCheck(pGraphics, pMatrix);
   }
   if (HasBorder()) {
     DrawBorder(pGraphics, CFWL_Part::Border, pTheme, pMatrix);
   }
   if (HasEdge()) {
     DrawEdge(pGraphics, CFWL_Part::Edge, pTheme, pMatrix);
   }
 }
 void IFWL_Edit::SetThemeProvider(IFWL_ThemeProvider* pThemeProvider) {
   if (!pThemeProvider)
     return;
   if (m_pHorzScrollBar) {
     m_pHorzScrollBar->SetThemeProvider(pThemeProvider);
   }
   if (m_pVertScrollBar) {
     m_pVertScrollBar->SetThemeProvider(pThemeProvider);
   }
   if (m_pCaret) {
     m_pCaret->SetThemeProvider(pThemeProvider);
   }
   m_pProperties->m_pThemeProvider = pThemeProvider;
 }
 
-FWL_Error IFWL_Edit::SetText(const CFX_WideString& wsText) {
-  m_pEdtEngine->SetText(wsText);
-  return FWL_Error::Succeeded;
+void IFWL_Edit::SetText(const CFX_WideString& wsText) {
+  m_EdtEngine.SetText(wsText);
 }
 
 int32_t IFWL_Edit::GetTextLength() const {
-  if (!m_pEdtEngine)
-    return -1;
-  return m_pEdtEngine->GetTextLength();
+  return m_EdtEngine.GetTextLength();
 }
 
-FWL_Error IFWL_Edit::GetText(CFX_WideString& wsText,
-                             int32_t nStart,
-                             int32_t nCount) const {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  m_pEdtEngine->GetText(wsText, nStart, nCount);
-  return FWL_Error::Succeeded;
+void IFWL_Edit::GetText(CFX_WideString& wsText,
+                        int32_t nStart,
+                        int32_t nCount) {
+  m_EdtEngine.GetText(wsText, nStart, nCount);
 }
 
-FWL_Error IFWL_Edit::ClearText() {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  m_pEdtEngine->ClearText();
-  return FWL_Error::Succeeded;
+void IFWL_Edit::ClearText() {
+  m_EdtEngine.ClearText();
 }
 
-int32_t IFWL_Edit::GetCaretPos() const {
-  if (!m_pEdtEngine)
-    return -1;
-  return m_pEdtEngine->GetCaretPos();
-}
-
-int32_t IFWL_Edit::SetCaretPos(int32_t nIndex, bool bBefore) {
-  if (!m_pEdtEngine)
-    return -1;
-  return m_pEdtEngine->SetCaretPos(nIndex, bBefore);
-}
-
-FWL_Error IFWL_Edit::AddSelRange(int32_t nStart, int32_t nCount) {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  m_pEdtEngine->AddSelRange(nStart, nCount);
-  return FWL_Error::Succeeded;
+void IFWL_Edit::AddSelRange(int32_t nStart, int32_t nCount) {
+  m_EdtEngine.AddSelRange(nStart, nCount);
 }
 
 int32_t IFWL_Edit::CountSelRanges() {
-  if (!m_pEdtEngine)
-    return 0;
-  return m_pEdtEngine->CountSelRanges();
+  return m_EdtEngine.CountSelRanges();
 }
 
 int32_t IFWL_Edit::GetSelRange(int32_t nIndex, int32_t& nStart) {
-  if (!m_pEdtEngine)
-    return -1;
-  return m_pEdtEngine->GetSelRange(nIndex, nStart);
+  return m_EdtEngine.GetSelRange(nIndex, nStart);
 }
 
-FWL_Error IFWL_Edit::ClearSelections() {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  m_pEdtEngine->ClearSelection();
-  return FWL_Error::Succeeded;
+void IFWL_Edit::ClearSelections() {
+  m_EdtEngine.ClearSelection();
 }
 
 int32_t IFWL_Edit::GetLimit() {
   return m_nLimit;
 }
 
-FWL_Error IFWL_Edit::SetLimit(int32_t nLimit) {
+void IFWL_Edit::SetLimit(int32_t nLimit) {
   m_nLimit = nLimit;
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  m_pEdtEngine->SetLimit(nLimit);
-  return FWL_Error::Succeeded;
+  m_EdtEngine.SetLimit(nLimit);
 }
 
-FWL_Error IFWL_Edit::SetAliasChar(FX_WCHAR wAlias) {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  m_pEdtEngine->SetAliasChar(wAlias);
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Edit::Insert(int32_t nStart,
-                            const FX_WCHAR* lpText,
-                            int32_t nLen) {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly) ||
-      (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
-    return FWL_Error::Indefinite;
-  }
-  m_pEdtEngine->Insert(nStart, lpText, nLen);
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Edit::DeleteSelections() {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  int32_t iCount = m_pEdtEngine->CountSelRanges();
-  if (iCount > 0)
-    m_pEdtEngine->Delete(-1);
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Edit::DeleteRange(int32_t nStart, int32_t nCount) {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  m_pEdtEngine->DeleteRange(nStart, nCount);
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Edit::Replace(int32_t nStart,
-                             int32_t nLen,
-                             const CFX_WideStringC& wsReplace) {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  m_pEdtEngine->Replace(nStart, nLen, CFX_WideString(wsReplace));
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Edit::DoClipboard(int32_t iCmd) {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly) ||
-      (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
-    return FWL_Error::Succeeded;
-  }
-  return FWL_Error::Indefinite;
+void IFWL_Edit::SetAliasChar(FX_WCHAR wAlias) {
+  m_EdtEngine.SetAliasChar(wAlias);
 }
 
 bool IFWL_Edit::Copy(CFX_WideString& wsCopy) {
-  if (!m_pEdtEngine)
-    return false;
-
-  int32_t nCount = m_pEdtEngine->CountSelRanges();
+  int32_t nCount = m_EdtEngine.CountSelRanges();
   if (nCount == 0)
     return false;
 
   wsCopy.clear();
   CFX_WideString wsTemp;
   int32_t nStart, nLength;
   for (int32_t i = 0; i < nCount; i++) {
-    nLength = m_pEdtEngine->GetSelRange(i, nStart);
-    m_pEdtEngine->GetText(wsTemp, nStart, nLength);
+    nLength = m_EdtEngine.GetSelRange(i, nStart);
+    m_EdtEngine.GetText(wsTemp, nStart, nLength);
     wsCopy += wsTemp;
     wsTemp.clear();
   }
   return true;
 }
 
 bool IFWL_Edit::Cut(CFX_WideString& wsCut) {
-  if (!m_pEdtEngine)
-    return false;
-
-  int32_t nCount = m_pEdtEngine->CountSelRanges();
+  int32_t nCount = m_EdtEngine.CountSelRanges();
   if (nCount == 0)
     return false;
 
   wsCut.clear();
   CFX_WideString wsTemp;
   int32_t nStart, nLength;
   for (int32_t i = 0; i < nCount; i++) {
-    nLength = m_pEdtEngine->GetSelRange(i, nStart);
-    m_pEdtEngine->GetText(wsTemp, nStart, nLength);
+    nLength = m_EdtEngine.GetSelRange(i, nStart);
+    m_EdtEngine.GetText(wsTemp, nStart, nLength);
     wsCut += wsTemp;
     wsTemp.clear();
   }
-  m_pEdtEngine->Delete(0);
+  m_EdtEngine.Delete(0);
   return true;
 }
 
 bool IFWL_Edit::Paste(const CFX_WideString& wsPaste) {
-  if (!m_pEdtEngine)
-    return false;
-
-  int32_t nCaret = m_pEdtEngine->GetCaretPos();
+  int32_t nCaret = m_EdtEngine.GetCaretPos();
   int32_t iError =
-      m_pEdtEngine->Insert(nCaret, wsPaste.c_str(), wsPaste.GetLength());
+      m_EdtEngine.Insert(nCaret, wsPaste.c_str(), wsPaste.GetLength());
   if (iError < 0) {
     ProcessInsertError(iError);
     return false;
   }
   return true;
 }
 
-bool IFWL_Edit::Delete() {
-  if (!m_pEdtEngine)
-    return false;
-
-  int32_t nCount = m_pEdtEngine->CountSelRanges();
-  if (nCount < 1)
-    return false;
-
-  m_pEdtEngine->Delete(0);
-  return true;
-}
-
 bool IFWL_Edit::Redo(const IFDE_TxtEdtDoRecord* pRecord) {
-  if (!m_pEdtEngine)
-    return false;
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_NoRedoUndo)
     return true;
-  return m_pEdtEngine->Redo(pRecord);
+  return m_EdtEngine.Redo(pRecord);
 }
 
 bool IFWL_Edit::Undo(const IFDE_TxtEdtDoRecord* pRecord) {
-  if (!m_pEdtEngine)
-    return false;
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_NoRedoUndo)
     return true;
-  return m_pEdtEngine->Undo(pRecord);
+  return m_EdtEngine.Undo(pRecord);
 }
 
 bool IFWL_Edit::Undo() {
   if (!CanUndo())
     return false;
   return Undo(m_DoRecords[m_iCurRecord--].get());
 }
 
 bool IFWL_Edit::Redo() {
   if (!CanRedo())
     return false;
   return Redo(m_DoRecords[++m_iCurRecord].get());
 }
 
 bool IFWL_Edit::CanUndo() {
   return m_iCurRecord >= 0;
 }
 
 bool IFWL_Edit::CanRedo() {
   return m_iCurRecord < pdfium::CollectionSize<int32_t>(m_DoRecords) - 1;
 }
 
-FWL_Error IFWL_Edit::SetTabWidth(FX_FLOAT fTabWidth, bool bEquidistant) {
-  if (!m_pEdtEngine)
-    return FWL_Error::Indefinite;
-
-  FDE_TXTEDTPARAMS* pParams = m_pEdtEngine->GetEditParams();
-  pParams->fTabWidth = fTabWidth;
-  pParams->bTabEquidistant = bEquidistant;
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Edit::SetOuter(IFWL_Widget* pOuter) {
+void IFWL_Edit::SetOuter(IFWL_Widget* pOuter) {
   m_pOuter = pOuter;
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Edit::SetNumberRange(int32_t iMin, int32_t iMax) {
-  m_iMin = iMin;
-  m_iMax = iMax;
-  m_bSetRange = true;
-  return FWL_Error::Succeeded;
 }
 
 void IFWL_Edit::On_CaretChanged(CFDE_TxtEdtEngine* pEdit,
                                 int32_t nPage,
                                 bool bVisible) {
   if (m_rtEngine.IsEmpty())
     return;
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) == 0)
     return;
 
@@ skipping 16 matching lines @@
     Repaint(&rtInvalid);
   }
 }
 
 void IFWL_Edit::On_TextChanged(CFDE_TxtEdtEngine* pEdit,
                                FDE_TXTEDT_TEXTCHANGE_INFO& ChangeInfo) {
   uint32_t dwStyleEx = m_pProperties->m_dwStyleExes;
   if (dwStyleEx & FWL_STYLEEXT_EDT_VAlignMask)
     UpdateVAlignment();
 
-  IFDE_TxtEdtPage* page = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* page = m_EdtEngine.GetPage(0);
   FX_FLOAT fContentWidth = page->GetContentsBox().width;
   FX_FLOAT fContentHeight = page->GetContentsBox().height;
   CFX_RectF rtTemp;
   GetClientRect(rtTemp);
   bool bHSelfAdaption =
       !!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_HSelfAdaption);
   bool bVSelfAdaption =
       !!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VSelfAdaption);
   bool bNeedUpdate = false;
   if (bHSelfAdaption || bVSelfAdaption) {
@@ skipping 16 matching lines @@
           0, FWL_STYLEEXT_EDT_VSelfAdaption | FWL_STYLEEXT_EDT_AutoVScroll);
     }
     bNeedUpdate = (bHSelfAdaption && !evt.bHSelfAdaption) ||
                   (bVSelfAdaption && !evt.bVSelfAdaption);
   }
   FX_FLOAT fContentWidth1 = fContentWidth;
   FX_FLOAT fContentHeight1 = fContentHeight;
   if (bNeedUpdate) {
     UpdateEditParams();
     UpdateEditLayout();
-    IFDE_TxtEdtPage* page1 = m_pEdtEngine->GetPage(0);
+    IFDE_TxtEdtPage* page1 = m_EdtEngine.GetPage(0);
     fContentWidth1 = page1->GetContentsBox().width;
     fContentHeight1 = page1->GetContentsBox().height;
   }
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_HSelfAdaption) {
     rtTemp.width = std::max(m_pProperties->m_rtWidget.width, fContentWidth1);
     m_pProperties->m_rtWidget.width = fContentWidth1;
   }
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VSelfAdaption) {
     rtTemp.height = std::max(m_pProperties->m_rtWidget.height, fContentHeight1);
     m_pProperties->m_rtWidget.height = fContentHeight1;
@@ skipping 11 matching lines @@
 
 void IFWL_Edit::On_SelChanged(CFDE_TxtEdtEngine* pEdit) {
   CFX_RectF rtTemp;
   GetClientRect(rtTemp);
   Repaint(&rtTemp);
 }
 
 bool IFWL_Edit::On_PageLoad(CFDE_TxtEdtEngine* pEdit,
                             int32_t nPageIndex,
                             int32_t nPurpose) {
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(nPageIndex);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(nPageIndex);
   if (!pPage)
     return false;
   pPage->LoadPage(nullptr, nullptr);
   return true;
 }
 
 bool IFWL_Edit::On_PageUnload(CFDE_TxtEdtEngine* pEdit,
                               int32_t nPageIndex,
                               int32_t nPurpose) {
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(nPageIndex);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(nPageIndex);
   if (!pPage)
     return false;
   pPage->UnloadPage(nullptr);
   return true;
 }
 
 void IFWL_Edit::On_AddDoRecord(CFDE_TxtEdtEngine* pEdit,
                                IFDE_TxtEdtDoRecord* pRecord) {
   AddDoRecord(pRecord);
 }
 
 bool IFWL_Edit::On_Validate(CFDE_TxtEdtEngine* pEdit, CFX_WideString& wsText) {
   IFWL_Widget* pDst = GetOuter();
   if (!pDst) {
     pDst = this;
   }
   CFWL_EvtEdtValidate event;
   event.pDstWidget = pDst;
   event.m_pSrcTarget = this;
   event.wsInsert = wsText;
   event.bValidate = true;
   DispatchEvent(&event);
   return event.bValidate;
 }
 
-FWL_Error IFWL_Edit::SetBackgroundColor(uint32_t color) {
-  m_backColor = color;
-  m_updateBackColor = true;
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Edit::SetFont(const CFX_WideString& wsFont, FX_FLOAT fSize) {
-  m_wsFont = wsFont;
-  m_fFontSize = fSize;
-  return FWL_Error::Succeeded;
-}
-
 void IFWL_Edit::SetScrollOffset(FX_FLOAT fScrollOffset) {
   m_fScrollOffsetY = fScrollOffset;
 }
 
 void IFWL_Edit::DrawTextBk(CFX_Graphics* pGraphics,
                            IFWL_ThemeProvider* pTheme,
                            const CFX_Matrix* pMatrix) {
   CFWL_ThemeBackground param;
   param.m_pWidget = this;
   param.m_iPart = CFWL_Part::Background;
@@ skipping 19 matching lines @@
                m_rtClient.bottom() - rtScorll.height, rtScorll.height,
                rtScorll.height);
   param.m_bStaticBackground = true;
   param.m_bMaximize = true;
   param.m_rtPart = rtStatic;
   pTheme->DrawBackground(&param);
 }
 void IFWL_Edit::DrawContent(CFX_Graphics* pGraphics,
                             IFWL_ThemeProvider* pTheme,
                             const CFX_Matrix* pMatrix) {
-  if (!m_pEdtEngine)
-    return;
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (!pPage)
     return;
   pGraphics->SaveGraphState();
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_CombText) {
     pGraphics->SaveGraphState();
   }
   CFX_RectF rtClip = m_rtEngine;
   FX_FLOAT fOffSetX = m_rtEngine.left - m_fScrollOffsetX;
   FX_FLOAT fOffSetY = m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset;
   CFX_Matrix mt;
   mt.Set(1, 0, 0, 1, fOffSetX, fOffSetY);
   if (pMatrix) {
     pMatrix->TransformRect(rtClip);
     mt.Concat(*pMatrix);
   }
   bool bShowSel = (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_NoHideSel) ||
                   (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused);
   if (bShowSel) {
     IFWL_Widget* pForm = m_pWidgetMgr->GetSystemFormWidget(this);
     if (pForm) {
       bShowSel = (pForm->GetStates() & FWL_WGTSTATE_Deactivated) !=
                  FWL_WGTSTATE_Deactivated;
     }
   }
-  int32_t nSelCount = m_pEdtEngine->CountSelRanges();
+  int32_t nSelCount = m_EdtEngine.CountSelRanges();
   if (bShowSel && nSelCount > 0) {
     int32_t nPageCharStart = pPage->GetCharStart();
     int32_t nPageCharCount = pPage->GetCharCount();
     int32_t nPageCharEnd = nPageCharStart + nPageCharCount - 1;
     int32_t nCharCount;
     int32_t nCharStart;
     CFX_RectFArray rectArr;
     int32_t i = 0;
     for (i = 0; i < nSelCount; i++) {
-      nCharCount = m_pEdtEngine->GetSelRange(i, nCharStart);
+      nCharCount = m_EdtEngine.GetSelRange(i, nCharStart);
       int32_t nCharEnd = nCharStart + nCharCount - 1;
       if (nCharEnd < nPageCharStart || nCharStart > nPageCharEnd) {
         continue;
       }
       int32_t nBgn = std::max(nCharStart, nPageCharStart);
       int32_t nEnd = std::min(nCharEnd, nPageCharEnd);
       pPage->CalcRangeRectArray(nBgn - nPageCharStart, nEnd - nBgn + 1,
                                 rectArr);
     }
     int32_t nCount = rectArr.GetSize();
@@ skipping 43 matching lines @@
     param.m_pPath = &path;
     pTheme->DrawBackground(&param);
   }
   pGraphics->RestoreGraphState();
 }
 
 void IFWL_Edit::UpdateEditEngine() {
   UpdateEditParams();
   UpdateEditLayout();
   if (m_nLimit > -1) {
-    m_pEdtEngine->SetLimit(m_nLimit);
+    m_EdtEngine.SetLimit(m_nLimit);
   }
 }
 void IFWL_Edit::UpdateEditParams() {
   FDE_TXTEDTPARAMS params;
   params.nHorzScale = 100;
   params.fPlateWidth = m_rtEngine.width;
   params.fPlateHeight = m_rtEngine.height;
   if (m_pProperties->m_dwStyles & FWL_WGTSTYLE_RTLLayout) {
     params.dwLayoutStyles |= FDE_TEXTEDITLAYOUT_RTL;
   }
@@ skipping 95 matching lines @@
   params.fFontSize = m_fFontSize;
   params.nLineCount = (int32_t)(params.fPlateHeight / params.fLineSpace);
   if (params.nLineCount <= 0) {
     params.nLineCount = 1;
   }
   params.fTabWidth = params.fFontSize * 1;
   params.bTabEquidistant = true;
   params.wLineBreakChar = L'\n';
   params.nCharRotation = 0;
   params.pEventSink = this;
-  m_pEdtEngine->SetEditParams(params);
+  m_EdtEngine.SetEditParams(params);
 }
 
 void IFWL_Edit::UpdateEditLayout() {
-  if (m_pEdtEngine->GetTextLength() <= 0)
-    m_pEdtEngine->SetTextByStream(nullptr);
+  if (m_EdtEngine.GetTextLength() <= 0)
+    m_EdtEngine.SetTextByStream(nullptr);
 
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (pPage)
     pPage->UnloadPage(nullptr);
 
-  m_pEdtEngine->StartLayout();
-  m_pEdtEngine->DoLayout(nullptr);
-  m_pEdtEngine->EndLayout();
-  pPage = m_pEdtEngine->GetPage(0);
+  m_EdtEngine.StartLayout();
+  m_EdtEngine.DoLayout(nullptr);
+  m_EdtEngine.EndLayout();
+  pPage = m_EdtEngine.GetPage(0);
   if (pPage)
     pPage->LoadPage(nullptr, nullptr);
 }
 
 bool IFWL_Edit::UpdateOffset() {
   CFX_RectF rtCaret;
-  m_pEdtEngine->GetCaretRect(rtCaret);
+  m_EdtEngine.GetCaretRect(rtCaret);
   FX_FLOAT fOffSetX = m_rtEngine.left - m_fScrollOffsetX;
   FX_FLOAT fOffSetY = m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset;
   rtCaret.Offset(fOffSetX, fOffSetY);
   const CFX_RectF& rtEidt = m_rtEngine;
   if (rtEidt.Contains(rtCaret)) {
-    IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+    IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
     if (!pPage)
       return false;
 
     CFX_RectF rtFDE = pPage->GetContentsBox();
     rtFDE.Offset(fOffSetX, fOffSetY);
     if (rtFDE.right() < rtEidt.right() && m_fScrollOffsetX > 0) {
       m_fScrollOffsetX += rtFDE.right() - rtEidt.right();
       m_fScrollOffsetX = std::max(m_fScrollOffsetX, 0.0f);
     }
     if (rtFDE.bottom() < rtEidt.bottom() && m_fScrollOffsetY > 0) {
@@ skipping 24 matching lines @@
 
 bool IFWL_Edit::UpdateOffset(IFWL_ScrollBar* pScrollBar, FX_FLOAT fPosChanged) {
   if (pScrollBar == m_pHorzScrollBar.get())
     m_fScrollOffsetX += fPosChanged;
   else
     m_fScrollOffsetY += fPosChanged;
   return true;
 }
 
 void IFWL_Edit::UpdateVAlignment() {
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (!pPage)
     return;
   const CFX_RectF& rtFDE = pPage->GetContentsBox();
   FX_FLOAT fOffsetY = 0.0f;
   FX_FLOAT fSpaceAbove = 0.0f;
   FX_FLOAT fSpaceBelow = 0.0f;
   CFX_SizeF* pSpace = static_cast<CFX_SizeF*>(
       GetThemeCapacity(CFWL_WidgetCapacity::SpaceAboveBelow));
   if (pSpace) {
     fSpaceAbove = pSpace->x;
@@ skipping 18 matching lines @@
   } else {
     fOffsetY += fSpaceAbove;
   }
   m_fVAlignOffset = fOffsetY;
   if (m_fVAlignOffset < 0) {
     m_fVAlignOffset = 0;
   }
 }
 void IFWL_Edit::UpdateCaret() {
   CFX_RectF rtFDE;
-  m_pEdtEngine->GetCaretRect(rtFDE);
+  m_EdtEngine.GetCaretRect(rtFDE);
   rtFDE.Offset(m_rtEngine.left - m_fScrollOffsetX,
                m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset);
   CFX_RectF rtCaret;
   rtCaret.Set(rtFDE.left, rtFDE.top, rtFDE.width, rtFDE.height);
   CFX_RectF temp = rtCaret;
   CFX_RectF rtClient;
   GetClientRect(rtClient);
   rtCaret.Intersect(rtClient);
   if (rtCaret.left > rtClient.right()) {
     FX_FLOAT right = rtCaret.right();
@@ skipping 24 matching lines @@
 IFWL_ScrollBar* IFWL_Edit::UpdateScroll() {
   bool bShowHorz =
       m_pHorzScrollBar &&
       ((m_pHorzScrollBar->GetStates() & FWL_WGTSTATE_Invisible) == 0);
   bool bShowVert =
       m_pVertScrollBar &&
       ((m_pVertScrollBar->GetStates() & FWL_WGTSTATE_Invisible) == 0);
   if (!bShowHorz && !bShowVert) {
     return nullptr;
   }
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (!pPage)
     return nullptr;
   const CFX_RectF& rtFDE = pPage->GetContentsBox();
   IFWL_ScrollBar* pRepaint = nullptr;
   if (bShowHorz) {
     CFX_RectF rtScroll;
     m_pHorzScrollBar->GetWidgetRect(rtScroll);
     if (rtScroll.width < rtFDE.width) {
       m_pHorzScrollBar->LockUpdate();
       FX_FLOAT fRange = rtFDE.width - rtScroll.width;
@@ skipping 20 matching lines @@
       m_pHorzScrollBar->UnlockUpdate();
       m_pHorzScrollBar->Update();
       pRepaint = m_pHorzScrollBar.get();
     }
   }
   if (bShowVert) {
     CFX_RectF rtScroll;
     m_pVertScrollBar->GetWidgetRect(rtScroll);
     if (rtScroll.height < rtFDE.height) {
       m_pVertScrollBar->LockUpdate();
-      FX_FLOAT fStep = m_pEdtEngine->GetEditParams()->fLineSpace;
+      FX_FLOAT fStep = m_EdtEngine.GetEditParams()->fLineSpace;
       FX_FLOAT fRange = rtFDE.height - m_rtEngine.height;
       if (fRange < fStep) {
         fRange = fStep;
       }
       m_pVertScrollBar->SetRange(0.0f, fRange);
       FX_FLOAT fPos = m_fScrollOffsetY;
       if (fPos < 0.0f) {
         fPos = 0.0f;
       }
       if (fPos > fRange) {
@@ skipping 26 matching lines @@
           : true;
   if (bVert) {
     return bShow && (m_pProperties->m_dwStyles & FWL_WGTSTYLE_VScroll) &&
            (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine) &&
            IsContentHeightOverflow();
   }
   return bShow && (m_pProperties->m_dwStyles & FWL_WGTSTYLE_HScroll) &&
          (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine);
 }
 bool IFWL_Edit::IsContentHeightOverflow() {
-  if (!m_pEdtEngine)
-    return false;
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (!pPage)
     return false;
   return pPage->GetContentsBox().height > m_rtEngine.height + 1.0f;
 }
 int32_t IFWL_Edit::AddDoRecord(IFDE_TxtEdtDoRecord* pRecord) {
   int32_t nCount = pdfium::CollectionSize<int32_t>(m_DoRecords);
   if (m_iCurRecord == nCount - 1) {
     if (nCount == m_iMaxRecord) {
       m_DoRecords.pop_front();
       m_iCurRecord--;
@@ skipping 155 matching lines @@
   prop->m_pParent = this;
   prop->m_pThemeProvider = m_pProperties->m_pThemeProvider;
 
   IFWL_ScrollBar* sb = new IFWL_ScrollBar(m_pOwnerApp, std::move(prop), this);
   if (bVert)
     m_pVertScrollBar.reset(sb);
   else
     m_pHorzScrollBar.reset(sb);
 }
 
-void IFWL_Edit::InitEngine() {
-  if (!m_pEdtEngine)
-    m_pEdtEngine.reset(new CFDE_TxtEdtEngine);
-}
-
 bool FWL_ShowCaret(IFWL_Widget* pWidget,
                    bool bVisible,
                    const CFX_RectF* pRtAnchor) {
   CXFA_FFWidget* pXFAWidget =
       static_cast<CXFA_FFWidget*>(pWidget->GetLayoutItem());
   if (!pXFAWidget)
     return false;
 
   IXFA_DocEnvironment* pDocEnvironment =
       pXFAWidget->GetDoc()->GetDocEnvironment();
@@ skipping 30 matching lines @@
       if (bVisible) {
         CFX_RectF rtOuter;
         pOuter->GetWidgetRect(rtOuter);
         pRect->Offset(rtOuter.left, rtOuter.top);
       }
     }
     FWL_ShowCaret(pOuter, bVisible, pRect);
   }
 }
 bool IFWL_Edit::ValidateNumberChar(FX_WCHAR cNum) {
-  if (!m_pEdtEngine) {
-    return false;
-  }
   if (!m_bSetRange) {
     return true;
   }
   CFX_WideString wsOld, wsText;
-  m_pEdtEngine->GetText(wsText, 0);
+  m_EdtEngine.GetText(wsText, 0);
   if (wsText.IsEmpty()) {
     if (cNum == L'0') {
       return false;
     }
     return true;
   }
-  int32_t caretPos = m_pEdtEngine->GetCaretPos();
+  int32_t caretPos = m_EdtEngine.GetCaretPos();
   int32_t iSel = CountSelRanges();
   if (iSel == 0) {
     if (cNum == L'0' && caretPos == 0) {
       return false;
     }
     int32_t nLen = wsText.GetLength();
     CFX_WideString l = wsText.Mid(0, caretPos);
     CFX_WideString r = wsText.Mid(caretPos, nLen - caretPos);
     CFX_WideString wsNew = l + cNum + r;
     if (wsNew.GetInteger() <= m_iMax) {
@@ skipping 26 matching lines @@
 }
 
 void IFWL_Edit::ProcessInsertError(int32_t iError) {
   switch (iError) {
     case -2: {
       CFWL_EvtEdtTextFull textFullEvent;
       textFullEvent.m_pSrcTarget = this;
       DispatchEvent(&textFullEvent);
       break;
     }
-    default: {}
+    default:
+      break;
   }
 }
 
 void IFWL_Edit::OnProcessMessage(CFWL_Message* pMessage) {
   if (!pMessage)
     return;
 
   CFWL_MessageType dwMsgCode = pMessage->GetClassID();
   switch (dwMsgCode) {
     case CFWL_MessageType::Activate:
@@ skipping 69 matching lines @@
 }
 
 void IFWL_Edit::DoDeactivate(CFWL_MsgDeactivate* pMsg) {
   m_pProperties->m_dwStates &= FWL_WGTSTATE_Deactivated;
   Repaint(&m_rtClient);
 }
 
 void IFWL_Edit::DoButtonDown(CFWL_MsgMouse* pMsg) {
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) == 0)
     SetFocus(true);
-  if (!m_pEdtEngine)
-    UpdateEditEngine();
 
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (!pPage)
     return;
   CFX_PointF pt(pMsg->m_fx, pMsg->m_fy);
   DeviceToEngine(pt);
   bool bBefore = true;
   int32_t nIndex = pPage->GetCharIndex(pt, bBefore);
   if (nIndex < 0)
     nIndex = 0;
 
-  m_pEdtEngine->SetCaretPos(nIndex, bBefore);
+  m_EdtEngine.SetCaretPos(nIndex, bBefore);
 }
 
 void IFWL_Edit::OnFocusChanged(CFWL_Message* pMsg, bool bSet) {
   uint32_t dwStyleEx = GetStylesEx();
   bool bRepaint = !!(dwStyleEx & FWL_STYLEEXT_EDT_InnerCaret);
   if (bSet) {
     m_pProperties->m_dwStates |= FWL_WGTSTATE_Focused;
-    if (!m_pEdtEngine)
-      UpdateEditEngine();
 
     UpdateVAlignment();
     UpdateOffset();
     UpdateCaret();
   } else if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) {
     m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Focused;
     ShowCaret(false);
-    if (m_pEdtEngine && (dwStyleEx & FWL_STYLEEXT_EDT_NoHideSel) == 0) {
+    if ((dwStyleEx & FWL_STYLEEXT_EDT_NoHideSel) == 0) {
       int32_t nSel = CountSelRanges();
       if (nSel > 0) {
         ClearSelections();
         bRepaint = true;
       }
-      SetCaretPos(0);
+      m_EdtEngine.SetCaretPos(0, true);
       UpdateOffset();
     }
     ClearRecord();
   }
   LayoutScrollBar();
   if (bRepaint) {
     CFX_RectF rtInvalidate;
     rtInvalidate.Set(0, 0, m_pProperties->m_rtWidget.width,
                      m_pProperties->m_rtWidget.height);
     Repaint(&rtInvalidate);
   }
 }
 
 void IFWL_Edit::OnLButtonDown(CFWL_MsgMouse* pMsg) {
   if (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)
     return;
 
   m_bLButtonDown = true;
   SetGrab(true);
   DoButtonDown(pMsg);
-  int32_t nIndex = m_pEdtEngine->GetCaretPos();
+  int32_t nIndex = m_EdtEngine.GetCaretPos();
   bool bRepaint = false;
-  int32_t iCount = m_pEdtEngine->CountSelRanges();
+  int32_t iCount = m_EdtEngine.CountSelRanges();
   if (iCount > 0) {
-    m_pEdtEngine->ClearSelection();
+    m_EdtEngine.ClearSelection();
     bRepaint = true;
   }
 
   bool bShift = !!(pMsg->m_dwFlags & FWL_KEYFLAG_Shift);
   if (bShift && m_nSelStart != nIndex) {
     int32_t iStart = std::min(m_nSelStart, nIndex);
     int32_t iEnd = std::max(m_nSelStart, nIndex);
-    m_pEdtEngine->AddSelRange(iStart, iEnd - iStart);
+    m_EdtEngine.AddSelRange(iStart, iEnd - iStart);
     bRepaint = true;
   } else {
     m_nSelStart = nIndex;
   }
   if (bRepaint)
     Repaint(&m_rtEngine);
 }
 
 void IFWL_Edit::OnLButtonUp(CFWL_MsgMouse* pMsg) {
   m_bLButtonDown = false;
   SetGrab(false);
 }
 
 void IFWL_Edit::OnButtonDblClk(CFWL_MsgMouse* pMsg) {
-  if (!m_pEdtEngine)
-    return;
-
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (!pPage)
     return;
 
   CFX_PointF pt(pMsg->m_fx, pMsg->m_fy);
   DeviceToEngine(pt);
   int32_t nCount = 0;
   int32_t nIndex = pPage->SelectWord(pt, nCount);
   if (nIndex < 0)
     return;
 
-  m_pEdtEngine->AddSelRange(nIndex, nCount);
-  m_pEdtEngine->SetCaretPos(nIndex + nCount - 1, false);
+  m_EdtEngine.AddSelRange(nIndex, nCount);
+  m_EdtEngine.SetCaretPos(nIndex + nCount - 1, false);
   Repaint(&m_rtEngine);
 }
 
 void IFWL_Edit::OnMouseMove(CFWL_MsgMouse* pMsg) {
-  if (!m_pEdtEngine)
-    return;
   if (m_nSelStart == -1 || !m_bLButtonDown)
     return;
 
-  IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
+  IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (!pPage)
     return;
 
   CFX_PointF pt(pMsg->m_fx, pMsg->m_fy);
   DeviceToEngine(pt);
   bool bBefore = true;
   int32_t nIndex = pPage->GetCharIndex(pt, bBefore);
-  m_pEdtEngine->SetCaretPos(nIndex, bBefore);
-  nIndex = m_pEdtEngine->GetCaretPos();
-  m_pEdtEngine->ClearSelection();
+  m_EdtEngine.SetCaretPos(nIndex, bBefore);
+  nIndex = m_EdtEngine.GetCaretPos();
+  m_EdtEngine.ClearSelection();
   if (nIndex != m_nSelStart) {
-    int32_t nLen = m_pEdtEngine->GetTextLength();
+    int32_t nLen = m_EdtEngine.GetTextLength();
     if (m_nSelStart >= nLen)
       m_nSelStart = nLen;
 
-    m_pEdtEngine->AddSelRange(std::min(m_nSelStart, nIndex),
-                              FXSYS_abs(nIndex - m_nSelStart));
+    m_EdtEngine.AddSelRange(std::min(m_nSelStart, nIndex),
+                            FXSYS_abs(nIndex - m_nSelStart));
   }
 }
 
 void IFWL_Edit::OnKeyDown(CFWL_MsgKey* pMsg) {
-  if (!m_pEdtEngine)
-    return;
-
   FDE_TXTEDTMOVECARET MoveCaret = MC_MoveNone;
   bool bShift = !!(pMsg->m_dwFlags & FWL_KEYFLAG_Shift);
   bool bCtrl = !!(pMsg->m_dwFlags & FWL_KEYFLAG_Ctrl);
   uint32_t dwKeyCode = pMsg->m_dwKeyCode;
   switch (dwKeyCode) {
     case FWL_VKEY_Left: {
       MoveCaret = MC_Left;
       break;
     }
     case FWL_VKEY_Right: {
@@ skipping 16 matching lines @@
       MoveCaret = bCtrl ? MC_End : MC_LineEnd;
       break;
     }
     case FWL_VKEY_Insert:
       break;
     case FWL_VKEY_Delete: {
       if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly) ||
           (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
         break;
       }
-      int32_t nCaret = m_pEdtEngine->GetCaretPos();
+      int32_t nCaret = m_EdtEngine.GetCaretPos();
 #if (_FX_OS_ == _FX_MACOSX_)
-      m_pEdtEngine->Delete(nCaret, true);
+      m_EdtEngine.Delete(nCaret, true);
 #else
-      m_pEdtEngine->Delete(nCaret);
+      m_EdtEngine.Delete(nCaret);
 #endif
       break;
     }
     case FWL_VKEY_F2:
       break;
     case FWL_VKEY_Tab: {
       DispatchKeyEvent(pMsg);
       break;
     }
-    default: {
-#if (_FX_OS_ == _FX_MACOSX_)
-      if (pMsg->m_dwFlags & FWL_KEYFLAG_Command) {
-#else
-      if (pMsg->m_dwFlags & FWL_KEYFLAG_Ctrl) {
-#endif
-        if (dwKeyCode == 0x43 || dwKeyCode == 0x63) {
-          DoClipboard(1);
-          return;
-        }
-        if (dwKeyCode == 0x58 || dwKeyCode == 0x78) {
-          DoClipboard(2);
-          return;
-        }
-        if (dwKeyCode == 0x56 || dwKeyCode == 0x76) {
-          DoClipboard(3);
-          return;
-        }
-      }
-    }
+    default:
+      break;
   }
   if (MoveCaret != MC_MoveNone)
-    m_pEdtEngine->MoveCaretPos(MoveCaret, bShift, bCtrl);
+    m_EdtEngine.MoveCaretPos(MoveCaret, bShift, bCtrl);
 }
 
 void IFWL_Edit::OnChar(CFWL_MsgKey* pMsg) {
   if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly) ||
       (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
     return;
   }
-  if (!m_pEdtEngine)
-    return;
 
   int32_t iError = 0;
   FX_WCHAR c = (FX_WCHAR)pMsg->m_dwKeyCode;
-  int32_t nCaret = m_pEdtEngine->GetCaretPos();
+  int32_t nCaret = m_EdtEngine.GetCaretPos();
   switch (c) {
     case FWL_VKEY_Back:
-      m_pEdtEngine->Delete(nCaret, true);
+      m_EdtEngine.Delete(nCaret, true);
       break;
     case 0x0A:
       break;
     case FWL_VKEY_Escape:
       break;
     case FWL_VKEY_Tab: {
-      iError = m_pEdtEngine->Insert(nCaret, L"\t", 1);
+      iError = m_EdtEngine.Insert(nCaret, L"\t", 1);
       break;
     }
     case FWL_VKEY_Return: {
       if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_WantReturn) {
-        iError = m_pEdtEngine->Insert(nCaret, L"\n", 1);
+        iError = m_EdtEngine.Insert(nCaret, L"\n", 1);
       }
       break;
     }
     default: {
       if (!m_pWidgetMgr->IsFormDisabled()) {
         if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_Number) {
           if (((pMsg->m_dwKeyCode < FWL_VKEY_0) &&
                (pMsg->m_dwKeyCode != 0x2E && pMsg->m_dwKeyCode != 0x2D)) ||
               pMsg->m_dwKeyCode > FWL_VKEY_9) {
             break;
           }
           if (!ValidateNumberChar(c))
             break;
         }
       }
 #if (_FX_OS_ == _FX_MACOSX_)
       if (pMsg->m_dwFlags & FWL_KEYFLAG_Command)
 #else
       if (pMsg->m_dwFlags & FWL_KEYFLAG_Ctrl)
 #endif
       {
         break;
       }
-      iError = m_pEdtEngine->Insert(nCaret, &c, 1);
+      iError = m_EdtEngine.Insert(nCaret, &c, 1);
       break;
     }
   }
   if (iError < 0)
     ProcessInsertError(iError);
 }
 
 bool IFWL_Edit::OnScroll(IFWL_ScrollBar* pScrollBar,
                          FWL_SCBCODE dwCode,
                          FX_FLOAT fPos) {
@@ skipping 42 matching lines @@
     case FWL_SCBCODE::TrackPos:
     case FWL_SCBCODE::None:
       break;
     case FWL_SCBCODE::EndScroll:
       return false;
   }
   if (iCurPos != fPos) {
     pScrollBar->SetPos(fPos);
     pScrollBar->SetTrackPos(fPos);
     UpdateOffset(pScrollBar, fPos - iCurPos);
-    if (m_pEdtEngine) {
-      UpdateCaret();
-    }
+    UpdateCaret();
+
     CFX_RectF rect;
     GetWidgetRect(rect);
     CFX_RectF rtInvalidate;
     rtInvalidate.Set(0, 0, rect.width + 2, rect.height + 2);
     Repaint(&rtInvalidate);
   }
   return true;
 }