Remove IFDE_TxtEdt interfaces where possible.

xfa/fee/fde_txtedtengine.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/fee/fde_txtedtengine.h"
 
 #include <algorithm>
 
 #include "xfa/fde/tto/fde_textout.h"
-#include "xfa/fee/fde_txtedtbuf.h"
 #include "xfa/fee/fde_txtedtparag.h"
-#include "xfa/fee/ifde_txtedtbuf.h"
 #include "xfa/fee/ifde_txtedtengine.h"
 #include "xfa/fee/ifde_txtedtpage.h"
+#include "xfa/fwl/basewidget/fwl_editimp.h"
 
 #define FDE_PAGEWIDTH_MAX 0xFFFF
 #define FDE_TXTPLATESIZE (1024 * 12)
 #define FDE_UNICODE_PARAGRAPH_SPERATOR (0x2029)
 #define FDE_TXTEDT_DORECORD_INS 0
 #define FDE_TXTEDT_DORECORD_DEL 1
 
-IFDE_TxtEdtEngine* IFDE_TxtEdtEngine::Create() {
-  return new CFDE_TxtEdtEngine();
-}
 CFDE_TxtEdtEngine::CFDE_TxtEdtEngine()
     : m_pTextBreak(nullptr),
       m_nPageLineCount(20),
       m_nLineCount(0),
       m_nAnchorPos(-1),
       m_nLayoutPos(0),
       m_fCaretPosReserve(0.0),
       m_nCaret(0),
       m_bBefore(TRUE),
       m_nCaretPage(0),
@@ skipping 27 matching lines @@
 }
 void CFDE_TxtEdtEngine::SetEditParams(const FDE_TXTEDTPARAMS& params) {
   if (!m_pTextBreak)
     m_pTextBreak = new CFX_TxtBreak(FX_TXTBREAKPOLICY_None);
 
   FXSYS_memcpy(&m_Param, &params, sizeof(FDE_TXTEDTPARAMS));
   m_wLineEnd = params.wLineBreakChar;
   m_bAutoLineEnd = (m_Param.nLineEnd == FDE_TXTEDIT_LINEEND_Auto);
   UpdateTxtBreak();
 }
-const FDE_TXTEDTPARAMS* CFDE_TxtEdtEngine::GetEditParams() const {
+FDE_TXTEDTPARAMS* CFDE_TxtEdtEngine::GetEditParams() {
   return &m_Param;
 }
 int32_t CFDE_TxtEdtEngine::CountPages() const {
   if (m_nLineCount == 0) {
     return 0;
   }
   return ((m_nLineCount - 1) / m_nPageLineCount) + 1;
 }
 IFDE_TxtEdtPage* CFDE_TxtEdtEngine::GetPage(int32_t nIndex) {
   if (m_PagePtrArray.GetSize() <= nIndex) {
@@ skipping 237 matching lines @@
   CFX_WideString wsTemp;
   FX_WCHAR* lpBuffer = wsTemp.GetBuffer(nLength);
   FXSYS_memcpy(lpBuffer, lpText, nLength * sizeof(FX_WCHAR));
   ReplaceParagEnd(lpBuffer, nLength, FALSE);
   wsTemp.ReleaseBuffer(nLength);
   FX_BOOL bPart = FALSE;
   if (m_nLimit > 0) {
     int32_t nTotalLength = GetTextBufLength();
     int32_t nCount = m_SelRangePtrArr.GetSize();
     for (int32_t i = 0; i < nCount; i++) {
-      FDE_LPTXTEDTSELRANGE lpSelRange = m_SelRangePtrArr.GetAt(i);
+      FDE_TXTEDTSELRANGE* lpSelRange = m_SelRangePtrArr.GetAt(i);
       nTotalLength -= lpSelRange->nCount;
     }
     int32_t nExpectLength = nTotalLength + nLength;
     if (nTotalLength == m_nLimit) {
       return FDE_TXTEDT_MODIFY_RET_F_Full;
     }
     if (nExpectLength > m_nLimit) {
       nLength -= (nExpectLength - m_nLimit);
       bPart = TRUE;
     }
@@ skipping 188 matching lines @@
   return FDE_TXTEDT_MODIFY_RET_S_Normal;
 }
 void CFDE_TxtEdtEngine::SetLimit(int32_t nLimit) {
   m_nLimit = nLimit;
 }
 void CFDE_TxtEdtEngine::SetAliasChar(FX_WCHAR wcAlias) {
   m_wcAliasChar = wcAlias;
 }
 
 void CFDE_TxtEdtEngine::RemoveSelRange(int32_t nStart, int32_t nCount) {
-  FDE_LPTXTEDTSELRANGE lpTemp = NULL;
+  FDE_TXTEDTSELRANGE* lpTemp = nullptr;
   int32_t nRangeCount = m_SelRangePtrArr.GetSize();
   int32_t i = 0;
   for (i = 0; i < nRangeCount; i++) {
     lpTemp = m_SelRangePtrArr[i];
     if (lpTemp->nStart == nStart && lpTemp->nCount == nCount) {
       delete lpTemp;
       m_SelRangePtrArr.RemoveAt(i);
       return;
     }
   }
 }
 
 void CFDE_TxtEdtEngine::AddSelRange(int32_t nStart, int32_t nCount) {
   if (nCount == -1) {
     nCount = GetTextLength() - nStart;
   }
   int32_t nSize = m_SelRangePtrArr.GetSize();
   if (nSize <= 0) {
-    FDE_LPTXTEDTSELRANGE lpSelRange = new FDE_TXTEDTSELRANGE;
+    FDE_TXTEDTSELRANGE* lpSelRange = new FDE_TXTEDTSELRANGE;
     lpSelRange->nStart = nStart;
     lpSelRange->nCount = nCount;
     m_SelRangePtrArr.Add(lpSelRange);
     m_Param.pEventSink->On_SelChanged(this);
     return;
   }
-  FDE_LPTXTEDTSELRANGE lpTemp = NULL;
+  FDE_TXTEDTSELRANGE* lpTemp = nullptr;
   lpTemp = m_SelRangePtrArr[nSize - 1];
   if (nStart >= lpTemp->nStart + lpTemp->nCount) {
-    FDE_LPTXTEDTSELRANGE lpSelRange = new FDE_TXTEDTSELRANGE;
+    FDE_TXTEDTSELRANGE* lpSelRange = new FDE_TXTEDTSELRANGE;
     lpSelRange->nStart = nStart;
     lpSelRange->nCount = nCount;
     m_SelRangePtrArr.Add(lpSelRange);
     m_Param.pEventSink->On_SelChanged(this);
     return;
   }
   int32_t nEnd = nStart + nCount - 1;
   FX_BOOL bBegin = FALSE;
   int32_t nRangeBgn = 0;
   int32_t nRangeCnt = 0;
@@ skipping 14 matching lines @@
         nRangeBgn = i;
         if (nEnd < nTempBgn) {
           break;
         }
         nRangeCnt = 1;
         bBegin = TRUE;
       }
     }
   }
   if (nRangeCnt == 0) {
-    FDE_LPTXTEDTSELRANGE lpSelRange = new FDE_TXTEDTSELRANGE;
+    FDE_TXTEDTSELRANGE* lpSelRange = new FDE_TXTEDTSELRANGE;
     lpSelRange->nStart = nStart;
     lpSelRange->nCount = nCount;
     m_SelRangePtrArr.InsertAt(nRangeBgn, lpSelRange);
   } else {
     lpTemp = m_SelRangePtrArr[nRangeBgn];
     lpTemp->nStart = nStart;
     lpTemp->nCount = nCount;
     nRangeCnt--;
     nRangeBgn++;
     while (nRangeCnt--) {
       delete m_SelRangePtrArr[nRangeBgn];
       m_SelRangePtrArr.RemoveAt(nRangeBgn);
     }
   }
   m_Param.pEventSink->On_SelChanged(this);
 }
 
 int32_t CFDE_TxtEdtEngine::CountSelRanges() {
   return m_SelRangePtrArr.GetSize();
 }
 int32_t CFDE_TxtEdtEngine::GetSelRange(int32_t nIndex, int32_t& nStart) {
   nStart = m_SelRangePtrArr[nIndex]->nStart;
   return m_SelRangePtrArr[nIndex]->nCount;
 }
 void CFDE_TxtEdtEngine::ClearSelection() {
   int32_t nCount = m_SelRangePtrArr.GetSize();
-  FDE_LPTXTEDTSELRANGE lpRange = NULL;
+  FDE_TXTEDTSELRANGE* lpRange = nullptr;
   int32_t i = 0;
   for (i = 0; i < nCount; i++) {
     lpRange = m_SelRangePtrArr[i];
-    if (lpRange != NULL) {
+    if (lpRange) {
       delete lpRange;
-      lpRange = NULL;
+      lpRange = nullptr;
     }
   }
   m_SelRangePtrArr.RemoveAll();
   if (nCount && m_Param.pEventSink) {
     m_Param.pEventSink->On_SelChanged(this);
   }
 }
 FX_BOOL CFDE_TxtEdtEngine::Redo(const CFX_ByteStringC& bsRedo) {
   if (IsLocked()) {
     return FALSE;
@@ skipping 33 matching lines @@
   m_nLineCount = 0;
   return 0;
 }
 int32_t CFDE_TxtEdtEngine::DoLayout(IFX_Pause* pPause) {
   int32_t nCount = m_ParagPtrArray.GetSize();
   CFDE_TxtEdtParag* pParag = NULL;
   int32_t nLineCount = 0;
   for (; m_nLayoutPos < nCount; m_nLayoutPos++) {
     pParag = m_ParagPtrArray[m_nLayoutPos];
     pParag->CalcLines();
-    nLineCount += pParag->m_nLineCount;
+    nLineCount += pParag->GetLineCount();
     if ((pPause != NULL) && (nLineCount > m_nPageLineCount) &&
         pPause->NeedToPauseNow()) {
       m_nLineCount += nLineCount;
       return (++m_nLayoutPos * 100) / nCount;
     }
   }
   m_nLineCount += nLineCount;
   return 100;
 }
 void CFDE_TxtEdtEngine::EndLayout() {
   UpdatePages();
   int32_t nLength = GetTextLength();
   if (m_nCaret > nLength) {
     m_nCaret = nLength;
   }
   int32_t nIndex = m_nCaret;
   if (!m_bBefore) {
     nIndex--;
   }
   m_rtCaret.Set(0, 0, 1, m_Param.fFontSize);
   Unlock();
 }
 FX_BOOL CFDE_TxtEdtEngine::Optimize(IFX_Pause* pPause) {
   return m_pTxtBuf->Optimize(pPause);
 }
-IFDE_TxtEdtBuf* CFDE_TxtEdtEngine::GetTextBuf() const {
-  return (IFDE_TxtEdtBuf*)m_pTxtBuf;
+CFDE_TxtEdtBuf* CFDE_TxtEdtEngine::GetTextBuf() const {
+  return m_pTxtBuf;
 }
 int32_t CFDE_TxtEdtEngine::GetTextBufLength() const {
   return m_pTxtBuf->GetTextLength() - 1;
 }
 CFX_TxtBreak* CFDE_TxtEdtEngine::GetTextBreak() const {
   return m_pTextBreak;
 }
 int32_t CFDE_TxtEdtEngine::GetLineCount() const {
   return m_nLineCount;
 }
 int32_t CFDE_TxtEdtEngine::GetPageLineCount() const {
   return m_nPageLineCount;
 }
 int32_t CFDE_TxtEdtEngine::CountParags() const {
   return m_ParagPtrArray.GetSize();
 }
-IFDE_TxtEdtParag* CFDE_TxtEdtEngine::GetParag(int32_t nParagIndex) const {
+CFDE_TxtEdtParag* CFDE_TxtEdtEngine::GetParag(int32_t nParagIndex) const {
   return m_ParagPtrArray[nParagIndex];
 }
 IFX_CharIter* CFDE_TxtEdtEngine::CreateCharIter() {
   if (!m_pTxtBuf) {
     return NULL;
   }
   return new CFDE_TxtEdtBufIter((CFDE_TxtEdtBuf*)m_pTxtBuf);
 }
 int32_t CFDE_TxtEdtEngine::Line2Parag(int32_t nStartParag,
                                       int32_t nStartLineofParag,
                                       int32_t nLineIndex,
                                       int32_t& nStartLine) const {
   int32_t nLineTotal = nStartLineofParag;
   int32_t nCount = m_ParagPtrArray.GetSize();
   CFDE_TxtEdtParag* pParag = NULL;
   int32_t i = nStartParag;
   for (; i < nCount; i++) {
     pParag = m_ParagPtrArray[i];
-    nLineTotal += pParag->m_nLineCount;
+    nLineTotal += pParag->GetLineCount();
     if (nLineTotal > nLineIndex) {
       break;
     }
   }
-  nStartLine = nLineTotal - pParag->m_nLineCount;
+  nStartLine = nLineTotal - pParag->GetLineCount();
   return i;
 }
 void CFDE_TxtEdtEngine::GetPreDeleteText(CFX_WideString& wsText,
                                          int32_t nIndex,
                                          int32_t nLength) {
   GetText(wsText, 0, GetTextBufLength());
   wsText.Delete(nIndex, nLength);
 }
 void CFDE_TxtEdtEngine::GetPreInsertText(CFX_WideString& wsText,
                                          int32_t nIndex,
@@ skipping 40 matching lines @@
 }
 void CFDE_TxtEdtEngine::Inner_Insert(int32_t nStart,
                                      const FX_WCHAR* lpText,
                                      int32_t nLength) {
   ASSERT(nLength > 0);
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nStart, ParagPos);
   m_Param.pEventSink->On_PageUnload(this, m_nCaretPage, 0);
   int32_t nParagCount = m_ParagPtrArray.GetSize();
   int32_t i = 0;
-  for (i = ParagPos.nParagIndex + 1; i < nParagCount; i++) {
-    m_ParagPtrArray[i]->m_nCharStart += nLength;
-  }
+  for (i = ParagPos.nParagIndex + 1; i < nParagCount; i++)
+    m_ParagPtrArray[i]->SetStartIndex(m_ParagPtrArray[i]->GetStartIndex() +
+                                      nLength);
+
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
-  int32_t nReserveLineCount = pParag->m_nLineCount;
-  int32_t nReserveCharStart = pParag->m_nCharStart;
+  int32_t nReserveLineCount = pParag->GetLineCount();
+  int32_t nReserveCharStart = pParag->GetStartIndex();
   int32_t nLeavePart = ParagPos.nCharIndex;
-  int32_t nCutPart = pParag->m_nCharCount - ParagPos.nCharIndex;
+  int32_t nCutPart = pParag->GetTextLength() - ParagPos.nCharIndex;
   int32_t nTextStart = 0;
   FX_WCHAR wCurChar = L' ';
   const FX_WCHAR* lpPos = lpText;
   FX_BOOL bFirst = TRUE;
   int32_t nParagIndex = ParagPos.nParagIndex;
   for (i = 0; i < nLength; i++, lpPos++) {
     wCurChar = *lpPos;
     if (wCurChar == m_wLineEnd) {
       if (bFirst) {
-        pParag->m_nCharCount = nLeavePart + (i - nTextStart + 1);
-        pParag->m_nLineCount = -1;
-        nReserveCharStart += pParag->m_nCharCount;
+        pParag->SetTextLength(nLeavePart + (i - nTextStart + 1));
+        pParag->SetLineCount(-1);
+        nReserveCharStart += pParag->GetTextLength();
         bFirst = FALSE;
       } else {
         pParag = new CFDE_TxtEdtParag(this);
-        pParag->m_nLineCount = -1;
-        pParag->m_nCharCount = i - nTextStart + 1;
-        pParag->m_nCharStart = nReserveCharStart;
+        pParag->SetLineCount(-1);
+        pParag->SetTextLength(i - nTextStart + 1);
+        pParag->SetStartIndex(nReserveCharStart);
         m_ParagPtrArray.InsertAt(++nParagIndex, pParag);
-        nReserveCharStart += pParag->m_nCharCount;
+        nReserveCharStart += pParag->GetTextLength();
       }
       nTextStart = i + 1;
     }
   }
   if (bFirst) {
-    pParag->m_nCharCount += nLength;
-    pParag->m_nLineCount = -1;
+    pParag->SetTextLength(pParag->GetTextLength() + nLength);
+    pParag->SetLineCount(-1);
     bFirst = FALSE;
   } else {
     pParag = new CFDE_TxtEdtParag(this);
-    pParag->m_nLineCount = -1;
-    pParag->m_nCharCount = nLength - nTextStart + nCutPart;
-    pParag->m_nCharStart = nReserveCharStart;
+    pParag->SetLineCount(-1);
+    pParag->SetTextLength(nLength - nTextStart + nCutPart);
+    pParag->SetStartIndex(nReserveCharStart);
     m_ParagPtrArray.InsertAt(++nParagIndex, pParag);
   }
   m_pTxtBuf->Insert(nStart, lpText, nLength);
   int32_t nTotalLineCount = 0;
   for (i = ParagPos.nParagIndex; i <= nParagIndex; i++) {
     pParag = m_ParagPtrArray[i];
     pParag->CalcLines();
-    nTotalLineCount += pParag->m_nLineCount;
+    nTotalLineCount += pParag->GetLineCount();
   }
   m_nLineCount += nTotalLineCount - nReserveLineCount;
   m_Param.pEventSink->On_PageLoad(this, m_nCaretPage, 0);
   UpdatePages();
 }
 
 void CFDE_TxtEdtEngine::Inner_DeleteRange(int32_t nStart, int32_t nCount) {
   if (nCount == -1) {
     nCount = m_pTxtBuf->GetTextLength() - nStart;
   }
   int32_t nEnd = nStart + nCount - 1;
   ASSERT(nStart >= 0 && nEnd < m_pTxtBuf->GetTextLength());
   m_Param.pEventSink->On_PageUnload(this, m_nCaretPage, 0);
   FDE_TXTEDTPARAGPOS ParagPosBgn, ParagPosEnd;
   TextPos2ParagPos(nStart, ParagPosBgn);
   TextPos2ParagPos(nEnd, ParagPosEnd);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPosEnd.nParagIndex];
   FX_BOOL bLastParag = FALSE;
-  if (ParagPosEnd.nCharIndex == pParag->m_nCharCount - 1) {
+  if (ParagPosEnd.nCharIndex == pParag->GetTextLength() - 1) {
     if (ParagPosEnd.nParagIndex < m_ParagPtrArray.GetSize() - 1) {
       ParagPosEnd.nParagIndex++;
     } else {
       bLastParag = TRUE;
     }
   }
   int32_t nTotalLineCount = 0;
   int32_t nTotalCharCount = 0;
   int32_t i = 0;
   for (i = ParagPosBgn.nParagIndex; i <= ParagPosEnd.nParagIndex; i++) {
     CFDE_TxtEdtParag* pParag = m_ParagPtrArray[i];
     pParag->CalcLines();
-    nTotalLineCount += pParag->m_nLineCount;
-    nTotalCharCount += pParag->m_nCharCount;
+    nTotalLineCount += pParag->GetLineCount();
+    nTotalCharCount += pParag->GetTextLength();
   }
   m_pTxtBuf->Delete(nStart, nCount);
   int32_t nNextParagIndex = (ParagPosBgn.nCharIndex == 0 && bLastParag)
                                 ? ParagPosBgn.nParagIndex
                                 : (ParagPosBgn.nParagIndex + 1);
   for (i = nNextParagIndex; i <= ParagPosEnd.nParagIndex; i++) {
     CFDE_TxtEdtParag* pParag = m_ParagPtrArray[nNextParagIndex];
     delete pParag;
     m_ParagPtrArray.RemoveAt(nNextParagIndex);
   }
   if (!(bLastParag && ParagPosBgn.nCharIndex == 0)) {
     pParag = m_ParagPtrArray[ParagPosBgn.nParagIndex];
-    pParag->m_nCharCount = nTotalCharCount - nCount;
+    pParag->SetTextLength(nTotalCharCount - nCount);
     pParag->CalcLines();
-    nTotalLineCount -= pParag->m_nLineCount;
+    nTotalLineCount -= pParag->GetTextLength();
   }
   int32_t nParagCount = m_ParagPtrArray.GetSize();
   for (i = nNextParagIndex; i < nParagCount; i++) {
-    m_ParagPtrArray[i]->m_nCharStart -= nCount;
+    m_ParagPtrArray[i]->SetStartIndex(m_ParagPtrArray[i]->GetStartIndex() -

[Tom Sepez, 2016/04/29 15:36:23]

Feels like we should have incrementStatIndex and decrementStartIndex methods to
make this cleaner.

[dsinclair, 2016/05/02 13:36:50]

Done.

+                                      nCount);
   }
   m_nLineCount -= nTotalLineCount;
   UpdatePages();
   int32_t nPageCount = CountPages();
   if (m_nCaretPage >= nPageCount) {
     m_nCaretPage = nPageCount - 1;
   }
   m_Param.pEventSink->On_PageLoad(this, m_nCaretPage, 0);
 }
 void CFDE_TxtEdtEngine::DeleteRange_DoRecord(int32_t nStart,
@@ skipping 32 matching lines @@
   FX_WCHAR wChar = L' ';
   int32_t nParagStart = 0;
   int32_t nIndex = 0;
   IFX_CharIter* pIter = new CFDE_TxtEdtBufIter((CFDE_TxtEdtBuf*)m_pTxtBuf);
   pIter->SetAt(0);
   do {
     wChar = pIter->GetChar();
     nIndex = pIter->GetAt();
     if (wChar == m_wLineEnd) {
       CFDE_TxtEdtParag* pParag = new CFDE_TxtEdtParag(this);
-      pParag->m_nCharStart = nParagStart;
-      pParag->m_nCharCount = nIndex - nParagStart + 1;
-      pParag->m_nLineCount = -1;
+      pParag->SetStartIndex(nParagStart);
+      pParag->SetTextLength(nIndex - nParagStart + 1);
+      pParag->SetLineCount(-1);
       m_ParagPtrArray.Add(pParag);
       nParagStart = nIndex + 1;
     }
   } while (pIter->Next());
   pIter->Release();
 }
 void CFDE_TxtEdtEngine::RemoveAllParags() {
   int32_t nCount = m_ParagPtrArray.GetSize();
   int32_t i = 0;
   for (i = 0; i < nCount; i++) {
@@ skipping 18 matching lines @@
 void CFDE_TxtEdtEngine::UpdateParags() {
   int32_t nCount = m_ParagPtrArray.GetSize();
   if (nCount == 0) {
     return;
   }
   CFDE_TxtEdtParag* pParag = NULL;
   int32_t nLineCount = 0;
   int32_t i = 0;
   for (i = 0; i < nCount; i++) {
     pParag = m_ParagPtrArray[i];
-    if (pParag->m_nLineCount == -1) {
+    if (pParag->GetLineCount() == -1)
       pParag->CalcLines();
-    }
-    nLineCount += pParag->m_nLineCount;
+
+    nLineCount += pParag->GetLineCount();
   }
   m_nLineCount = nLineCount;
 }
 void CFDE_TxtEdtEngine::UpdatePages() {
-  if (m_nLineCount == 0) {
+  if (m_nLineCount == 0)
     return;
-  }
+
   int32_t nPageCount = (m_nLineCount - 1) / (m_nPageLineCount) + 1;
   int32_t nSize = m_PagePtrArray.GetSize();
-  if (nSize == nPageCount) {
+  if (nSize == nPageCount)
     return;
-  }
+
   if (nSize > nPageCount) {
     IFDE_TxtEdtPage* pPage = NULL;
     int32_t i = 0;
     for (i = nSize - 1; i >= nPageCount; i--) {
       pPage = m_PagePtrArray[i];
       if (pPage) {
         pPage->Release();
       }
       m_PagePtrArray.RemoveAt(i);
     }
-    m_Param.pEventSink->On_PageCountChanged(this);
     return;
   }
   if (nSize < nPageCount) {
     IFDE_TxtEdtPage* pPage = NULL;
     int32_t i = 0;
     for (i = nSize; i < nPageCount; i++) {
       pPage = IFDE_TxtEdtPage::Create(this, i);
       m_PagePtrArray.Add(pPage);
     }
-    m_Param.pEventSink->On_PageCountChanged(this);
     return;
   }
 }
 void CFDE_TxtEdtEngine::UpdateTxtBreak() {
   uint32_t dwStyle = m_pTextBreak->GetLayoutStyles();
   if (m_Param.dwMode & FDE_TEXTEDITMODE_MultiLines) {
     dwStyle &= ~FX_TXTLAYOUTSTYLE_SingleLine;
   } else {
     dwStyle |= FX_TXTLAYOUTSTYLE_SingleLine;
   }
@@ skipping 185 matching lines @@
       return m_nCaretPage;
     }
     m_Param.pEventSink->On_PageUnload(this, m_nCaretPage, 0);
   }
   CFDE_TxtEdtParag* pParag = NULL;
   int32_t nLineCount = 0;
   int32_t nParagCount = m_ParagPtrArray.GetSize();
   int32_t i = 0;
   for (i = 0; i < nParagCount; i++) {
     pParag = m_ParagPtrArray[i];
-    if (pParag->m_nCharStart <= nIndex &&
-        nIndex < (pParag->m_nCharStart + pParag->m_nCharCount)) {
+    if (pParag->GetStartIndex() <= nIndex &&
+        nIndex < (pParag->GetStartIndex() + pParag->GetTextLength())) {
       break;
     }
-    nLineCount += pParag->m_nLineCount;
+    nLineCount += pParag->GetLineCount();
   }
   pParag->LoadParag();
   int32_t nLineStart = -1;
   int32_t nLineCharCount = -1;
-  for (i = 0; i < pParag->m_nLineCount; i++) {
+  for (i = 0; i < pParag->GetLineCount(); i++) {
     pParag->GetLineRange(i, nLineStart, nLineCharCount);
     if (nLineStart <= nIndex && nIndex < (nLineStart + nLineCharCount)) {
       break;
     }
   }
-  ASSERT(i < pParag->m_nLineCount);
+  ASSERT(i < pParag->GetLineCount());
   nLineCount += (i + 1);
   m_nCaretPage = (nLineCount - 1) / m_nPageLineCount + 1 - 1;
-  m_Param.pEventSink->On_PageChange(this, m_nCaretPage);
   pParag->UnloadParag();
   return m_nCaretPage;
 }
 void CFDE_TxtEdtEngine::TextPos2ParagPos(int32_t nIndex,
                                          FDE_TXTEDTPARAGPOS& ParagPos) const {
   ASSERT(nIndex >= 0 && nIndex < m_pTxtBuf->GetTextLength());
   int32_t nCount = m_ParagPtrArray.GetSize();
   int32_t nBgn = 0;
   int32_t nMid = 0;
   int32_t nEnd = nCount - 1;
   while (nEnd > nBgn) {
     nMid = (nBgn + nEnd) / 2;
     CFDE_TxtEdtParag* pParag = m_ParagPtrArray[nMid];
-    if (nIndex < pParag->m_nCharStart) {
+    if (nIndex < pParag->GetStartIndex()) {
       nEnd = nMid - 1;
-    } else if (nIndex >= (pParag->m_nCharStart + pParag->m_nCharCount)) {
+    } else if (nIndex >= (pParag->GetStartIndex() + pParag->GetTextLength())) {
       nBgn = nMid + 1;
     } else {
       break;
     }
   }
   if (nBgn == nEnd) {
     nMid = nBgn;
   }
-  ASSERT(nIndex >= m_ParagPtrArray[nMid]->m_nCharStart &&
-         (nIndex < m_ParagPtrArray[nMid]->m_nCharStart +
-                       m_ParagPtrArray[nMid]->m_nCharCount));
+  ASSERT(nIndex >= m_ParagPtrArray[nMid]->GetStartIndex() &&
+         (nIndex < m_ParagPtrArray[nMid]->GetStartIndex() +
+                       m_ParagPtrArray[nMid]->GetTextLength()));
   ParagPos.nParagIndex = nMid;
-  ParagPos.nCharIndex = nIndex - m_ParagPtrArray[nMid]->m_nCharStart;
+  ParagPos.nCharIndex = nIndex - m_ParagPtrArray[nMid]->GetStartIndex();
 }
 int32_t CFDE_TxtEdtEngine::MoveForward(FX_BOOL& bBefore) {
   if (m_nCaret == m_pTxtBuf->GetTextLength() - 1) {
     return -1;
   }
   int32_t nCaret = m_nCaret;
   if ((nCaret + 1 < m_pTxtBuf->GetTextLength()) &&
       (m_pTxtBuf->GetCharByIndex(nCaret) == L'\r') &&
       (m_pTxtBuf->GetCharByIndex(nCaret + 1) == L'\n')) {
     nCaret++;
@@ skipping 31 matching lines @@
       } else {
         if (m_nCaretPage == 0) {
           return FALSE;
         }
       }
       if (bLineReserve) {
         m_nCaretPage++;
       } else {
         m_nCaretPage--;
       }
-      m_Param.pEventSink->On_PageChange(this, m_nCaretPage);
       ptCaret.x -= rtContent.left;
       IFDE_TxtEdtPage* pCurPage = GetPage(m_nCaretPage);
       ptCaret.x += pCurPage->GetContentsBox().right();
     }
   } else {
     ptCaret.x = m_fCaretPosReserve;
     ptCaret.y = m_rtCaret.top + m_rtCaret.height / 2 - m_Param.fLineSpace;
     if (ptCaret.y < rtContent.top) {
       if (m_nCaretPage == 0) {
         return FALSE;
       }
       ptCaret.y -= rtContent.top;
       m_nCaretPage--;
-      m_Param.pEventSink->On_PageChange(this, m_nCaretPage);
       IFDE_TxtEdtPage* pCurPage = GetPage(m_nCaretPage);
       ptCaret.y += pCurPage->GetContentsBox().bottom();
     }
   }
   return TRUE;
 }
 FX_BOOL CFDE_TxtEdtEngine::MoveDown(CFX_PointF& ptCaret) {
   IFDE_TxtEdtPage* pPage = GetPage(m_nCaretPage);
   const CFX_RectF& rtContent = pPage->GetContentsBox();
   if (m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_DocVertical) {
     ptCaret.x = m_rtCaret.left + m_rtCaret.width / 2 + m_Param.fLineSpace;
     ptCaret.y = m_fCaretPosReserve;
     if (ptCaret.x >= rtContent.right()) {
       FX_BOOL bLineReserve =
           m_Param.dwLayoutStyles & FDE_TEXTEDITLAYOUT_LineReserve;
       if (bLineReserve) {
         if (m_nCaretPage == 0) {
           return FALSE;
         }
       } else {
         if (m_nCaretPage == CountPages() - 1) {
           return FALSE;
         }
       }
       if (bLineReserve) {
         m_nCaretPage--;
       } else {
         m_nCaretPage++;
       }
-      m_Param.pEventSink->On_PageChange(this, m_nCaretPage);
       ptCaret.x -= rtContent.right();
       IFDE_TxtEdtPage* pCurPage = GetPage(m_nCaretPage);
       ptCaret.x += pCurPage->GetContentsBox().left;
     }
   } else {
     ptCaret.x = m_fCaretPosReserve;
     ptCaret.y = m_rtCaret.top + m_rtCaret.height / 2 + m_Param.fLineSpace;
     if (ptCaret.y >= rtContent.bottom()) {
       if (m_nCaretPage == CountPages() - 1) {
         return FALSE;
       }
       ptCaret.y -= rtContent.bottom();
       m_nCaretPage++;
-      m_Param.pEventSink->On_PageChange(this, m_nCaretPage);
       IFDE_TxtEdtPage* pCurPage = GetPage(m_nCaretPage);
       ptCaret.y += pCurPage->GetContentsBox().top;
     }
   }
   return TRUE;
 }
 FX_BOOL CFDE_TxtEdtEngine::MoveLineStart() {
   int32_t nIndex = m_bBefore ? m_nCaret : m_nCaret - 1;
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nIndex, ParagPos);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
   pParag->LoadParag();
-  int32_t nLineCount = pParag->m_nLineCount;
+  int32_t nLineCount = pParag->GetLineCount();
   int32_t i = 0;
   int32_t nStart = 0;
   int32_t nCount = 0;
   for (; i < nLineCount; i++) {
     pParag->GetLineRange(i, nStart, nCount);
     if (nIndex >= nStart && nIndex < nStart + nCount) {
       break;
     }
   }
   UpdateCaretRect(nStart, TRUE);
   pParag->UnloadParag();
   return TRUE;
 }
 FX_BOOL CFDE_TxtEdtEngine::MoveLineEnd() {
   int32_t nIndex = m_bBefore ? m_nCaret : m_nCaret - 1;
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nIndex, ParagPos);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
   pParag->LoadParag();
-  int32_t nLineCount = pParag->m_nLineCount;
+  int32_t nLineCount = pParag->GetLineCount();
   int32_t i = 0;
   int32_t nStart = 0;
   int32_t nCount = 0;
   for (; i < nLineCount; i++) {
     pParag->GetLineRange(i, nStart, nCount);
     if (nIndex >= nStart && nIndex < nStart + nCount) {
       break;
     }
   }
   nIndex = nStart + nCount - 1;
@@ skipping 14 matching lines @@
   }
   UpdateCaretRect(nIndex, bBefore);
   pParag->UnloadParag();
   return TRUE;
 }
 FX_BOOL CFDE_TxtEdtEngine::MoveParagStart() {
   int32_t nIndex = m_bBefore ? m_nCaret : m_nCaret - 1;
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nIndex, ParagPos);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
-  UpdateCaretRect(pParag->m_nCharStart, TRUE);
+  UpdateCaretRect(pParag->GetStartIndex(), TRUE);
   return TRUE;
 }
 FX_BOOL CFDE_TxtEdtEngine::MoveParagEnd() {
   int32_t nIndex = m_bBefore ? m_nCaret : m_nCaret - 1;
   FDE_TXTEDTPARAGPOS ParagPos;
   TextPos2ParagPos(nIndex, ParagPos);
   CFDE_TxtEdtParag* pParag = m_ParagPtrArray[ParagPos.nParagIndex];
-  nIndex = pParag->m_nCharStart + pParag->m_nCharCount - 1;
+  nIndex = pParag->GetStartIndex() + pParag->GetTextLength() - 1;
   FX_WCHAR wChar = m_pTxtBuf->GetCharByIndex(nIndex);
   if (wChar == L'\n' && nIndex > 0) {
     nIndex--;
     wChar = m_pTxtBuf->GetCharByIndex(nIndex);
     if (wChar != L'\r') {
       nIndex++;
     }
   }
   UpdateCaretRect(nIndex, TRUE);
   return TRUE;
@@ skipping 102 matching lines @@
 FX_BOOL CFDE_TxtEdtEngine::IsSelect() {
   return m_SelRangePtrArr.GetSize() > 0;
 }
 void CFDE_TxtEdtEngine::DeleteSelect() {
   int32_t nCountRange = CountSelRanges();
   if (nCountRange > 0) {
     int32_t nSelStart;
     int32_t nSelCount;
     while (nCountRange > 0) {
       nSelCount = GetSelRange(--nCountRange, nSelStart);
-      FDE_LPTXTEDTSELRANGE lpTemp = m_SelRangePtrArr[nCountRange];
+      FDE_TXTEDTSELRANGE* lpTemp = m_SelRangePtrArr[nCountRange];
       delete lpTemp;
       m_SelRangePtrArr.RemoveAt(nCountRange);
       DeleteRange_DoRecord(nSelStart, nSelCount, TRUE);
     }
     ClearSelection();
     m_Param.pEventSink->On_TextChanged(this, m_ChangeInfo);
     m_Param.pEventSink->On_SelChanged(this);
     SetCaretPos(nSelStart, TRUE);
     return;
   }
@@ skipping 152 matching lines @@
   int32_t nEngine = 0;
   ArchiveLoader >> nEngine;
   m_pEngine = (CFDE_TxtEdtEngine*)(uintptr_t)nEngine;
   int32_t iSel = 0;
   ArchiveLoader >> iSel;
   m_bSel = !!iSel;
   ArchiveLoader >> m_nIndex;
   ArchiveLoader >> m_nCaret;
   ArchiveLoader >> m_wsRange;
 }