Merge the CFWL_*Imp classes into the IFWL_* classes.

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/basewidget/fwl_editimp.h"
+#include "xfa/fwl/core/ifwl_edit.h"
 
 #include <algorithm>
 #include <memory>
 #include <vector>
 
 #include "third_party/base/stl_util.h"
 #include "xfa/fde/cfde_txtedtengine.h"
 #include "xfa/fde/fde_gedevice.h"
 #include "xfa/fde/fde_render.h"
 #include "xfa/fde/ifde_txtedtpage.h"
 #include "xfa/fgas/font/fgas_gefont.h"
-#include "xfa/fwl/basewidget/fwl_caretimp.h"
-#include "xfa/fwl/basewidget/fwl_comboboximp.h"
-#include "xfa/fwl/basewidget/fwl_scrollbarimp.h"
-#include "xfa/fwl/basewidget/ifwl_caret.h"
 #include "xfa/fwl/core/cfwl_message.h"
 #include "xfa/fwl/core/cfwl_themebackground.h"
 #include "xfa/fwl/core/cfwl_themepart.h"
 #include "xfa/fwl/core/cfwl_widgetmgr.h"
-#include "xfa/fwl/core/fwl_widgetimp.h"
 #include "xfa/fwl/core/ifwl_app.h"
+#include "xfa/fwl/core/ifwl_caret.h"
 #include "xfa/fwl/core/ifwl_themeprovider.h"
 #include "xfa/fxfa/xfa_ffdoc.h"
 #include "xfa/fxfa/xfa_ffwidget.h"
 #include "xfa/fxgraphics/cfx_path.h"
 
 namespace {
 
 const int kEditMargin = 3;
 
 bool FX_EDIT_ISLATINWORD(FX_WCHAR c) {
@@ skipping 12 matching lines @@
   for (FX_FLOAT fx = fStartX + fStep; fx < fEndX; fx += fStep, ++i) {
     pPathData->LineTo(fx, fY + (i & 1) * fStep);
   }
 }
 
 }  // namespace
 
 // static
 IFWL_Edit* IFWL_Edit::Create(const CFWL_WidgetImpProperties& properties,
                              IFWL_Widget* pOuter) {
-  IFWL_Edit* pEdit = new IFWL_Edit;
-  CFWL_EditImp* pEditImpl = new CFWL_EditImp(properties, pOuter);
-  pEdit->SetImpl(pEditImpl);
-  pEditImpl->SetInterface(pEdit);
-  return pEdit;
-}
-// static
-IFWL_Edit* IFWL_Edit::CreateComboEdit(
-    const CFWL_WidgetImpProperties& properties,
-    IFWL_Widget* pOuter) {
-  IFWL_Edit* pEdit = new IFWL_Edit;
-  CFWL_EditImp* pComboEditImpl = new CFWL_ComboEditImp(properties, pOuter);
-  pEdit->SetImpl(pComboEditImpl);
-  pComboEditImpl->SetInterface(pEdit);
-  return pEdit;
-}
-IFWL_Edit::IFWL_Edit() {}
-FWL_Error IFWL_Edit::SetText(const CFX_WideString& wsText) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetText(wsText);
-}
-int32_t IFWL_Edit::GetTextLength() const {
-  return static_cast<CFWL_EditImp*>(GetImpl())->GetTextLength();
-}
-FWL_Error IFWL_Edit::GetText(CFX_WideString& wsText,
-                             int32_t nStart,
-                             int32_t nCount) const {
-  return static_cast<CFWL_EditImp*>(GetImpl())->GetText(wsText, nStart, nCount);
-}
-FWL_Error IFWL_Edit::ClearText() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->ClearText();
-}
-int32_t IFWL_Edit::GetCaretPos() const {
-  return static_cast<CFWL_EditImp*>(GetImpl())->GetCaretPos();
-}
-int32_t IFWL_Edit::SetCaretPos(int32_t nIndex, FX_BOOL bBefore) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetCaretPos(nIndex, bBefore);
-}
-FWL_Error IFWL_Edit::AddSelRange(int32_t nStart, int32_t nCount) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->AddSelRange(nStart, nCount);
-}
-int32_t IFWL_Edit::CountSelRanges() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->CountSelRanges();
-}
-int32_t IFWL_Edit::GetSelRange(int32_t nIndex, int32_t& nStart) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->GetSelRange(nIndex, nStart);
-}
-FWL_Error IFWL_Edit::ClearSelections() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->ClearSelections();
-}
-int32_t IFWL_Edit::GetLimit() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->GetLimit();
-}
-FWL_Error IFWL_Edit::SetLimit(int32_t nLimit) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetLimit(nLimit);
-}
-FWL_Error IFWL_Edit::SetAliasChar(FX_WCHAR wAlias) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetAliasChar(wAlias);
-}
-FWL_Error IFWL_Edit::Insert(int32_t nStart,
-                            const FX_WCHAR* lpText,
-                            int32_t nLen) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Insert(nStart, lpText, nLen);
-}
-FWL_Error IFWL_Edit::DeleteSelections() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->DeleteSelections();
-}
-FWL_Error IFWL_Edit::DeleteRange(int32_t nStart, int32_t nCount) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->DeleteRange(nStart, nCount);
-}
-FWL_Error IFWL_Edit::Replace(int32_t nStart,
-                             int32_t nLen,
-                             const CFX_WideStringC& wsReplace) {
-  return static_cast<CFWL_EditImp*>(GetImpl())
-      ->Replace(nStart, nLen, wsReplace);
-}
-FWL_Error IFWL_Edit::DoClipboard(int32_t iCmd) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->DoClipboard(iCmd);
-}
-FX_BOOL IFWL_Edit::Copy(CFX_WideString& wsCopy) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Copy(wsCopy);
-}
-FX_BOOL IFWL_Edit::Cut(CFX_WideString& wsCut) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Cut(wsCut);
-}
-FX_BOOL IFWL_Edit::Paste(const CFX_WideString& wsPaste) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Paste(wsPaste);
-}
-FX_BOOL IFWL_Edit::Delete() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Delete();
-}
-FX_BOOL IFWL_Edit::Redo(const IFDE_TxtEdtDoRecord* pRecord) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Redo(pRecord);
-}
-FX_BOOL IFWL_Edit::Undo(const IFDE_TxtEdtDoRecord* pRecord) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Undo(pRecord);
-}
-FX_BOOL IFWL_Edit::Undo() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Undo();
-}
-FX_BOOL IFWL_Edit::Redo() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->Redo();
-}
-FX_BOOL IFWL_Edit::CanUndo() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->CanUndo();
-}
-FX_BOOL IFWL_Edit::CanRedo() {
-  return static_cast<CFWL_EditImp*>(GetImpl())->CanRedo();
-}
-FWL_Error IFWL_Edit::SetTabWidth(FX_FLOAT fTabWidth, FX_BOOL bEquidistant) {
-  return static_cast<CFWL_EditImp*>(GetImpl())
-      ->SetTabWidth(fTabWidth, bEquidistant);
-}
-FWL_Error IFWL_Edit::SetOuter(IFWL_Widget* pOuter) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetOuter(pOuter);
-}
-FWL_Error IFWL_Edit::SetNumberRange(int32_t iMin, int32_t iMax) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetNumberRange(iMin, iMax);
-}
-FWL_Error IFWL_Edit::SetBackColor(uint32_t dwColor) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetBackgroundColor(dwColor);
-}
-FWL_Error IFWL_Edit::SetFont(const CFX_WideString& wsFont, FX_FLOAT fSize) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetFont(wsFont, fSize);
-}
-void IFWL_Edit::SetScrollOffset(FX_FLOAT fScrollOffset) {
-  return static_cast<CFWL_EditImp*>(GetImpl())->SetScrollOffset(fScrollOffset);
-}
-FX_BOOL IFWL_Edit::GetSuggestWords(CFX_PointF pointf,
-                                   std::vector<CFX_ByteString>& sSuggest) {
-  return static_cast<CFWL_EditImp*>(GetImpl())
-      ->GetSuggestWords(pointf, sSuggest);
-}
-FX_BOOL IFWL_Edit::ReplaceSpellCheckWord(CFX_PointF pointf,
-                                         const CFX_ByteStringC& bsReplace) {
-  return static_cast<CFWL_EditImp*>(GetImpl())
-      ->ReplaceSpellCheckWord(pointf, bsReplace);
+  return new IFWL_Edit(properties, pOuter);
 }
 
-CFWL_EditImp::CFWL_EditImp(const CFWL_WidgetImpProperties& properties,
-                           IFWL_Widget* pOuter)
-    : CFWL_WidgetImp(properties, pOuter),
+IFWL_Edit::IFWL_Edit(const CFWL_WidgetImpProperties& properties,
+                     IFWL_Widget* pOuter)
+    : IFWL_Widget(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();
 }
 
-CFWL_EditImp::~CFWL_EditImp() {
+IFWL_Edit::~IFWL_Edit() {
   ClearRecord();
 }
 
-FWL_Error CFWL_EditImp::GetClassName(CFX_WideString& wsClass) const {
+FWL_Error IFWL_Edit::GetClassName(CFX_WideString& wsClass) const {
   wsClass = FWL_CLASS_Edit;
   return FWL_Error::Succeeded;
 }
 
-FWL_Type CFWL_EditImp::GetClassID() const {
+FWL_Type IFWL_Edit::GetClassID() const {
   return FWL_Type::Edit;
 }
 
-FWL_Error CFWL_EditImp::Initialize() {
-  if (CFWL_WidgetImp::Initialize() != FWL_Error::Succeeded)
+FWL_Error IFWL_Edit::Initialize() {
+  if (IFWL_Widget::Initialize() != FWL_Error::Succeeded)
     return FWL_Error::Indefinite;
   if (!m_pDelegate)
     m_pDelegate = new CFWL_EditImpDelegate(this);
 
   InitCaret();
   if (!m_pEdtEngine)
     InitEngine();
 
   return FWL_Error::Succeeded;
 }
 
-FWL_Error CFWL_EditImp::Finalize() {
+FWL_Error IFWL_Edit::Finalize() {
   if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) {
     ShowCaret(FALSE);
   }
   if (m_pHorzScrollBar) {
     m_pHorzScrollBar->Finalize();
   }
   if (m_pVertScrollBar) {
     m_pVertScrollBar->Finalize();
   }
   delete m_pDelegate;
   m_pDelegate = nullptr;
-  return CFWL_WidgetImp::Finalize();
+  return IFWL_Widget::Finalize();
 }
-FWL_Error CFWL_EditImp::GetWidgetRect(CFX_RectF& rect, FX_BOOL bAutoSize) {
+FWL_Error IFWL_Edit::GetWidgetRect(CFX_RectF& rect, FX_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);
       }
     }
-    CFWL_WidgetImp::GetWidgetRect(rect, TRUE);
+    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;
       }
       if (IsShowScrollBar(FALSE)) {
         FX_FLOAT* pfWidth = static_cast<FX_FLOAT*>(
             GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
         rect.height += *pfWidth;
         rect.height += kEditMargin;
       }
     }
   }
   return FWL_Error::Succeeded;
 }
 
-void CFWL_EditImp::SetStates(uint32_t dwStates, FX_BOOL bSet) {
+void IFWL_Edit::SetStates(uint32_t dwStates, FX_BOOL bSet) {
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Invisible) ||
       (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
     ShowCaret(FALSE);
   }
-  CFWL_WidgetImp::SetStates(dwStates, bSet);
+  IFWL_Widget::SetStates(dwStates, bSet);
 }
 
-FWL_Error CFWL_EditImp::SetWidgetRect(const CFX_RectF& rect) {
-  return CFWL_WidgetImp::SetWidgetRect(rect);
+FWL_Error IFWL_Edit::SetWidgetRect(const CFX_RectF& rect) {
+  return IFWL_Widget::SetWidgetRect(rect);
 }
-FWL_Error CFWL_EditImp::Update() {
+FWL_Error IFWL_Edit::Update() {
   if (IsLocked()) {
     return FWL_Error::Indefinite;
   }
   if (!m_pProperties->m_pThemeProvider) {
     m_pProperties->m_pThemeProvider = GetAvailableTheme();
   }
   Layout();
   if (m_rtClient.IsEmpty()) {
     return FWL_Error::Indefinite;
   }
   UpdateEditEngine();
   UpdateVAlignment();
   UpdateScroll();
   InitCaret();
   return FWL_Error::Succeeded;
 }
 
-FWL_WidgetHit CFWL_EditImp::HitTest(FX_FLOAT fx, FX_FLOAT fy) {
+FWL_WidgetHit IFWL_Edit::HitTest(FX_FLOAT fx, FX_FLOAT fy) {
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
     if (IsShowScrollBar(TRUE)) {
       CFX_RectF rect;
       m_pVertScrollBar->GetWidgetRect(rect);
       if (rect.Contains(fx, fy))
         return FWL_WidgetHit::VScrollBar;
     }
     if (IsShowScrollBar(FALSE)) {
       CFX_RectF rect;
       m_pHorzScrollBar->GetWidgetRect(rect);
       if (rect.Contains(fx, fy))
         return FWL_WidgetHit::HScrollBar;
     }
   }
   if (m_rtClient.Contains(fx, fy))
     return FWL_WidgetHit::Edit;
   return FWL_WidgetHit::Unknown;
 }
 
-void CFWL_EditImp::AddSpellCheckObj(CFX_Path& PathData,
-                                    int32_t nStart,
-                                    int32_t nCount,
-                                    FX_FLOAT fOffSetX,
-                                    FX_FLOAT fOffSetY) {
+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);
   CFX_RectFArray rectArray;
   CFX_RectF rectText;
   const FDE_TXTEDTPARAMS* txtEdtParams = m_pEdtEngine->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 CFWL_EditImp::GetWordAtPoint(CFX_PointF pointf, int32_t& nCount) {
+int32_t IFWL_Edit::GetWordAtPoint(CFX_PointF pointf, int32_t& nCount) {
   return 0;
 }
-FX_BOOL CFWL_EditImp::GetSuggestWords(CFX_PointF pointf,
-                                      std::vector<CFX_ByteString>& sSuggest) {
+FX_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 = m_pInterface;
+  checkWordEvent.m_pSrcTarget = this;
   checkWordEvent.bsWord = sLatinWord;
   checkWordEvent.bCheckWord = TRUE;
   DispatchEvent(&checkWordEvent);
   if (checkWordEvent.bCheckWord) {
     return FALSE;
   }
   CFWL_EvtEdtGetSuggestWords suggestWordsEvent;
-  suggestWordsEvent.m_pSrcTarget = m_pInterface;
+  suggestWordsEvent.m_pSrcTarget = this;
   suggestWordsEvent.bsWord = sLatinWord;
   suggestWordsEvent.bsArraySuggestWords = sSuggest;
   suggestWordsEvent.bSuggestWords = FALSE;
   DispatchEvent(&checkWordEvent);
   return suggestWordsEvent.bSuggestWords;
 }
-FX_BOOL CFWL_EditImp::ReplaceSpellCheckWord(CFX_PointF pointf,
-                                            const CFX_ByteStringC& bsReplace) {
+FX_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 CFWL_EditImp::DrawSpellCheck(CFX_Graphics* pGraphics,
-                                  const CFX_Matrix* pMatrix) {
+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 = m_pInterface;
+  checkWordEvent.m_pSrcTarget = this;
   CFX_ByteString sLatinWord;
   CFX_Path pathSpell;
   pathSpell.Create();
   int32_t nStart = 0;
   FX_FLOAT fOffSetX = m_rtEngine.left - m_fScrollOffsetX;
   FX_FLOAT fOffSetY = m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset;
   CFX_WideString wsSpell;
   GetText(wsSpell);
   int32_t nContentLen = wsSpell.GetLength();
   for (int i = 0; i < nContentLen; i++) {
@@ skipping 28 matching lines @@
       pMatrix->TransformRect(rtClip);
       mt.Concat(*pMatrix);
     }
     pGraphics->SetClipRect(rtClip);
     pGraphics->SetStrokeColor(&crLine);
     pGraphics->SetLineWidth(0);
     pGraphics->StrokePath(&pathSpell, nullptr);
   }
   pGraphics->RestoreGraphState();
 }
-FWL_Error CFWL_EditImp::DrawWidget(CFX_Graphics* pGraphics,
-                                   const CFX_Matrix* pMatrix) {
+FWL_Error IFWL_Edit::DrawWidget(CFX_Graphics* pGraphics,
+                                const CFX_Matrix* pMatrix) {
   if (!pGraphics)
     return FWL_Error::Indefinite;
   if (!m_pProperties->m_pThemeProvider)
     return FWL_Error::Indefinite;
   if (m_rtClient.IsEmpty()) {
     return FWL_Error::Indefinite;
   }
   IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
   if (!m_pWidgetMgr->IsFormDisabled()) {
     DrawTextBk(pGraphics, pTheme, pMatrix);
   }
   if (m_pEdtEngine) {
     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);
   }
   return FWL_Error::Succeeded;
 }
-FWL_Error CFWL_EditImp::SetThemeProvider(IFWL_ThemeProvider* pThemeProvider) {
+FWL_Error IFWL_Edit::SetThemeProvider(IFWL_ThemeProvider* pThemeProvider) {
   if (!pThemeProvider)
     return FWL_Error::Indefinite;
   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;
   return FWL_Error::Succeeded;
 }
 
-FWL_Error CFWL_EditImp::SetText(const CFX_WideString& wsText) {
+FWL_Error IFWL_Edit::SetText(const CFX_WideString& wsText) {
   m_pEdtEngine->SetText(wsText);
   return FWL_Error::Succeeded;
 }
 
-int32_t CFWL_EditImp::GetTextLength() const {
+int32_t IFWL_Edit::GetTextLength() const {
   if (!m_pEdtEngine)
     return -1;
   return m_pEdtEngine->GetTextLength();
 }
 
-FWL_Error CFWL_EditImp::GetText(CFX_WideString& wsText,
-                                int32_t nStart,
-                                int32_t nCount) const {
+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;
 }
 
-FWL_Error CFWL_EditImp::ClearText() {
+FWL_Error IFWL_Edit::ClearText() {
   if (!m_pEdtEngine)
     return FWL_Error::Indefinite;
 
   m_pEdtEngine->ClearText();
   return FWL_Error::Succeeded;
 }
 
-int32_t CFWL_EditImp::GetCaretPos() const {
+int32_t IFWL_Edit::GetCaretPos() const {
   if (!m_pEdtEngine)
     return -1;
   return m_pEdtEngine->GetCaretPos();
 }
 
-int32_t CFWL_EditImp::SetCaretPos(int32_t nIndex, FX_BOOL bBefore) {
+int32_t IFWL_Edit::SetCaretPos(int32_t nIndex, FX_BOOL bBefore) {
   if (!m_pEdtEngine)
     return -1;
   return m_pEdtEngine->SetCaretPos(nIndex, bBefore);
 }
 
-FWL_Error CFWL_EditImp::AddSelRange(int32_t nStart, int32_t nCount) {
+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;
 }
 
-int32_t CFWL_EditImp::CountSelRanges() {
+int32_t IFWL_Edit::CountSelRanges() {
   if (!m_pEdtEngine)
     return 0;
   return m_pEdtEngine->CountSelRanges();
 }
 
-int32_t CFWL_EditImp::GetSelRange(int32_t nIndex, int32_t& nStart) {
+int32_t IFWL_Edit::GetSelRange(int32_t nIndex, int32_t& nStart) {
   if (!m_pEdtEngine)
     return -1;
   return m_pEdtEngine->GetSelRange(nIndex, nStart);
 }
 
-FWL_Error CFWL_EditImp::ClearSelections() {
+FWL_Error IFWL_Edit::ClearSelections() {
   if (!m_pEdtEngine)
     return FWL_Error::Indefinite;
 
   m_pEdtEngine->ClearSelection();
   return FWL_Error::Succeeded;
 }
 
-int32_t CFWL_EditImp::GetLimit() {
+int32_t IFWL_Edit::GetLimit() {
   return m_nLimit;
 }
 
-FWL_Error CFWL_EditImp::SetLimit(int32_t nLimit) {
+FWL_Error IFWL_Edit::SetLimit(int32_t nLimit) {
   m_nLimit = nLimit;
   if (!m_pEdtEngine)
     return FWL_Error::Indefinite;
 
   m_pEdtEngine->SetLimit(nLimit);
   return FWL_Error::Succeeded;
 }
 
-FWL_Error CFWL_EditImp::SetAliasChar(FX_WCHAR wAlias) {
+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 CFWL_EditImp::Insert(int32_t nStart,
-                               const FX_WCHAR* lpText,
-                               int32_t nLen) {
+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 CFWL_EditImp::DeleteSelections() {
+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 CFWL_EditImp::DeleteRange(int32_t nStart, int32_t nCount) {
+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 CFWL_EditImp::Replace(int32_t nStart,
-                                int32_t nLen,
-                                const CFX_WideStringC& wsReplace) {
+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 CFWL_EditImp::DoClipboard(int32_t iCmd) {
+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;
 }
 
-FX_BOOL CFWL_EditImp::Copy(CFX_WideString& wsCopy) {
+FX_BOOL IFWL_Edit::Copy(CFX_WideString& wsCopy) {
   if (!m_pEdtEngine)
     return FALSE;
 
   int32_t nCount = m_pEdtEngine->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);
     wsCopy += wsTemp;
     wsTemp.clear();
   }
   return TRUE;
 }
 
-FX_BOOL CFWL_EditImp::Cut(CFX_WideString& wsCut) {
+FX_BOOL IFWL_Edit::Cut(CFX_WideString& wsCut) {
   if (!m_pEdtEngine)
     return FALSE;
 
   int32_t nCount = m_pEdtEngine->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);
     wsCut += wsTemp;
     wsTemp.clear();
   }
   m_pEdtEngine->Delete(0);
   return TRUE;
 }
 
-FX_BOOL CFWL_EditImp::Paste(const CFX_WideString& wsPaste) {
+FX_BOOL IFWL_Edit::Paste(const CFX_WideString& wsPaste) {
   if (!m_pEdtEngine)
     return FALSE;
 
   int32_t nCaret = m_pEdtEngine->GetCaretPos();
   int32_t iError =
       m_pEdtEngine->Insert(nCaret, wsPaste.c_str(), wsPaste.GetLength());
   if (iError < 0) {
     ProcessInsertError(iError);
     return FALSE;
   }
   return TRUE;
 }
 
-FX_BOOL CFWL_EditImp::Delete() {
+FX_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;
 }
 
-FX_BOOL CFWL_EditImp::Redo(const IFDE_TxtEdtDoRecord* pRecord) {
+FX_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);
 }
 
-FX_BOOL CFWL_EditImp::Undo(const IFDE_TxtEdtDoRecord* pRecord) {
+FX_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);
 }
 
-FX_BOOL CFWL_EditImp::Undo() {
+FX_BOOL IFWL_Edit::Undo() {
   if (!CanUndo())
     return FALSE;
   return Undo(m_DoRecords[m_iCurRecord--].get());
 }
 
-FX_BOOL CFWL_EditImp::Redo() {
+FX_BOOL IFWL_Edit::Redo() {
   if (!CanRedo())
     return FALSE;
   return Redo(m_DoRecords[++m_iCurRecord].get());
 }
 
-FX_BOOL CFWL_EditImp::CanUndo() {
+FX_BOOL IFWL_Edit::CanUndo() {
   return m_iCurRecord >= 0;
 }
 
-FX_BOOL CFWL_EditImp::CanRedo() {
+FX_BOOL IFWL_Edit::CanRedo() {
   return m_iCurRecord < pdfium::CollectionSize<int32_t>(m_DoRecords) - 1;
 }
 
-FWL_Error CFWL_EditImp::SetTabWidth(FX_FLOAT fTabWidth, FX_BOOL bEquidistant) {
+FWL_Error IFWL_Edit::SetTabWidth(FX_FLOAT fTabWidth, FX_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 CFWL_EditImp::SetOuter(IFWL_Widget* pOuter) {
+FWL_Error IFWL_Edit::SetOuter(IFWL_Widget* pOuter) {
   m_pOuter = pOuter;
   return FWL_Error::Succeeded;
 }
 
-FWL_Error CFWL_EditImp::SetNumberRange(int32_t iMin, int32_t iMax) {
+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 CFWL_EditImp::On_CaretChanged(CFDE_TxtEdtEngine* pEdit,
-                                   int32_t nPage,
-                                   FX_BOOL bVisible) {
+void IFWL_Edit::On_CaretChanged(CFDE_TxtEdtEngine* pEdit,
+                                int32_t nPage,
+                                FX_BOOL bVisible) {
   if (m_rtEngine.IsEmpty())
     return;
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) == 0)
     return;
 
   FX_BOOL bRepaintContent = UpdateOffset();
   UpdateCaret();
   CFX_RectF rtInvalid;
   rtInvalid.Set(0, 0, 0, 0);
   FX_BOOL bRepaintScroll = FALSE;
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine) {
     IFWL_ScrollBar* pScroll = UpdateScroll();
     if (pScroll) {
       pScroll->GetWidgetRect(rtInvalid);
       bRepaintScroll = TRUE;
     }
   }
   if (bRepaintContent || bRepaintScroll) {
     if (bRepaintContent) {
       rtInvalid.Union(m_rtEngine);
     }
     Repaint(&rtInvalid);
   }
 }
 
-void CFWL_EditImp::On_TextChanged(CFDE_TxtEdtEngine* pEdit,
-                                  FDE_TXTEDT_TEXTCHANGE_INFO& ChangeInfo) {
+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);
   FX_FLOAT fContentWidth = page->GetContentsBox().width;
   FX_FLOAT fContentHeight = page->GetContentsBox().height;
   CFX_RectF rtTemp;
   GetClientRect(rtTemp);
   FX_BOOL bHSelfAdaption =
       m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_HSelfAdaption;
   FX_BOOL bVSelfAdaption =
       m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VSelfAdaption;
   FX_BOOL bNeedUpdate = FALSE;
   if (bHSelfAdaption || bVSelfAdaption) {
     CFWL_EvtEdtPreSelfAdaption evt;
-    evt.m_pSrcTarget = m_pInterface;
+    evt.m_pSrcTarget = this;
     evt.bHSelfAdaption = TRUE;
     evt.bVSelfAdaption = TRUE;
     FX_FLOAT fWidth;
     FX_FLOAT fHight;
     fWidth = bHSelfAdaption ? fContentWidth : m_pProperties->m_rtWidget.width;
     fHight = bVSelfAdaption ? fContentHeight : m_pProperties->m_rtWidget.height;
     evt.rtAfterChange.Set(0, 0, fWidth, fHight);
     DispatchEvent(&evt);
     if (!evt.bHSelfAdaption) {
       ModifyStylesEx(
@@ skipping 17 matching lines @@
   }
   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;
   }
   CFWL_EvtEdtTextChanged event;
-  event.m_pSrcTarget = m_pInterface;
+  event.m_pSrcTarget = this;
   event.nChangeType = ChangeInfo.nChangeType;
   event.wsInsert = ChangeInfo.wsInsert;
   event.wsDelete = ChangeInfo.wsDelete;
   event.wsPrevText = ChangeInfo.wsPrevText;
   DispatchEvent(&event);
   LayoutScrollBar();
   Repaint(&rtTemp);
 }
 
-void CFWL_EditImp::On_SelChanged(CFDE_TxtEdtEngine* pEdit) {
+void IFWL_Edit::On_SelChanged(CFDE_TxtEdtEngine* pEdit) {
   CFX_RectF rtTemp;
   GetClientRect(rtTemp);
   Repaint(&rtTemp);
 }
 
-FX_BOOL CFWL_EditImp::On_PageLoad(CFDE_TxtEdtEngine* pEdit,
-                                  int32_t nPageIndex,
-                                  int32_t nPurpose) {
+FX_BOOL IFWL_Edit::On_PageLoad(CFDE_TxtEdtEngine* pEdit,
+                               int32_t nPageIndex,
+                               int32_t nPurpose) {
   IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(nPageIndex);
   if (!pPage)
     return FALSE;
   pPage->LoadPage(nullptr, nullptr);
   return TRUE;
 }
 
-FX_BOOL CFWL_EditImp::On_PageUnload(CFDE_TxtEdtEngine* pEdit,
-                                    int32_t nPageIndex,
-                                    int32_t nPurpose) {
+FX_BOOL IFWL_Edit::On_PageUnload(CFDE_TxtEdtEngine* pEdit,
+                                 int32_t nPageIndex,
+                                 int32_t nPurpose) {
   IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(nPageIndex);
   if (!pPage)
     return FALSE;
   pPage->UnloadPage(nullptr);
   return TRUE;
 }
 
-void CFWL_EditImp::On_AddDoRecord(CFDE_TxtEdtEngine* pEdit,
-                                  IFDE_TxtEdtDoRecord* pRecord) {
+void IFWL_Edit::On_AddDoRecord(CFDE_TxtEdtEngine* pEdit,
+                               IFDE_TxtEdtDoRecord* pRecord) {
   AddDoRecord(pRecord);
 }
 
-FX_BOOL CFWL_EditImp::On_Validate(CFDE_TxtEdtEngine* pEdit,
-                                  CFX_WideString& wsText) {
+FX_BOOL IFWL_Edit::On_Validate(CFDE_TxtEdtEngine* pEdit,
+                               CFX_WideString& wsText) {
   IFWL_Widget* pDst = GetOuter();
   if (!pDst) {
-    pDst = m_pInterface;
+    pDst = this;
   }
   CFWL_EvtEdtValidate event;
   event.pDstWidget = pDst;
-  event.m_pSrcTarget = m_pInterface;
+  event.m_pSrcTarget = this;
   event.wsInsert = wsText;
   event.bValidate = TRUE;
   DispatchEvent(&event);
   return event.bValidate;
 }
-FWL_Error CFWL_EditImp::SetBackgroundColor(uint32_t color) {
+FWL_Error IFWL_Edit::SetBackgroundColor(uint32_t color) {
   m_backColor = color;
   m_updateBackColor = TRUE;
   return FWL_Error::Succeeded;
 }
-FWL_Error CFWL_EditImp::SetFont(const CFX_WideString& wsFont, FX_FLOAT fSize) {
+FWL_Error IFWL_Edit::SetFont(const CFX_WideString& wsFont, FX_FLOAT fSize) {
   m_wsFont = wsFont;
   m_fFontSize = fSize;
   return FWL_Error::Succeeded;
 }
-void CFWL_EditImp::SetScrollOffset(FX_FLOAT fScrollOffset) {
+void IFWL_Edit::SetScrollOffset(FX_FLOAT fScrollOffset) {
   m_fScrollOffsetY = fScrollOffset;
 }
-void CFWL_EditImp::DrawTextBk(CFX_Graphics* pGraphics,
-                              IFWL_ThemeProvider* pTheme,
-                              const CFX_Matrix* pMatrix) {
+void IFWL_Edit::DrawTextBk(CFX_Graphics* pGraphics,
+                           IFWL_ThemeProvider* pTheme,
+                           const CFX_Matrix* pMatrix) {
   CFWL_ThemeBackground param;
-  param.m_pWidget = m_pInterface;
+  param.m_pWidget = this;
   param.m_iPart = CFWL_Part::Background;
   param.m_bStaticBackground = false;
   param.m_dwStates = m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly
                          ? CFWL_PartState_ReadOnly
                          : CFWL_PartState_Normal;
   uint32_t dwStates = (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled);
   if (dwStates) {
     param.m_dwStates = CFWL_PartState_Disabled;
   }
   param.m_pGraphics = pGraphics;
   param.m_matrix = *pMatrix;
   param.m_rtPart = m_rtClient;
   pTheme->DrawBackground(&param);
   if (!IsShowScrollBar(TRUE) || !IsShowScrollBar(FALSE)) {
     return;
   }
   CFX_RectF rtScorll;
   m_pHorzScrollBar->GetWidgetRect(rtScorll);
   CFX_RectF rtStatic;
   rtStatic.Set(m_rtClient.right() - rtScorll.height,
                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 CFWL_EditImp::DrawContent(CFX_Graphics* pGraphics,
-                               IFWL_ThemeProvider* pTheme,
-                               const CFX_Matrix* pMatrix) {
+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);
   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);
   }
   FX_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(m_pInterface);
+    IFWL_Widget* pForm = m_pWidgetMgr->GetSystemFormWidget(this);
     if (pForm) {
       bShowSel = (pForm->GetStates() & FWL_WGTSTATE_Deactivated) !=
                  FWL_WGTSTATE_Deactivated;
     }
   }
   int32_t nSelCount = m_pEdtEngine->CountSelRanges();
   if (bShowSel && nSelCount > 0) {
     int32_t nPageCharStart = pPage->GetCharStart();
     int32_t nPageCharCount = pPage->GetCharCount();
     int32_t nPageCharEnd = nPageCharStart + nPageCharCount - 1;
@@ skipping 18 matching lines @@
     for (i = 0; i < nCount; i++) {
       rectArr[i].left += fOffSetX;
       rectArr[i].top += fOffSetY;
       path.AddRectangle(rectArr[i].left, rectArr[i].top, rectArr[i].width,
                         rectArr[i].height);
     }
     pGraphics->SetClipRect(rtClip);
     CFWL_ThemeBackground param;
     param.m_pGraphics = pGraphics;
     param.m_matrix = *pMatrix;
-    param.m_pWidget = m_pInterface;
+    param.m_pWidget = this;
     param.m_iPart = CFWL_Part::Background;
     param.m_pPath = &path;
     pTheme->DrawBackground(&param);
   }
   CFX_RenderDevice* pRenderDev = pGraphics->GetRenderDevice();
   if (!pRenderDev)
     return;
 
   std::unique_ptr<CFDE_RenderDevice> pRenderDevice(
       new CFDE_RenderDevice(pRenderDev, FALSE));
   std::unique_ptr<CFDE_RenderContext> pRenderContext(new CFDE_RenderContext);
   pRenderDevice->SetClipRect(rtClip);
   pRenderContext->StartRender(pRenderDevice.get(), pPage, mt);
   pRenderContext->DoRender(nullptr);
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_CombText) {
     pGraphics->RestoreGraphState();
     CFX_Path path;
     path.Create();
     int32_t iLimit = m_nLimit > 0 ? m_nLimit : 1;
     FX_FLOAT fStep = m_rtEngine.width / iLimit;
     FX_FLOAT fLeft = m_rtEngine.left + 1;
     for (int32_t i = 1; i < iLimit; i++) {
       fLeft += fStep;
       path.AddLine(fLeft, m_rtClient.top, fLeft, m_rtClient.bottom());
     }
     CFWL_ThemeBackground param;
     param.m_pGraphics = pGraphics;
     param.m_matrix = *pMatrix;
-    param.m_pWidget = m_pInterface;
+    param.m_pWidget = this;
     param.m_iPart = CFWL_Part::CombTextLine;
     param.m_pPath = &path;
     pTheme->DrawBackground(&param);
   }
   pGraphics->RestoreGraphState();
 }
 
-void CFWL_EditImp::UpdateEditEngine() {
+void IFWL_Edit::UpdateEditEngine() {
   UpdateEditParams();
   UpdateEditLayout();
   if (m_nLimit > -1) {
     m_pEdtEngine->SetLimit(m_nLimit);
   }
 }
-void CFWL_EditImp::UpdateEditParams() {
+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;
   }
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VerticalLayout) {
     params.dwLayoutStyles |= FDE_TEXTEDITLAYOUT_DocVertical;
   }
@@ skipping 95 matching lines @@
     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);
 }
 
-void CFWL_EditImp::UpdateEditLayout() {
+void IFWL_Edit::UpdateEditLayout() {
   if (m_pEdtEngine->GetTextLength() <= 0)
     m_pEdtEngine->SetTextByStream(nullptr);
 
   IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
   if (pPage)
     pPage->UnloadPage(nullptr);
 
   m_pEdtEngine->StartLayout();
   m_pEdtEngine->DoLayout(nullptr);
   m_pEdtEngine->EndLayout();
   pPage = m_pEdtEngine->GetPage(0);
   if (pPage)
     pPage->LoadPage(nullptr, nullptr);
 }
 
-FX_BOOL CFWL_EditImp::UpdateOffset() {
+FX_BOOL IFWL_Edit::UpdateOffset() {
   CFX_RectF rtCaret;
   m_pEdtEngine->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);
     if (!pPage)
       return FALSE;
@@ skipping 23 matching lines @@
     offsetY = rtCaret.bottom() - rtEidt.bottom();
   if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_HSelfAdaption))
     m_fScrollOffsetX += offsetX;
   if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VSelfAdaption))
     m_fScrollOffsetY += offsetY;
   if (m_fFontSize > m_rtEngine.height)
     m_fScrollOffsetY = 0;
   return TRUE;
 }
 
-FX_BOOL CFWL_EditImp::UpdateOffset(IFWL_ScrollBar* pScrollBar,
-                                   FX_FLOAT fPosChanged) {
+FX_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 CFWL_EditImp::UpdateVAlignment() {
+void IFWL_Edit::UpdateVAlignment() {
   IFDE_TxtEdtPage* pPage = m_pEdtEngine->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) {
@@ skipping 17 matching lines @@
     fOffsetY = (m_rtEngine.height - rtFDE.height);
     fOffsetY -= fSpaceBelow;
   } else {
     fOffsetY += fSpaceAbove;
   }
   m_fVAlignOffset = fOffsetY;
   if (m_fVAlignOffset < 0) {
     m_fVAlignOffset = 0;
   }
 }
-void CFWL_EditImp::UpdateCaret() {
+void IFWL_Edit::UpdateCaret() {
   CFX_RectF rtFDE;
   m_pEdtEngine->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);
@@ skipping 16 matching lines @@
       temp.bottom() > m_rtEngine.bottom()) {
     bShowWhole = TRUE;
   } else {
     bShow = (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused && bIntersect);
   }
   if (bShowWhole) {
     rtCaret = temp;
   }
   ShowCaret(bShow, &rtCaret);
 }
-IFWL_ScrollBar* CFWL_EditImp::UpdateScroll() {
+IFWL_ScrollBar* IFWL_Edit::UpdateScroll() {
   FX_BOOL bShowHorz =
       m_pHorzScrollBar &&
       ((m_pHorzScrollBar->GetStates() & FWL_WGTSTATE_Invisible) == 0);
   FX_BOOL bShowVert =
       m_pVertScrollBar &&
       ((m_pVertScrollBar->GetStates() & FWL_WGTSTATE_Invisible) == 0);
   if (!bShowHorz && !bShowVert) {
     return nullptr;
   }
   IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
@@ skipping 62 matching lines @@
       m_pVertScrollBar->LockUpdate();
       m_pVertScrollBar->SetRange(0, -1);
       m_pVertScrollBar->SetStates(FWL_WGTSTATE_Disabled, TRUE);
       m_pVertScrollBar->UnlockUpdate();
       m_pVertScrollBar->Update();
       pRepaint = m_pVertScrollBar.get();
     }
   }
   return pRepaint;
 }
-FX_BOOL CFWL_EditImp::IsShowScrollBar(FX_BOOL bVert) {
+FX_BOOL IFWL_Edit::IsShowScrollBar(FX_BOOL bVert) {
   FX_BOOL bShow =
       (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ShowScrollbarFocus)
           ? (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) ==
                 FWL_WGTSTATE_Focused
           : 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);
 }
-FX_BOOL CFWL_EditImp::IsContentHeightOverflow() {
+FX_BOOL IFWL_Edit::IsContentHeightOverflow() {
   if (!m_pEdtEngine)
     return FALSE;
   IFDE_TxtEdtPage* pPage = m_pEdtEngine->GetPage(0);
   if (!pPage)
     return FALSE;
   return pPage->GetContentsBox().height > m_rtEngine.height + 1.0f;
 }
-int32_t CFWL_EditImp::AddDoRecord(IFDE_TxtEdtDoRecord* pRecord) {
+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--;
     }
   } else {
     m_DoRecords.erase(m_DoRecords.begin() + m_iCurRecord + 1,
                       m_DoRecords.end());
   }
 
   m_DoRecords.push_back(std::unique_ptr<IFDE_TxtEdtDoRecord>(pRecord));
   m_iCurRecord = pdfium::CollectionSize<int32_t>(m_DoRecords) - 1;
   return m_iCurRecord;
 }
-void CFWL_EditImp::Layout() {
+void IFWL_Edit::Layout() {
   GetClientRect(m_rtClient);
   m_rtEngine = m_rtClient;
   FX_FLOAT* pfWidth = static_cast<FX_FLOAT*>(
       GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
   if (!pfWidth)
     return;
   FX_FLOAT fWidth = *pfWidth;
   if (!m_pOuter) {
     CFX_RectF* pUIMargin = static_cast<CFX_RectF*>(
         GetThemeCapacity(CFWL_WidgetCapacity::UIMargin));
@@ skipping 48 matching lines @@
       }
       m_rtEngine.height -= fWidth;
     }
     m_pHorzScrollBar->SetWidgetRect(rtHoriScr);
     m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, FALSE);
     m_pHorzScrollBar->Update();
   } else if (m_pHorzScrollBar) {
     m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, TRUE);
   }
 }
-void CFWL_EditImp::LayoutScrollBar() {
+void IFWL_Edit::LayoutScrollBar() {
   if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ShowScrollbarFocus) ==
       0) {
     return;
   }
   FX_FLOAT* pfWidth = nullptr;
   FX_BOOL bShowVertScrollbar = IsShowScrollBar(TRUE);
   FX_BOOL bShowHorzScrollbar = IsShowScrollBar(FALSE);
   if (bShowVertScrollbar) {
     if (!m_pVertScrollBar) {
       pfWidth = static_cast<FX_FLOAT*>(
@@ skipping 42 matching lines @@
     }
     m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, FALSE);
   } else if (m_pHorzScrollBar) {
     m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, TRUE);
   }
   if (bShowVertScrollbar || bShowHorzScrollbar) {
     UpdateScroll();
   }
 }
 
-void CFWL_EditImp::DeviceToEngine(CFX_PointF& pt) {
+void IFWL_Edit::DeviceToEngine(CFX_PointF& pt) {
   pt.x += m_fScrollOffsetX - m_rtEngine.left;
   pt.y += m_fScrollOffsetY - m_rtEngine.top - m_fVAlignOffset;
 }
 
-void CFWL_EditImp::InitScrollBar(FX_BOOL bVert) {
+void IFWL_Edit::InitScrollBar(FX_BOOL bVert) {
   if ((bVert && m_pVertScrollBar) || (!bVert && m_pHorzScrollBar)) {
     return;
   }
   CFWL_WidgetImpProperties prop;
   prop.m_dwStyleExes = bVert ? FWL_STYLEEXT_SCB_Vert : FWL_STYLEEXT_SCB_Horz;
   prop.m_dwStates = FWL_WGTSTATE_Disabled | FWL_WGTSTATE_Invisible;
-  prop.m_pParent = m_pInterface;
+  prop.m_pParent = this;
   prop.m_pThemeProvider = m_pProperties->m_pThemeProvider;
-  IFWL_ScrollBar* pScrollBar = IFWL_ScrollBar::Create(prop, m_pInterface);
+  IFWL_ScrollBar* pScrollBar = IFWL_ScrollBar::Create(prop, this);
   pScrollBar->Initialize();
   (bVert ? &m_pVertScrollBar : &m_pHorzScrollBar)->reset(pScrollBar);
 }
 
-void CFWL_EditImp::InitEngine() {
+void IFWL_Edit::InitEngine() {
   if (!m_pEdtEngine)
     m_pEdtEngine.reset(new CFDE_TxtEdtEngine);
 }
 
 FX_BOOL FWL_ShowCaret(IFWL_Widget* pWidget,
                       FX_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();
   if (!pDocEnvironment)
     return FALSE;
 
   if (bVisible) {
     CFX_Matrix mt;
     pXFAWidget->GetRotateMatrix(mt);
     CFX_RectF rt(*pRtAnchor);
     mt.TransformRect(rt);
     pDocEnvironment->DisplayCaret(pXFAWidget, bVisible, &rt);
     return TRUE;
   }
   pDocEnvironment->DisplayCaret(pXFAWidget, bVisible, pRtAnchor);
   return TRUE;
 }
 
-void CFWL_EditImp::ShowCaret(FX_BOOL bVisible, CFX_RectF* pRect) {
+void IFWL_Edit::ShowCaret(FX_BOOL bVisible, CFX_RectF* pRect) {
   if (m_pCaret) {
     m_pCaret->ShowCaret(bVisible);
     if (bVisible && !pRect->IsEmpty()) {
       m_pCaret->SetWidgetRect(*pRect);
     }
     Repaint(&m_rtEngine);
   } else {
-    IFWL_Widget* pOuter = m_pInterface;
+    IFWL_Widget* pOuter = this;
     if (bVisible) {
       pRect->Offset(m_pProperties->m_rtWidget.left,
                     m_pProperties->m_rtWidget.top);
     }
     while (pOuter->GetOuter()) {
       pOuter = pOuter->GetOuter();
       if (bVisible) {
         CFX_RectF rtOuter;
         pOuter->GetWidgetRect(rtOuter);
         pRect->Offset(rtOuter.left, rtOuter.top);
       }
     }
     FWL_ShowCaret(pOuter, bVisible, pRect);
   }
 }
-FX_BOOL CFWL_EditImp::ValidateNumberChar(FX_WCHAR cNum) {
+FX_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);
   if (wsText.IsEmpty()) {
     if (cNum == L'0') {
@@ skipping 14 matching lines @@
     if (wsNew.GetInteger() <= m_iMax) {
       return TRUE;
     }
   } else {
     if (wsText.GetInteger() <= m_iMax) {
       return TRUE;
     }
   }
   return FALSE;
 }
-void CFWL_EditImp::InitCaret() {
+void IFWL_Edit::InitCaret() {
   if (!m_pCaret) {
     if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_InnerCaret)) {
       CFWL_WidgetImpProperties prop;
-      m_pCaret.reset(IFWL_Caret::Create(prop, m_pInterface));
+      m_pCaret.reset(IFWL_Caret::Create(prop, this));
       m_pCaret->Initialize();
-      m_pCaret->SetParent(m_pInterface);
+      m_pCaret->SetParent(this);
       m_pCaret->SetStates(m_pProperties->m_dwStates);
     }
   } else if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_InnerCaret) ==
              0) {
     m_pCaret.reset();
   }
 }
 
-void CFWL_EditImp::ClearRecord() {
+void IFWL_Edit::ClearRecord() {
   m_iCurRecord = -1;
   m_DoRecords.clear();
 }
 
-void CFWL_EditImp::ProcessInsertError(int32_t iError) {
+void IFWL_Edit::ProcessInsertError(int32_t iError) {
   switch (iError) {
     case -2: {
       CFWL_EvtEdtTextFull textFullEvent;
-      textFullEvent.m_pSrcTarget = m_pInterface;
+      textFullEvent.m_pSrcTarget = this;
       DispatchEvent(&textFullEvent);
       break;
     }
     default: {}
   }
 }
 
-CFWL_EditImpDelegate::CFWL_EditImpDelegate(CFWL_EditImp* pOwner)
+CFWL_EditImpDelegate::CFWL_EditImpDelegate(IFWL_Edit* pOwner)
     : m_pOwner(pOwner) {}
 
 void CFWL_EditImpDelegate::OnProcessMessage(CFWL_Message* pMessage) {
   if (!pMessage)
     return;
 
   CFWL_MessageType dwMsgCode = pMessage->GetClassID();
   switch (dwMsgCode) {
     case CFWL_MessageType::Activate: {
       DoActivate(static_cast<CFWL_MsgActivate*>(pMessage));
@@ skipping 37 matching lines @@
       break;
     }
     case CFWL_MessageType::Key: {
       CFWL_MsgKey* pKey = static_cast<CFWL_MsgKey*>(pMessage);
       if (pKey->m_dwCmd == FWL_KeyCommand::KeyDown)
         OnKeyDown(pKey);
       else if (pKey->m_dwCmd == FWL_KeyCommand::Char)
         OnChar(pKey);
       break;
     }
-    default: {
-      break;
-    }
+    default: { break; }
   }
   CFWL_WidgetImpDelegate::OnProcessMessage(pMessage);
 }
 
 void CFWL_EditImpDelegate::OnProcessEvent(CFWL_Event* pEvent) {
   if (!pEvent)
     return;
   if (pEvent->GetClassID() != CFWL_EventType::Scroll)
     return;
 
@@ skipping 364 matching lines @@
     }
     CFX_RectF rect;
     m_pOwner->GetWidgetRect(rect);
     CFX_RectF rtInvalidate;
     rtInvalidate.Set(0, 0, rect.width + 2, rect.height + 2);
     m_pOwner->Repaint(&rtInvalidate);
   }
   return TRUE;
 }
 void CFWL_EditImpDelegate::DoCursor(CFWL_MsgMouse* pMsg) {}