Index: xfa/fwl/core/cfwl_edit.cpp |
diff --git a/xfa/fwl/core/cfwl_edit.cpp b/xfa/fwl/core/cfwl_edit.cpp |
index e404b1de6a811f2867703f346c300537c891e5cb..99cac68d57d4fa11fca9b7a8371d30aeb882cb6f 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(¶m); |
+ |
+ 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(¶m); |
+} |
+ |
+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(¶m); |
+ } |
+ |
+ 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(¶m); |
+ } |
+ 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; |
} |