Cleanup FWL default values part II.

xfa/fwl/core/cfwl_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/cfwl_edit.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 95 matching lines @@
         rect.height += kEditMargin;
       }
     }
     return;
   }
 
   rect.Set(0, 0, 0, 0);
 
   int32_t iTextLen = m_EdtEngine.GetTextLength();
   if (iTextLen > 0) {
-    CFX_WideString wsText = m_EdtEngine.GetText(0);
+    CFX_WideString wsText = m_EdtEngine.GetText(0, -1);
     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_Widget::GetWidgetRect(rect, true);
 }
 
 void CFWL_Edit::SetStates(uint32_t dwStates) {
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Invisible) ||
@@ skipping 163 matching lines @@
 }
 
 void CFWL_Edit::SetText(const CFX_WideString& wsText) {
   m_EdtEngine.SetText(wsText);
 }
 
 int32_t CFWL_Edit::GetTextLength() const {
   return m_EdtEngine.GetTextLength();
 }
 
-CFX_WideString CFWL_Edit::GetText(int32_t nStart, int32_t nCount) const {
-  return m_EdtEngine.GetText(nStart, nCount);
+CFX_WideString CFWL_Edit::GetText() const {
+  return m_EdtEngine.GetText(0, -1);
 }
 
 void CFWL_Edit::ClearText() {
   m_EdtEngine.ClearText();
 }
 
-void CFWL_Edit::AddSelRange(int32_t nStart, int32_t nCount) {
-  m_EdtEngine.AddSelRange(nStart, nCount);
+void CFWL_Edit::AddSelRange(int32_t nStart) {
+  m_EdtEngine.AddSelRange(nStart, -1);
 }
 
 int32_t CFWL_Edit::CountSelRanges() const {
   return m_EdtEngine.CountSelRanges();
 }
 
-int32_t CFWL_Edit::GetSelRange(int32_t nIndex, int32_t& nStart) const {
+int32_t CFWL_Edit::GetSelRange(int32_t nIndex, int32_t* nStart) const {
   return m_EdtEngine.GetSelRange(nIndex, nStart);
 }
 
 void CFWL_Edit::ClearSelections() {
   m_EdtEngine.ClearSelection();
 }
 
 int32_t CFWL_Edit::GetLimit() const {
   return m_nLimit;
 }
 
 void CFWL_Edit::SetLimit(int32_t nLimit) {
   m_nLimit = nLimit;
   m_EdtEngine.SetLimit(nLimit);
 }
 
 void CFWL_Edit::SetAliasChar(FX_WCHAR wAlias) {
   m_EdtEngine.SetAliasChar(wAlias);
 }
 
 bool CFWL_Edit::Copy(CFX_WideString& wsCopy) {
   int32_t nCount = m_EdtEngine.CountSelRanges();
   if (nCount == 0)
     return false;
 
   wsCopy.clear();
-  CFX_WideString wsTemp;
-  int32_t nStart, nLength;
+  int32_t nStart;
+  int32_t nLength;
   for (int32_t i = 0; i < nCount; i++) {
-    nLength = m_EdtEngine.GetSelRange(i, nStart);
-    wsTemp = m_EdtEngine.GetText(nStart, nLength);
-    wsCopy += wsTemp;
-    wsTemp.clear();
+    nLength = m_EdtEngine.GetSelRange(i, &nStart);
+    wsCopy += m_EdtEngine.GetText(nStart, nLength);
   }
   return true;
 }
 
 bool CFWL_Edit::Cut(CFX_WideString& wsCut) {
   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_EdtEngine.GetSelRange(i, nStart);
+    nLength = m_EdtEngine.GetSelRange(i, &nStart);
     wsTemp = m_EdtEngine.GetText(nStart, nLength);
     wsCut += wsTemp;
     wsTemp.clear();
   }
   m_EdtEngine.Delete(0);
   return true;
 }
 
 bool CFWL_Edit::Paste(const CFX_WideString& wsPaste) {
   int32_t nCaret = m_EdtEngine.GetCaretPos();
@@ skipping 35 matching lines @@
 }
 
 bool CFWL_Edit::CanRedo() {
   return m_iCurRecord < pdfium::CollectionSize<int32_t>(m_DoRecords) - 1;
 }
 
 void CFWL_Edit::SetOuter(CFWL_Widget* pOuter) {
   m_pOuter = pOuter;
 }
 
-void CFWL_Edit::On_CaretChanged(CFDE_TxtEdtEngine* pEdit,
-                                int32_t nPage,
-                                bool bVisible) {
+void CFWL_Edit::OnCaretChanged() {
   if (m_rtEngine.IsEmpty())
     return;
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) == 0)
     return;
 
   bool bRepaintContent = UpdateOffset();
   UpdateCaret();
   CFX_RectF rtInvalid;
   rtInvalid.Set(0, 0, 0, 0);
   bool bRepaintScroll = false;
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine) {
     CFWL_ScrollBar* pScroll = UpdateScroll();
     if (pScroll) {
       pScroll->GetWidgetRect(rtInvalid, false);
       bRepaintScroll = true;
     }
   }
   if (bRepaintContent || bRepaintScroll) {
     if (bRepaintContent)
       rtInvalid.Union(m_rtEngine);
     Repaint(&rtInvalid);
   }
 }
 
-void CFWL_Edit::On_TextChanged(CFDE_TxtEdtEngine* pEdit,
-                               FDE_TXTEDT_TEXTCHANGE_INFO& ChangeInfo) {
+void CFWL_Edit::OnTextChanged(const FDE_TXTEDT_TEXTCHANGE_INFO& ChangeInfo) {
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VAlignMask)
     UpdateVAlignment();
 
   CFX_RectF rtTemp;
   GetClientRect(rtTemp);
 
   CFWL_EvtTextChanged event(this);
   event.wsPrevText = ChangeInfo.wsPrevText;
   DispatchEvent(&event);
 
   LayoutScrollBar();
   Repaint(&rtTemp);
 }
 
-void CFWL_Edit::On_SelChanged(CFDE_TxtEdtEngine* pEdit) {
+void CFWL_Edit::OnSelChanged() {
   CFX_RectF rtTemp;
   GetClientRect(rtTemp);
   Repaint(&rtTemp);
 }
 
-bool CFWL_Edit::On_PageLoad(CFDE_TxtEdtEngine* pEdit,
-                            int32_t nPageIndex,
-                            int32_t nPurpose) {
+bool CFWL_Edit::OnPageLoad(int32_t nPageIndex) {
   IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(nPageIndex);
   if (!pPage)
     return false;
 
   pPage->LoadPage(nullptr, nullptr);
   return true;
 }
 
-bool CFWL_Edit::On_PageUnload(CFDE_TxtEdtEngine* pEdit,
-                              int32_t nPageIndex,
-                              int32_t nPurpose) {
+bool CFWL_Edit::OnPageUnload(int32_t nPageIndex) {
   IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(nPageIndex);
   if (!pPage)
     return false;
 
   pPage->UnloadPage(nullptr);
   return true;
 }
 
-void CFWL_Edit::On_AddDoRecord(CFDE_TxtEdtEngine* pEdit,
-                               IFDE_TxtEdtDoRecord* pRecord) {
-  AddDoRecord(pRecord);
+void CFWL_Edit::OnAddDoRecord(std::unique_ptr<IFDE_TxtEdtDoRecord> pRecord) {
+  AddDoRecord(std::move(pRecord));
 }
 
-bool CFWL_Edit::On_Validate(CFDE_TxtEdtEngine* pEdit, CFX_WideString& wsText) {
+bool CFWL_Edit::OnValidate(const CFX_WideString& wsText) {
   CFWL_Widget* pDst = GetOuter();
   if (!pDst)
     pDst = this;
 
   CFWL_EvtValidate event(this);
   event.wsInsert = wsText;
   event.bValidate = true;
   DispatchEvent(&event);
   return event.bValidate;
 }
@@ skipping 70 matching lines @@
   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_EdtEngine.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);
     }
 
@@ skipping 387 matching lines @@
          (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine);
 }
 
 bool CFWL_Edit::IsContentHeightOverflow() {
   IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
   if (!pPage)
     return false;
   return pPage->GetContentsBox().height > m_rtEngine.height + 1.0f;
 }
 
-int32_t CFWL_Edit::AddDoRecord(IFDE_TxtEdtDoRecord* pRecord) {
+int32_t CFWL_Edit::AddDoRecord(std::unique_ptr<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_DoRecords.push_back(std::move(pRecord));
   m_iCurRecord = pdfium::CollectionSize<int32_t>(m_DoRecords) - 1;
   return m_iCurRecord;
 }
 
 void CFWL_Edit::Layout() {
   GetClientRect(m_rtClient);
   m_rtEngine = m_rtClient;
   FX_FLOAT* pfWidth = static_cast<FX_FLOAT*>(
       GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
   if (!pfWidth)
@@ skipping 15 matching lines @@
             &part, CFWL_WidgetCapacity::UIMargin));
     if (pUIMargin) {
       m_rtEngine.Deflate(pUIMargin->left, pUIMargin->top, pUIMargin->width,
                          pUIMargin->height);
     }
   }
 
   bool bShowVertScrollbar = IsShowScrollBar(true);
   bool bShowHorzScrollbar = IsShowScrollBar(false);
   if (bShowVertScrollbar) {
-    InitScrollBar();
+    InitVerticalScrollBar();
 
     CFX_RectF rtVertScr;
     if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
       rtVertScr.Set(m_rtClient.right() + kEditMargin, m_rtClient.top, fWidth,
                     m_rtClient.height);
     } else {
       rtVertScr.Set(m_rtClient.right() - fWidth, m_rtClient.top, fWidth,
                     m_rtClient.height);
       if (bShowHorzScrollbar)
         rtVertScr.height -= fWidth;
       m_rtEngine.width -= fWidth;
     }
 
     m_pVertScrollBar->SetWidgetRect(rtVertScr);
     m_pVertScrollBar->RemoveStates(FWL_WGTSTATE_Invisible);
     m_pVertScrollBar->Update();
   } else if (m_pVertScrollBar) {
     m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible);
   }
 
   if (bShowHorzScrollbar) {
-    InitScrollBar(false);
+    InitHorizontalScrollBar();
 
     CFX_RectF rtHoriScr;
     if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
       rtHoriScr.Set(m_rtClient.left, m_rtClient.bottom() + kEditMargin,
                     m_rtClient.width, fWidth);
     } else {
       rtHoriScr.Set(m_rtClient.left, m_rtClient.bottom() - fWidth,
                     m_rtClient.width, fWidth);
       if (bShowVertScrollbar)
         rtHoriScr.width -= fWidth;
@@ skipping 14 matching lines @@
   }
 
   FX_FLOAT* pfWidth = nullptr;
   bool bShowVertScrollbar = IsShowScrollBar(true);
   bool bShowHorzScrollbar = IsShowScrollBar(false);
   if (bShowVertScrollbar) {
     if (!m_pVertScrollBar) {
       pfWidth = static_cast<FX_FLOAT*>(
           GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
       FX_FLOAT fWidth = pfWidth ? *pfWidth : 0;
-      InitScrollBar();
+      InitVerticalScrollBar();
       CFX_RectF rtVertScr;
       if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
         rtVertScr.Set(m_rtClient.right() + kEditMargin, m_rtClient.top, fWidth,
                       m_rtClient.height);
       } else {
         rtVertScr.Set(m_rtClient.right() - fWidth, m_rtClient.top, fWidth,
                       m_rtClient.height);
         if (bShowHorzScrollbar)
           rtVertScr.height -= fWidth;
       }
       m_pVertScrollBar->SetWidgetRect(rtVertScr);
       m_pVertScrollBar->Update();
     }
     m_pVertScrollBar->RemoveStates(FWL_WGTSTATE_Invisible);
   } else if (m_pVertScrollBar) {
     m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible);
   }
 
   if (bShowHorzScrollbar) {
     if (!m_pHorzScrollBar) {
       if (!pfWidth) {
         pfWidth = static_cast<FX_FLOAT*>(
             GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
       }
 
       FX_FLOAT fWidth = pfWidth ? *pfWidth : 0;
-      InitScrollBar(false);
+      InitHorizontalScrollBar();
       CFX_RectF rtHoriScr;
       if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_OuterScrollbar) {
         rtHoriScr.Set(m_rtClient.left, m_rtClient.bottom() + kEditMargin,
                       m_rtClient.width, fWidth);
       } else {
         rtHoriScr.Set(m_rtClient.left, m_rtClient.bottom() - fWidth,
                       m_rtClient.width, fWidth);
         if (bShowVertScrollbar)
           rtHoriScr.width -= (fWidth);
       }
       m_pHorzScrollBar->SetWidgetRect(rtHoriScr);
       m_pHorzScrollBar->Update();
     }
     m_pHorzScrollBar->RemoveStates(FWL_WGTSTATE_Invisible);
   } else if (m_pHorzScrollBar) {
     m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible);
   }
   if (bShowVertScrollbar || bShowHorzScrollbar)
     UpdateScroll();
 }
 
 void CFWL_Edit::DeviceToEngine(CFX_PointF& pt) {
   pt.x += m_fScrollOffsetX - m_rtEngine.left;
   pt.y += m_fScrollOffsetY - m_rtEngine.top - m_fVAlignOffset;
 }
 
-void CFWL_Edit::InitScrollBar(bool bVert) {
-  if ((bVert && m_pVertScrollBar) || (!bVert && m_pHorzScrollBar))
+void CFWL_Edit::InitVerticalScrollBar() {
+  if (m_pVertScrollBar)
     return;
 
   auto prop = pdfium::MakeUnique<CFWL_WidgetProperties>();
-  prop->m_dwStyleExes = bVert ? FWL_STYLEEXT_SCB_Vert : FWL_STYLEEXT_SCB_Horz;
+  prop->m_dwStyleExes = FWL_STYLEEXT_SCB_Vert;
   prop->m_dwStates = FWL_WGTSTATE_Disabled | FWL_WGTSTATE_Invisible;
   prop->m_pParent = this;
   prop->m_pThemeProvider = m_pProperties->m_pThemeProvider;
+  m_pVertScrollBar =
+      pdfium::MakeUnique<CFWL_ScrollBar>(m_pOwnerApp, std::move(prop), this);
+}
 
-  CFWL_ScrollBar* sb = new CFWL_ScrollBar(m_pOwnerApp, std::move(prop), this);
-  if (bVert)
-    m_pVertScrollBar.reset(sb);
-  else
-    m_pHorzScrollBar.reset(sb);
+void CFWL_Edit::InitHorizontalScrollBar() {
+  if (m_pHorzScrollBar)
+    return;
+
+  auto prop = pdfium::MakeUnique<CFWL_WidgetProperties>();
+  prop->m_dwStyleExes = FWL_STYLEEXT_SCB_Horz;
+  prop->m_dwStates = FWL_WGTSTATE_Disabled | FWL_WGTSTATE_Invisible;
+  prop->m_pParent = this;
+  prop->m_pThemeProvider = m_pProperties->m_pThemeProvider;
+  m_pHorzScrollBar =
+      pdfium::MakeUnique<CFWL_ScrollBar>(m_pOwnerApp, std::move(prop), this);
 }
 
 void CFWL_Edit::ShowCaret(CFX_RectF* pRect) {
   if (m_pCaret) {
     m_pCaret->ShowCaret();
     if (!pRect->IsEmpty())
       m_pCaret->SetWidgetRect(*pRect);
     Repaint(&m_rtEngine);
     return;
   }
@@ skipping 47 matching lines @@
   if (!pDocEnvironment)
     return;
 
   pDocEnvironment->DisplayCaret(pXFAWidget, false, pRect);
 }
 
 bool CFWL_Edit::ValidateNumberChar(FX_WCHAR cNum) {
   if (!m_bSetRange)
     return true;
 
-  CFX_WideString wsText = m_EdtEngine.GetText(0);
+  CFX_WideString wsText = m_EdtEngine.GetText(0, -1);
   if (wsText.IsEmpty()) {
     if (cNum == L'0')
       return false;
     return true;
   }
 
   int32_t caretPos = m_EdtEngine.GetCaretPos();
   if (CountSelRanges() == 0) {
     if (cNum == L'0' && caretPos == 0)
       return false;
@@ skipping 401 matching lines @@
   UpdateOffset(pScrollBar, fPos - iCurPos);
   UpdateCaret();
 
   CFX_RectF rect;
   GetWidgetRect(rect, false);
   CFX_RectF rtInvalidate;
   rtInvalidate.Set(0, 0, rect.width + 2, rect.height + 2);
   Repaint(&rtInvalidate);
   return true;
 }