summaryrefslogtreecommitdiff
path: root/xfa/fwl/core/cfwl_edit.cpp
diff options
context:
space:
mode:
authordsinclair <dsinclair@chromium.org>2016-11-23 16:17:20 -0800
committerCommit bot <commit-bot@chromium.org>2016-11-23 16:17:21 -0800
commit2c489cc41023a40648dfde988d11b8ec2b66c7d0 (patch)
tree78255c80c547a5954ed5778f1a809d3166a5f3e2 /xfa/fwl/core/cfwl_edit.cpp
parent0ce11eef157b791c661d7e82e1c5641605b9f03d (diff)
downloadpdfium-2c489cc41023a40648dfde988d11b8ec2b66c7d0.tar.xz
Merge IFWL and CFWL classes.
This CL merges the IFWL hierarchy into the CFWL hierachy. All CFWL proxy methods have been replaced by the IFWL implementations. Review-Url: https://codereview.chromium.org/2524173002
Diffstat (limited to 'xfa/fwl/core/cfwl_edit.cpp')
-rw-r--r--xfa/fwl/core/cfwl_edit.cpp1633
1 files changed, 1611 insertions, 22 deletions
diff --git a/xfa/fwl/core/cfwl_edit.cpp b/xfa/fwl/core/cfwl_edit.cpp
index e404b1de6a..99cac68d57 100644
--- a/xfa/fwl/core/cfwl_edit.cpp
+++ b/xfa/fwl/core/cfwl_edit.cpp
@@ -6,67 +6,1656 @@
#include "xfa/fwl/core/cfwl_edit.h"
+#include <algorithm>
#include <memory>
+#include <utility>
#include <vector>
#include "third_party/base/ptr_util.h"
+#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/cfgas_gefont.h"
+#include "xfa/fwl/core/cfwl_app.h"
+#include "xfa/fwl/core/cfwl_caret.h"
+#include "xfa/fwl/core/cfwl_evtcheckword.h"
+#include "xfa/fwl/core/cfwl_evttextchanged.h"
+#include "xfa/fwl/core/cfwl_evttextfull.h"
+#include "xfa/fwl/core/cfwl_evtvalidate.h"
+#include "xfa/fwl/core/cfwl_msgkey.h"
+#include "xfa/fwl/core/cfwl_msgmouse.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/ifwl_themeprovider.h"
+#include "xfa/fxfa/xfa_ffdoc.h"
+#include "xfa/fxfa/xfa_ffwidget.h"
+#include "xfa/fxgraphics/cfx_path.h"
namespace {
-IFWL_Edit* ToEdit(IFWL_Widget* widget) {
- return static_cast<IFWL_Edit*>(widget);
+const int kEditMargin = 3;
+
+bool FX_EDIT_ISLATINWORD(FX_WCHAR c) {
+ return c == 0x2D || (c <= 0x005A && c >= 0x0041) ||
+ (c <= 0x007A && c >= 0x0061) || (c <= 0x02AF && c >= 0x00C0) ||
+ c == 0x0027;
+}
+
+void AddSquigglyPath(CFX_Path* pPathData,
+ FX_FLOAT fStartX,
+ FX_FLOAT fEndX,
+ FX_FLOAT fY,
+ FX_FLOAT fStep) {
+ pPathData->MoveTo(fStartX, fY);
+ int i = 1;
+ for (FX_FLOAT fx = fStartX + fStep; fx < fEndX; fx += fStep, ++i)
+ pPathData->LineTo(fx, fY + (i & 1) * fStep);
}
} // namespace
-CFWL_Edit::CFWL_Edit(const CFWL_App* app) : CFWL_Widget(app) {}
+CFWL_Edit::CFWL_Edit(const CFWL_App* app,
+ std::unique_ptr<CFWL_WidgetProperties> properties,
+ CFWL_Widget* pOuter)
+ : CFWL_Widget(app, std::move(properties), pOuter),
+ m_fVAlignOffset(0.0f),
+ m_fScrollOffsetX(0.0f),
+ m_fScrollOffsetY(0.0f),
+ m_bLButtonDown(false),
+ m_nSelStart(0),
+ m_nLimit(-1),
+ m_fFontSize(0),
+ m_bSetRange(false),
+ m_iMax(0xFFFFFFF),
+ m_iCurRecord(-1),
+ m_iMaxRecord(128) {
+ m_rtClient.Reset();
+ m_rtEngine.Reset();
+ m_rtStatic.Reset();
+
+ InitCaret();
+}
+
+CFWL_Edit::~CFWL_Edit() {
+ if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused)
+ ShowCaret(false);
+ ClearRecord();
+}
+
+FWL_Type CFWL_Edit::GetClassID() const {
+ return FWL_Type::Edit;
+}
+
+void CFWL_Edit::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
+ if (!bAutoSize) {
+ 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;
+ }
+
+ rect.Set(0, 0, 0, 0);
+
+ int32_t iTextLen = m_EdtEngine.GetTextLength();
+ if (iTextLen > 0) {
+ CFX_WideString wsText;
+ m_EdtEngine.GetText(wsText, 0);
+ CFX_SizeF sz = CalcTextSize(
+ wsText, m_pProperties->m_pThemeProvider,
+ !!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine));
+ rect.Set(0, 0, sz.x, sz.y);
+ }
+ CFWL_Widget::GetWidgetRect(rect, true);
+}
+
+void CFWL_Edit::SetStates(uint32_t dwStates, bool bSet) {
+ if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Invisible) ||
+ (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
+ ShowCaret(false);
+ }
+ CFWL_Widget::SetStates(dwStates, bSet);
+}
+
+void CFWL_Edit::Update() {
+ if (IsLocked())
+ return;
+ if (!m_pProperties->m_pThemeProvider)
+ m_pProperties->m_pThemeProvider = GetAvailableTheme();
+
+ Layout();
+ if (m_rtClient.IsEmpty())
+ return;
+
+ UpdateEditEngine();
+ UpdateVAlignment();
+ UpdateScroll();
+ InitCaret();
+}
+
+FWL_WidgetHit CFWL_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_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_EdtEngine.GetPage(0);
+ CFX_RectFArray rectArray;
+ CFX_RectF rectText;
+ const FDE_TXTEDTPARAMS* txtEdtParams = m_EdtEngine.GetEditParams();
+ FX_FLOAT fAsent = static_cast<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);
+ }
+}
+
+void CFWL_Edit::DrawSpellCheck(CFX_Graphics* pGraphics,
+ const CFX_Matrix* pMatrix) {
+ pGraphics->SaveGraphState();
+ if (pMatrix)
+ pGraphics->ConcatMatrix(const_cast<CFX_Matrix*>(pMatrix));
+
+ CFX_Color crLine(0xFFFF0000);
+ CFWL_EvtCheckWord checkWordEvent;
+ 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++) {
+ if (FX_EDIT_ISLATINWORD(wsSpell[i])) {
+ if (sLatinWord.IsEmpty())
+ nStart = i;
+ sLatinWord += (FX_CHAR)wsSpell[i];
+ continue;
+ }
+ checkWordEvent.bsWord = sLatinWord;
+ checkWordEvent.bCheckWord = true;
+ DispatchEvent(&checkWordEvent);
-CFWL_Edit::~CFWL_Edit() {}
+ if (!sLatinWord.IsEmpty() && !checkWordEvent.bCheckWord) {
+ AddSpellCheckObj(pathSpell, nStart, sLatinWord.GetLength(), fOffSetX,
+ fOffSetY);
+ }
+ sLatinWord.clear();
+ }
-void CFWL_Edit::Initialize() {
- ASSERT(!m_pIface);
+ checkWordEvent.bsWord = sLatinWord;
+ checkWordEvent.bCheckWord = true;
+ DispatchEvent(&checkWordEvent);
- m_pIface = pdfium::MakeUnique<IFWL_Edit>(
- m_pApp, pdfium::MakeUnique<CFWL_WidgetProperties>(), nullptr);
+ if (!sLatinWord.IsEmpty() && !checkWordEvent.bCheckWord) {
+ AddSpellCheckObj(pathSpell, nStart, sLatinWord.GetLength(), fOffSetX,
+ fOffSetY);
+ }
+ if (!pathSpell.IsEmpty()) {
+ CFX_RectF rtClip = m_rtEngine;
+ CFX_Matrix mt;
+ mt.Set(1, 0, 0, 1, fOffSetX, fOffSetY);
+ if (pMatrix) {
+ pMatrix->TransformRect(rtClip);
+ mt.Concat(*pMatrix);
+ }
+ pGraphics->SetClipRect(rtClip);
+ pGraphics->SetStrokeColor(&crLine);
+ pGraphics->SetLineWidth(0);
+ pGraphics->StrokePath(&pathSpell, nullptr);
+ }
+ pGraphics->RestoreGraphState();
+}
+
+void CFWL_Edit::DrawWidget(CFX_Graphics* pGraphics, const CFX_Matrix* pMatrix) {
+ if (!pGraphics)
+ return;
+ if (!m_pProperties->m_pThemeProvider)
+ return;
+ if (m_rtClient.IsEmpty())
+ return;
+
+ IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
+ if (!m_pWidgetMgr->IsFormDisabled())
+ DrawTextBk(pGraphics, pTheme, pMatrix);
+ 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);
+}
- CFWL_Widget::Initialize();
+void CFWL_Edit::SetThemeProvider(IFWL_ThemeProvider* pThemeProvider) {
+ if (!pThemeProvider)
+ return;
+ if (m_pHorzScrollBar)
+ m_pHorzScrollBar->SetThemeProvider(pThemeProvider);
+ if (m_pVertScrollBar)
+ m_pVertScrollBar->SetThemeProvider(pThemeProvider);
+ if (m_pCaret)
+ m_pCaret->SetThemeProvider(pThemeProvider);
+ m_pProperties->m_pThemeProvider = pThemeProvider;
}
void CFWL_Edit::SetText(const CFX_WideString& wsText) {
- if (GetWidget())
- ToEdit(GetWidget())->SetText(wsText);
+ m_EdtEngine.SetText(wsText);
+}
+
+int32_t CFWL_Edit::GetTextLength() const {
+ return m_EdtEngine.GetTextLength();
}
void CFWL_Edit::GetText(CFX_WideString& wsText,
int32_t nStart,
int32_t nCount) const {
- if (GetWidget())
- ToEdit(GetWidget())->GetText(wsText, nStart, nCount);
+ m_EdtEngine.GetText(wsText, nStart, nCount);
+}
+
+void CFWL_Edit::ClearText() {
+ m_EdtEngine.ClearText();
+}
+
+void CFWL_Edit::AddSelRange(int32_t nStart, int32_t nCount) {
+ m_EdtEngine.AddSelRange(nStart, nCount);
}
int32_t CFWL_Edit::CountSelRanges() const {
- return GetWidget() ? ToEdit(GetWidget())->CountSelRanges() : 0;
+ return m_EdtEngine.CountSelRanges();
}
int32_t CFWL_Edit::GetSelRange(int32_t nIndex, int32_t& nStart) const {
- return GetWidget() ? ToEdit(GetWidget())->GetSelRange(nIndex, nStart) : 0;
+ return m_EdtEngine.GetSelRange(nIndex, nStart);
+}
+
+void CFWL_Edit::ClearSelections() {
+ m_EdtEngine.ClearSelection();
}
int32_t CFWL_Edit::GetLimit() const {
- return GetWidget() ? ToEdit(GetWidget())->GetLimit() : -1;
+ return m_nLimit;
}
void CFWL_Edit::SetLimit(int32_t nLimit) {
- if (GetWidget())
- ToEdit(GetWidget())->SetLimit(nLimit);
+ m_nLimit = nLimit;
+ m_EdtEngine.SetLimit(nLimit);
}
void CFWL_Edit::SetAliasChar(FX_WCHAR wAlias) {
- if (GetWidget())
- ToEdit(GetWidget())->SetAliasChar(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;
+ for (int32_t i = 0; i < nCount; i++) {
+ nLength = m_EdtEngine.GetSelRange(i, nStart);
+ m_EdtEngine.GetText(wsTemp, nStart, nLength);
+ wsCopy += wsTemp;
+ wsTemp.clear();
+ }
+ 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);
+ m_EdtEngine.GetText(wsTemp, 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();
+ int32_t iError =
+ m_EdtEngine.Insert(nCaret, wsPaste.c_str(), wsPaste.GetLength());
+ if (iError < 0) {
+ ProcessInsertError(iError);
+ return false;
+ }
+ return true;
+}
+
+bool CFWL_Edit::Redo(const IFDE_TxtEdtDoRecord* pRecord) {
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_NoRedoUndo)
+ return true;
+ return m_EdtEngine.Redo(pRecord);
+}
+
+bool CFWL_Edit::Undo(const IFDE_TxtEdtDoRecord* pRecord) {
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_NoRedoUndo)
+ return true;
+ return m_EdtEngine.Undo(pRecord);
+}
+
+bool CFWL_Edit::Undo() {
+ if (!CanUndo())
+ return false;
+ return Undo(m_DoRecords[m_iCurRecord--].get());
+}
+
+bool CFWL_Edit::Redo() {
+ if (!CanRedo())
+ return false;
+ return Redo(m_DoRecords[++m_iCurRecord].get());
+}
+
+bool CFWL_Edit::CanUndo() {
+ return m_iCurRecord >= 0;
+}
+
+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) {
+ 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);
+ 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) {
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VAlignMask)
+ UpdateVAlignment();
+
+ CFX_RectF rtTemp;
+ GetClientRect(rtTemp);
+
+ CFWL_EvtTextChanged event;
+ 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_Edit::On_SelChanged(CFDE_TxtEdtEngine* pEdit) {
+ CFX_RectF rtTemp;
+ GetClientRect(rtTemp);
+ Repaint(&rtTemp);
+}
+
+bool CFWL_Edit::On_PageLoad(CFDE_TxtEdtEngine* pEdit,
+ int32_t nPageIndex,
+ int32_t nPurpose) {
+ 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) {
+ 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);
+}
+
+bool CFWL_Edit::On_Validate(CFDE_TxtEdtEngine* pEdit, CFX_WideString& wsText) {
+ CFWL_Widget* pDst = GetOuter();
+ if (!pDst)
+ pDst = this;
+
+ CFWL_EvtValidate event;
+ event.pDstWidget = pDst;
+ event.m_pSrcTarget = this;
+ event.wsInsert = wsText;
+ event.bValidate = true;
+ DispatchEvent(&event);
+ return event.bValidate;
}
void CFWL_Edit::SetScrollOffset(FX_FLOAT fScrollOffset) {
- if (GetWidget())
- ToEdit(GetWidget())->SetScrollOffset(fScrollOffset);
+ m_fScrollOffsetY = fScrollOffset;
+}
+
+void CFWL_Edit::DrawTextBk(CFX_Graphics* pGraphics,
+ IFWL_ThemeProvider* pTheme,
+ const CFX_Matrix* pMatrix) {
+ CFWL_ThemeBackground param;
+ param.m_pWidget = this;
+ param.m_iPart = CFWL_Part::Background;
+ 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_Edit::DrawContent(CFX_Graphics* pGraphics,
+ IFWL_ThemeProvider* pTheme,
+ const CFX_Matrix* pMatrix) {
+ IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
+ if (!pPage)
+ return;
+
+ pGraphics->SaveGraphState();
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_CombText)
+ pGraphics->SaveGraphState();
+
+ CFX_RectF rtClip = m_rtEngine;
+ FX_FLOAT fOffSetX = m_rtEngine.left - m_fScrollOffsetX;
+ FX_FLOAT fOffSetY = m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset;
+ CFX_Matrix mt;
+ mt.Set(1, 0, 0, 1, fOffSetX, fOffSetY);
+ if (pMatrix) {
+ pMatrix->TransformRect(rtClip);
+ mt.Concat(*pMatrix);
+ }
+
+ bool bShowSel = (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_NoHideSel) ||
+ (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused);
+ if (bShowSel) {
+ CFWL_Widget* pForm = m_pWidgetMgr->GetSystemFormWidget(this);
+ if (pForm) {
+ bShowSel = (pForm->GetStates() & FWL_WGTSTATE_Deactivated) !=
+ FWL_WGTSTATE_Deactivated;
+ }
+ }
+
+ 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);
+ int32_t nCharEnd = nCharStart + nCharCount - 1;
+ if (nCharEnd < nPageCharStart || nCharStart > nPageCharEnd)
+ continue;
+
+ int32_t nBgn = std::max(nCharStart, nPageCharStart);
+ int32_t nEnd = std::min(nCharEnd, nPageCharEnd);
+ pPage->CalcRangeRectArray(nBgn - nPageCharStart, nEnd - nBgn + 1,
+ rectArr);
+ }
+
+ int32_t nCount = rectArr.GetSize();
+ CFX_Path path;
+ path.Create();
+ 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 = 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 = this;
+ param.m_iPart = CFWL_Part::CombTextLine;
+ param.m_pPath = &path;
+ pTheme->DrawBackground(&param);
+ }
+ pGraphics->RestoreGraphState();
+}
+
+void CFWL_Edit::UpdateEditEngine() {
+ UpdateEditParams();
+ UpdateEditLayout();
+ if (m_nLimit > -1)
+ m_EdtEngine.SetLimit(m_nLimit);
+}
+
+void CFWL_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;
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VerticalChars)
+ params.dwLayoutStyles |= FDE_TEXTEDITLAYOUT_CharVertial;
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReverseLine)
+ params.dwLayoutStyles |= FDE_TEXTEDITLAYOUT_LineReserve;
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ArabicShapes)
+ params.dwLayoutStyles |= FDE_TEXTEDITLAYOUT_ArabicShapes;
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ExpandTab)
+ params.dwLayoutStyles |= FDE_TEXTEDITLAYOUT_ExpandTab;
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_CombText)
+ params.dwLayoutStyles |= FDE_TEXTEDITLAYOUT_CombText;
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_LastLineHeight)
+ params.dwLayoutStyles |= FDE_TEXTEDITLAYOUT_LastLineHeight;
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_Validate)
+ params.dwMode |= FDE_TEXTEDITMODE_Validate;
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_Password)
+ params.dwMode |= FDE_TEXTEDITMODE_Password;
+
+ switch (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_HAlignMask) {
+ case FWL_STYLEEXT_EDT_HNear: {
+ params.dwAlignment |= FDE_TEXTEDITALIGN_Left;
+ break;
+ }
+ case FWL_STYLEEXT_EDT_HCenter: {
+ params.dwAlignment |= FDE_TEXTEDITALIGN_Center;
+ break;
+ }
+ case FWL_STYLEEXT_EDT_HFar: {
+ params.dwAlignment |= FDE_TEXTEDITALIGN_Right;
+ break;
+ }
+ default:
+ break;
+ }
+ switch (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_HAlignModeMask) {
+ case FWL_STYLEEXT_EDT_Justified: {
+ params.dwAlignment |= FDE_TEXTEDITALIGN_Justified;
+ break;
+ }
+ case FWL_STYLEEXT_EDT_Distributed: {
+ params.dwAlignment |= FDE_TEXTEDITALIGN_Distributed;
+ break;
+ }
+ default: {
+ params.dwAlignment |= FDE_TEXTEDITALIGN_Normal;
+ break;
+ }
+ }
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_MultiLine) {
+ params.dwMode |= FDE_TEXTEDITMODE_MultiLines;
+ if ((m_pProperties->m_dwStyles & FWL_WGTSTYLE_HScroll) == 0 &&
+ (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_AutoHScroll) == 0) {
+ params.dwMode |=
+ FDE_TEXTEDITMODE_AutoLineWrap | FDE_TEXTEDITMODE_LimitArea_Horz;
+ }
+ if ((m_pProperties->m_dwStyles & FWL_WGTSTYLE_VScroll) == 0 &&
+ (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_AutoVScroll) == 0) {
+ params.dwMode |= FDE_TEXTEDITMODE_LimitArea_Vert;
+ } else {
+ params.fPlateHeight = 0x00FFFFFF;
+ }
+ } else if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_AutoHScroll) ==
+ 0) {
+ params.dwMode |= FDE_TEXTEDITMODE_LimitArea_Horz;
+ }
+ if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly) ||
+ (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
+ params.dwMode |= FDE_TEXTEDITMODE_ReadOnly;
+ }
+
+ FX_FLOAT* pFontSize =
+ static_cast<FX_FLOAT*>(GetThemeCapacity(CFWL_WidgetCapacity::FontSize));
+ if (!pFontSize)
+ return;
+
+ m_fFontSize = *pFontSize;
+ uint32_t* pFontColor =
+ static_cast<uint32_t*>(GetThemeCapacity(CFWL_WidgetCapacity::TextColor));
+ if (!pFontColor)
+ return;
+
+ params.dwFontColor = *pFontColor;
+ FX_FLOAT* pLineHeight =
+ static_cast<FX_FLOAT*>(GetThemeCapacity(CFWL_WidgetCapacity::LineHeight));
+ if (!pLineHeight)
+ return;
+
+ params.fLineSpace = *pLineHeight;
+ CFGAS_GEFont* pFont =
+ static_cast<CFGAS_GEFont*>(GetThemeCapacity(CFWL_WidgetCapacity::Font));
+ if (!pFont)
+ return;
+
+ params.pFont = pFont;
+ params.fFontSize = m_fFontSize;
+ params.nLineCount = (int32_t)(params.fPlateHeight / params.fLineSpace);
+ if (params.nLineCount <= 0)
+ params.nLineCount = 1;
+ params.fTabWidth = params.fFontSize * 1;
+ params.bTabEquidistant = true;
+ params.wLineBreakChar = L'\n';
+ params.nCharRotation = 0;
+ params.pEventSink = this;
+ m_EdtEngine.SetEditParams(params);
+}
+
+void CFWL_Edit::UpdateEditLayout() {
+ if (m_EdtEngine.GetTextLength() <= 0)
+ m_EdtEngine.SetTextByStream(nullptr);
+
+ IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
+ if (pPage)
+ pPage->UnloadPage(nullptr);
+
+ m_EdtEngine.StartLayout();
+ m_EdtEngine.DoLayout(nullptr);
+ m_EdtEngine.EndLayout();
+ pPage = m_EdtEngine.GetPage(0);
+ if (pPage)
+ pPage->LoadPage(nullptr, nullptr);
+}
+
+bool CFWL_Edit::UpdateOffset() {
+ CFX_RectF rtCaret;
+ m_EdtEngine.GetCaretRect(rtCaret);
+ FX_FLOAT fOffSetX = m_rtEngine.left - m_fScrollOffsetX;
+ FX_FLOAT fOffSetY = m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset;
+ rtCaret.Offset(fOffSetX, fOffSetY);
+ const CFX_RectF& rtEidt = m_rtEngine;
+ if (rtEidt.Contains(rtCaret)) {
+ IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
+ if (!pPage)
+ return false;
+
+ CFX_RectF rtFDE = pPage->GetContentsBox();
+ rtFDE.Offset(fOffSetX, fOffSetY);
+ if (rtFDE.right() < rtEidt.right() && m_fScrollOffsetX > 0) {
+ m_fScrollOffsetX += rtFDE.right() - rtEidt.right();
+ m_fScrollOffsetX = std::max(m_fScrollOffsetX, 0.0f);
+ }
+ if (rtFDE.bottom() < rtEidt.bottom() && m_fScrollOffsetY > 0) {
+ m_fScrollOffsetY += rtFDE.bottom() - rtEidt.bottom();
+ m_fScrollOffsetY = std::max(m_fScrollOffsetY, 0.0f);
+ }
+ return false;
+ }
+
+ FX_FLOAT offsetX = 0.0;
+ FX_FLOAT offsetY = 0.0;
+ if (rtCaret.left < rtEidt.left)
+ offsetX = rtCaret.left - rtEidt.left;
+ if (rtCaret.right() > rtEidt.right())
+ offsetX = rtCaret.right() - rtEidt.right();
+ if (rtCaret.top < rtEidt.top)
+ offsetY = rtCaret.top - rtEidt.top;
+ if (rtCaret.bottom() > rtEidt.bottom())
+ offsetY = rtCaret.bottom() - rtEidt.bottom();
+ m_fScrollOffsetX += offsetX;
+ m_fScrollOffsetY += offsetY;
+ if (m_fFontSize > m_rtEngine.height)
+ m_fScrollOffsetY = 0;
+ return true;
+}
+
+bool CFWL_Edit::UpdateOffset(CFWL_ScrollBar* pScrollBar, FX_FLOAT fPosChanged) {
+ if (pScrollBar == m_pHorzScrollBar.get())
+ m_fScrollOffsetX += fPosChanged;
+ else
+ m_fScrollOffsetY += fPosChanged;
+ return true;
+}
+
+void CFWL_Edit::UpdateVAlignment() {
+ IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
+ if (!pPage)
+ return;
+
+ const CFX_RectF& rtFDE = pPage->GetContentsBox();
+ FX_FLOAT fOffsetY = 0.0f;
+ FX_FLOAT fSpaceAbove = 0.0f;
+ FX_FLOAT fSpaceBelow = 0.0f;
+ CFX_SizeF* pSpace = static_cast<CFX_SizeF*>(
+ GetThemeCapacity(CFWL_WidgetCapacity::SpaceAboveBelow));
+ if (pSpace) {
+ fSpaceAbove = pSpace->x;
+ fSpaceBelow = pSpace->y;
+ }
+ if (fSpaceAbove < 0.1f)
+ fSpaceAbove = 0;
+ if (fSpaceBelow < 0.1f)
+ fSpaceBelow = 0;
+
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VCenter) {
+ fOffsetY = (m_rtEngine.height - rtFDE.height) / 2;
+ if (fOffsetY < (fSpaceAbove + fSpaceBelow) / 2 &&
+ fSpaceAbove < fSpaceBelow) {
+ return;
+ }
+ fOffsetY += (fSpaceAbove - fSpaceBelow) / 2;
+ } else if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VFar) {
+ fOffsetY = (m_rtEngine.height - rtFDE.height);
+ fOffsetY -= fSpaceBelow;
+ } else {
+ fOffsetY += fSpaceAbove;
+ }
+ m_fVAlignOffset = std::max(fOffsetY, 0.0f);
+}
+
+void CFWL_Edit::UpdateCaret() {
+ CFX_RectF rtFDE;
+ m_EdtEngine.GetCaretRect(rtFDE);
+
+ rtFDE.Offset(m_rtEngine.left - m_fScrollOffsetX,
+ m_rtEngine.top - m_fScrollOffsetY + m_fVAlignOffset);
+ CFX_RectF rtCaret;
+ rtCaret.Set(rtFDE.left, rtFDE.top, rtFDE.width, rtFDE.height);
+
+ CFX_RectF rtClient;
+ GetClientRect(rtClient);
+ rtCaret.Intersect(rtClient);
+
+ if (rtCaret.left > rtClient.right()) {
+ FX_FLOAT right = rtCaret.right();
+ rtCaret.left = rtClient.right() - 1;
+ rtCaret.width = right - rtCaret.left;
+ }
+
+ bool bShow =
+ m_pProperties->m_dwStates & FWL_WGTSTATE_Focused && !rtCaret.IsEmpty();
+ ShowCaret(bShow, &rtCaret);
+}
+
+CFWL_ScrollBar* CFWL_Edit::UpdateScroll() {
+ bool bShowHorz =
+ m_pHorzScrollBar &&
+ ((m_pHorzScrollBar->GetStates() & FWL_WGTSTATE_Invisible) == 0);
+ bool bShowVert =
+ m_pVertScrollBar &&
+ ((m_pVertScrollBar->GetStates() & FWL_WGTSTATE_Invisible) == 0);
+ if (!bShowHorz && !bShowVert)
+ return nullptr;
+
+ IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
+ if (!pPage)
+ return nullptr;
+
+ const CFX_RectF& rtFDE = pPage->GetContentsBox();
+ CFWL_ScrollBar* pRepaint = nullptr;
+ if (bShowHorz) {
+ CFX_RectF rtScroll;
+ m_pHorzScrollBar->GetWidgetRect(rtScroll);
+ if (rtScroll.width < rtFDE.width) {
+ m_pHorzScrollBar->LockUpdate();
+ FX_FLOAT fRange = rtFDE.width - rtScroll.width;
+ m_pHorzScrollBar->SetRange(0.0f, fRange);
+
+ FX_FLOAT fPos = std::min(std::max(m_fScrollOffsetX, 0.0f), fRange);
+ m_pHorzScrollBar->SetPos(fPos);
+ m_pHorzScrollBar->SetTrackPos(fPos);
+ m_pHorzScrollBar->SetPageSize(rtScroll.width);
+ m_pHorzScrollBar->SetStepSize(rtScroll.width / 10);
+ m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Disabled, false);
+ m_pHorzScrollBar->UnlockUpdate();
+ m_pHorzScrollBar->Update();
+ pRepaint = m_pHorzScrollBar.get();
+ } else if ((m_pHorzScrollBar->GetStates() & FWL_WGTSTATE_Disabled) == 0) {
+ m_pHorzScrollBar->LockUpdate();
+ m_pHorzScrollBar->SetRange(0, -1);
+ m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Disabled, true);
+ m_pHorzScrollBar->UnlockUpdate();
+ m_pHorzScrollBar->Update();
+ pRepaint = m_pHorzScrollBar.get();
+ }
+ }
+
+ if (bShowVert) {
+ CFX_RectF rtScroll;
+ m_pVertScrollBar->GetWidgetRect(rtScroll);
+ if (rtScroll.height < rtFDE.height) {
+ m_pVertScrollBar->LockUpdate();
+ FX_FLOAT fStep = m_EdtEngine.GetEditParams()->fLineSpace;
+ FX_FLOAT fRange = std::max(rtFDE.height - m_rtEngine.height, fStep);
+
+ m_pVertScrollBar->SetRange(0.0f, fRange);
+ FX_FLOAT fPos = std::min(std::max(m_fScrollOffsetY, 0.0f), fRange);
+ m_pVertScrollBar->SetPos(fPos);
+ m_pVertScrollBar->SetTrackPos(fPos);
+ m_pVertScrollBar->SetPageSize(rtScroll.height);
+ m_pVertScrollBar->SetStepSize(fStep);
+ m_pVertScrollBar->SetStates(FWL_WGTSTATE_Disabled, false);
+ m_pVertScrollBar->UnlockUpdate();
+ m_pVertScrollBar->Update();
+ pRepaint = m_pVertScrollBar.get();
+ } else if ((m_pVertScrollBar->GetStates() & FWL_WGTSTATE_Disabled) == 0) {
+ 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;
+}
+
+bool CFWL_Edit::IsShowScrollBar(bool bVert) {
+ 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);
+}
+
+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 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_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));
+ if (pUIMargin) {
+ m_rtEngine.Deflate(pUIMargin->left, pUIMargin->top, pUIMargin->width,
+ pUIMargin->height);
+ }
+ } else if (m_pOuter->GetClassID() == FWL_Type::DateTimePicker) {
+ CFWL_ThemePart part;
+ part.m_pWidget = m_pOuter;
+ CFX_RectF* pUIMargin =
+ static_cast<CFX_RectF*>(m_pOuter->GetThemeProvider()->GetCapacity(
+ &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();
+
+ 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->SetStates(FWL_WGTSTATE_Invisible, false);
+ m_pVertScrollBar->Update();
+ } else if (m_pVertScrollBar) {
+ m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
+ }
+
+ if (bShowHorzScrollbar) {
+ InitScrollBar(false);
+
+ 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_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_Edit::LayoutScrollBar() {
+ if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ShowScrollbarFocus) ==
+ 0) {
+ return;
+ }
+
+ 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();
+ 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->SetStates(FWL_WGTSTATE_Invisible, false);
+ } else if (m_pVertScrollBar) {
+ m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
+ }
+
+ if (bShowHorzScrollbar) {
+ if (!m_pHorzScrollBar) {
+ if (!pfWidth) {
+ pfWidth = static_cast<FX_FLOAT*>(
+ GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
+ }
+
+ FX_FLOAT fWidth = pfWidth ? *pfWidth : 0;
+ InitScrollBar(false);
+ 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->SetStates(FWL_WGTSTATE_Invisible, false);
+ } else if (m_pHorzScrollBar) {
+ m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
+ }
+ 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))
+ return;
+
+ auto prop = pdfium::MakeUnique<CFWL_WidgetProperties>();
+ prop->m_dwStyleExes = bVert ? FWL_STYLEEXT_SCB_Vert : FWL_STYLEEXT_SCB_Horz;
+ prop->m_dwStates = FWL_WGTSTATE_Disabled | FWL_WGTSTATE_Invisible;
+ prop->m_pParent = this;
+ prop->m_pThemeProvider = m_pProperties->m_pThemeProvider;
+
+ CFWL_ScrollBar* sb = new CFWL_ScrollBar(m_pOwnerApp, std::move(prop), this);
+ if (bVert)
+ m_pVertScrollBar.reset(sb);
+ else
+ m_pHorzScrollBar.reset(sb);
+}
+
+bool FWL_ShowCaret(CFWL_Widget* pWidget,
+ bool bVisible,
+ const CFX_RectF* pRtAnchor) {
+ CXFA_FFWidget* pXFAWidget =
+ static_cast<CXFA_FFWidget*>(pWidget->GetLayoutItem());
+ if (!pXFAWidget)
+ return false;
+
+ IXFA_DocEnvironment* pDocEnvironment =
+ pXFAWidget->GetDoc()->GetDocEnvironment();
+ 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_Edit::ShowCaret(bool bVisible, CFX_RectF* pRect) {
+ if (m_pCaret) {
+ m_pCaret->ShowCaret(bVisible);
+ if (bVisible && !pRect->IsEmpty())
+ m_pCaret->SetWidgetRect(*pRect);
+ Repaint(&m_rtEngine);
+ return;
+ }
+
+ CFWL_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);
+}
+
+bool CFWL_Edit::ValidateNumberChar(FX_WCHAR cNum) {
+ if (!m_bSetRange)
+ return true;
+
+ CFX_WideString wsOld, wsText;
+ m_EdtEngine.GetText(wsText, 0);
+ 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;
+
+ int32_t nLen = wsText.GetLength();
+ CFX_WideString l = wsText.Mid(0, caretPos);
+ CFX_WideString r = wsText.Mid(caretPos, nLen - caretPos);
+ CFX_WideString wsNew = l + cNum + r;
+ if (wsNew.GetInteger() <= m_iMax)
+ return true;
+ return false;
+ }
+
+ if (wsText.GetInteger() <= m_iMax)
+ return true;
+ return false;
+}
+
+void CFWL_Edit::InitCaret() {
+ if (!m_pCaret) {
+ if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_InnerCaret)) {
+ m_pCaret.reset(new CFWL_Caret(
+ m_pOwnerApp, pdfium::MakeUnique<CFWL_WidgetProperties>(), this));
+ 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_Edit::ClearRecord() {
+ m_iCurRecord = -1;
+ m_DoRecords.clear();
+}
+
+void CFWL_Edit::ProcessInsertError(int32_t iError) {
+ if (iError != -2)
+ return;
+
+ CFWL_EvtTextFull textFullEvent;
+ textFullEvent.m_pSrcTarget = this;
+ DispatchEvent(&textFullEvent);
+}
+
+void CFWL_Edit::OnProcessMessage(CFWL_Message* pMessage) {
+ if (!pMessage)
+ return;
+
+ CFWL_MessageType dwMsgCode = pMessage->GetClassID();
+ switch (dwMsgCode) {
+ case CFWL_MessageType::SetFocus:
+ case CFWL_MessageType::KillFocus:
+ OnFocusChanged(pMessage, dwMsgCode == CFWL_MessageType::SetFocus);
+ break;
+ case CFWL_MessageType::Mouse: {
+ CFWL_MsgMouse* pMsg = static_cast<CFWL_MsgMouse*>(pMessage);
+ switch (pMsg->m_dwCmd) {
+ case FWL_MouseCommand::LeftButtonDown:
+ OnLButtonDown(pMsg);
+ break;
+ case FWL_MouseCommand::LeftButtonUp:
+ OnLButtonUp(pMsg);
+ break;
+ case FWL_MouseCommand::LeftButtonDblClk:
+ OnButtonDblClk(pMsg);
+ break;
+ case FWL_MouseCommand::Move:
+ OnMouseMove(pMsg);
+ break;
+ case FWL_MouseCommand::RightButtonDown:
+ DoButtonDown(pMsg);
+ break;
+ default:
+ break;
+ }
+ 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;
+ }
+ CFWL_Widget::OnProcessMessage(pMessage);
+}
+
+void CFWL_Edit::OnProcessEvent(CFWL_Event* pEvent) {
+ if (!pEvent)
+ return;
+ if (pEvent->GetClassID() != CFWL_EventType::Scroll)
+ return;
+
+ CFWL_Widget* pSrcTarget = pEvent->m_pSrcTarget;
+ if ((pSrcTarget == m_pVertScrollBar.get() && m_pVertScrollBar) ||
+ (pSrcTarget == m_pHorzScrollBar.get() && m_pHorzScrollBar)) {
+ CFWL_EvtScroll* pScrollEvent = static_cast<CFWL_EvtScroll*>(pEvent);
+ OnScroll(static_cast<CFWL_ScrollBar*>(pSrcTarget),
+ pScrollEvent->m_iScrollCode, pScrollEvent->m_fPos);
+ }
+}
+
+void CFWL_Edit::OnDrawWidget(CFX_Graphics* pGraphics,
+ const CFX_Matrix* pMatrix) {
+ DrawWidget(pGraphics, pMatrix);
+}
+
+void CFWL_Edit::DoButtonDown(CFWL_MsgMouse* pMsg) {
+ if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) == 0)
+ SetFocus(true);
+
+ IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
+ if (!pPage)
+ return;
+
+ CFX_PointF pt(pMsg->m_fx, pMsg->m_fy);
+ DeviceToEngine(pt);
+ bool bBefore = true;
+ int32_t nIndex = pPage->GetCharIndex(pt, bBefore);
+ if (nIndex < 0)
+ nIndex = 0;
+
+ m_EdtEngine.SetCaretPos(nIndex, bBefore);
+}
+
+void CFWL_Edit::OnFocusChanged(CFWL_Message* pMsg, bool bSet) {
+ uint32_t dwStyleEx = GetStylesEx();
+ bool bRepaint = !!(dwStyleEx & FWL_STYLEEXT_EDT_InnerCaret);
+ if (bSet) {
+ m_pProperties->m_dwStates |= FWL_WGTSTATE_Focused;
+
+ UpdateVAlignment();
+ UpdateOffset();
+ UpdateCaret();
+ } else if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) {
+ m_pProperties->m_dwStates &= ~FWL_WGTSTATE_Focused;
+ ShowCaret(false);
+ if ((dwStyleEx & FWL_STYLEEXT_EDT_NoHideSel) == 0) {
+ int32_t nSel = CountSelRanges();
+ if (nSel > 0) {
+ ClearSelections();
+ bRepaint = true;
+ }
+ m_EdtEngine.SetCaretPos(0, true);
+ UpdateOffset();
+ }
+ ClearRecord();
+ }
+
+ LayoutScrollBar();
+ if (!bRepaint)
+ return;
+
+ CFX_RectF rtInvalidate;
+ rtInvalidate.Set(0, 0, m_pProperties->m_rtWidget.width,
+ m_pProperties->m_rtWidget.height);
+ Repaint(&rtInvalidate);
+}
+
+void CFWL_Edit::OnLButtonDown(CFWL_MsgMouse* pMsg) {
+ if (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)
+ return;
+
+ m_bLButtonDown = true;
+ SetGrab(true);
+ DoButtonDown(pMsg);
+ int32_t nIndex = m_EdtEngine.GetCaretPos();
+ bool bRepaint = false;
+ if (m_EdtEngine.CountSelRanges() > 0) {
+ m_EdtEngine.ClearSelection();
+ bRepaint = true;
+ }
+
+ if ((pMsg->m_dwFlags & FWL_KEYFLAG_Shift) && m_nSelStart != nIndex) {
+ int32_t iStart = std::min(m_nSelStart, nIndex);
+ int32_t iEnd = std::max(m_nSelStart, nIndex);
+ m_EdtEngine.AddSelRange(iStart, iEnd - iStart);
+ bRepaint = true;
+ } else {
+ m_nSelStart = nIndex;
+ }
+ if (bRepaint)
+ Repaint(&m_rtEngine);
+}
+
+void CFWL_Edit::OnLButtonUp(CFWL_MsgMouse* pMsg) {
+ m_bLButtonDown = false;
+ SetGrab(false);
+}
+
+void CFWL_Edit::OnButtonDblClk(CFWL_MsgMouse* pMsg) {
+ IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
+ if (!pPage)
+ return;
+
+ CFX_PointF pt(pMsg->m_fx, pMsg->m_fy);
+ DeviceToEngine(pt);
+ int32_t nCount = 0;
+ int32_t nIndex = pPage->SelectWord(pt, nCount);
+ if (nIndex < 0)
+ return;
+
+ m_EdtEngine.AddSelRange(nIndex, nCount);
+ m_EdtEngine.SetCaretPos(nIndex + nCount - 1, false);
+ Repaint(&m_rtEngine);
+}
+
+void CFWL_Edit::OnMouseMove(CFWL_MsgMouse* pMsg) {
+ if (m_nSelStart == -1 || !m_bLButtonDown)
+ return;
+
+ IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
+ if (!pPage)
+ return;
+
+ CFX_PointF pt(pMsg->m_fx, pMsg->m_fy);
+ DeviceToEngine(pt);
+ bool bBefore = true;
+ int32_t nIndex = pPage->GetCharIndex(pt, bBefore);
+ m_EdtEngine.SetCaretPos(nIndex, bBefore);
+ nIndex = m_EdtEngine.GetCaretPos();
+ m_EdtEngine.ClearSelection();
+
+ if (nIndex == m_nSelStart)
+ return;
+
+ int32_t nLen = m_EdtEngine.GetTextLength();
+ if (m_nSelStart >= nLen)
+ m_nSelStart = nLen;
+
+ m_EdtEngine.AddSelRange(std::min(m_nSelStart, nIndex),
+ FXSYS_abs(nIndex - m_nSelStart));
+}
+
+void CFWL_Edit::OnKeyDown(CFWL_MsgKey* pMsg) {
+ FDE_TXTEDTMOVECARET MoveCaret = MC_MoveNone;
+ bool bShift = !!(pMsg->m_dwFlags & FWL_KEYFLAG_Shift);
+ bool bCtrl = !!(pMsg->m_dwFlags & FWL_KEYFLAG_Ctrl);
+ uint32_t dwKeyCode = pMsg->m_dwKeyCode;
+ switch (dwKeyCode) {
+ case FWL_VKEY_Left: {
+ MoveCaret = MC_Left;
+ break;
+ }
+ case FWL_VKEY_Right: {
+ MoveCaret = MC_Right;
+ break;
+ }
+ case FWL_VKEY_Up: {
+ MoveCaret = MC_Up;
+ break;
+ }
+ case FWL_VKEY_Down: {
+ MoveCaret = MC_Down;
+ break;
+ }
+ case FWL_VKEY_Home: {
+ MoveCaret = bCtrl ? MC_Home : MC_LineStart;
+ break;
+ }
+ case FWL_VKEY_End: {
+ MoveCaret = bCtrl ? MC_End : MC_LineEnd;
+ break;
+ }
+ case FWL_VKEY_Insert:
+ break;
+ case FWL_VKEY_Delete: {
+ if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly) ||
+ (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
+ break;
+ }
+ int32_t nCaret = m_EdtEngine.GetCaretPos();
+#if (_FX_OS_ == _FX_MACOSX_)
+ m_EdtEngine.Delete(nCaret, true);
+#else
+ m_EdtEngine.Delete(nCaret);
+#endif
+ break;
+ }
+ case FWL_VKEY_F2:
+ break;
+ case FWL_VKEY_Tab: {
+ DispatchKeyEvent(pMsg);
+ break;
+ }
+ default:
+ break;
+ }
+ if (MoveCaret != MC_MoveNone)
+ m_EdtEngine.MoveCaretPos(MoveCaret, bShift, bCtrl);
+}
+
+void CFWL_Edit::OnChar(CFWL_MsgKey* pMsg) {
+ if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ReadOnly) ||
+ (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
+ return;
+ }
+
+ int32_t iError = 0;
+ FX_WCHAR c = static_cast<FX_WCHAR>(pMsg->m_dwKeyCode);
+ int32_t nCaret = m_EdtEngine.GetCaretPos();
+ switch (c) {
+ case FWL_VKEY_Back:
+ m_EdtEngine.Delete(nCaret, true);
+ break;
+ case FWL_VKEY_NewLine:
+ case FWL_VKEY_Escape:
+ break;
+ case FWL_VKEY_Tab: {
+ iError = m_EdtEngine.Insert(nCaret, L"\t", 1);
+ break;
+ }
+ case FWL_VKEY_Return: {
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_WantReturn) {
+ iError = m_EdtEngine.Insert(nCaret, L"\n", 1);
+ }
+ break;
+ }
+ default: {
+ if (!m_pWidgetMgr->IsFormDisabled()) {
+ if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_Number) {
+ if (((pMsg->m_dwKeyCode < FWL_VKEY_0) &&
+ (pMsg->m_dwKeyCode != 0x2E && pMsg->m_dwKeyCode != 0x2D)) ||
+ pMsg->m_dwKeyCode > FWL_VKEY_9) {
+ break;
+ }
+ if (!ValidateNumberChar(c))
+ break;
+ }
+ }
+#if (_FX_OS_ == _FX_MACOSX_)
+ if (pMsg->m_dwFlags & FWL_KEYFLAG_Command)
+#else
+ if (pMsg->m_dwFlags & FWL_KEYFLAG_Ctrl)
+#endif
+ {
+ break;
+ }
+ iError = m_EdtEngine.Insert(nCaret, &c, 1);
+ break;
+ }
+ }
+ if (iError < 0)
+ ProcessInsertError(iError);
+}
+
+bool CFWL_Edit::OnScroll(CFWL_ScrollBar* pScrollBar,
+ FWL_SCBCODE dwCode,
+ FX_FLOAT fPos) {
+ CFX_SizeF fs;
+ pScrollBar->GetRange(&fs.x, &fs.y);
+ FX_FLOAT iCurPos = pScrollBar->GetPos();
+ FX_FLOAT fStep = pScrollBar->GetStepSize();
+ switch (dwCode) {
+ case FWL_SCBCODE::Min: {
+ fPos = fs.x;
+ break;
+ }
+ case FWL_SCBCODE::Max: {
+ fPos = fs.y;
+ break;
+ }
+ case FWL_SCBCODE::StepBackward: {
+ fPos -= fStep;
+ if (fPos < fs.x + fStep / 2) {
+ fPos = fs.x;
+ }
+ break;
+ }
+ case FWL_SCBCODE::StepForward: {
+ fPos += fStep;
+ if (fPos > fs.y - fStep / 2) {
+ fPos = fs.y;
+ }
+ break;
+ }
+ case FWL_SCBCODE::PageBackward: {
+ fPos -= pScrollBar->GetPageSize();
+ if (fPos < fs.x) {
+ fPos = fs.x;
+ }
+ break;
+ }
+ case FWL_SCBCODE::PageForward: {
+ fPos += pScrollBar->GetPageSize();
+ if (fPos > fs.y) {
+ fPos = fs.y;
+ }
+ break;
+ }
+ case FWL_SCBCODE::Pos:
+ case FWL_SCBCODE::TrackPos:
+ case FWL_SCBCODE::None:
+ break;
+ case FWL_SCBCODE::EndScroll:
+ return false;
+ }
+ if (iCurPos == fPos)
+ return true;
+
+ pScrollBar->SetPos(fPos);
+ pScrollBar->SetTrackPos(fPos);
+ UpdateOffset(pScrollBar, fPos - iCurPos);
+ UpdateCaret();
+
+ CFX_RectF rect;
+ GetWidgetRect(rect);
+ CFX_RectF rtInvalidate;
+ rtInvalidate.Set(0, 0, rect.width + 2, rect.height + 2);
+ Repaint(&rtInvalidate);
+ return true;
}