Move xfa/fwl/core to xfa/fwl.

xfa/fwl/cfwl_edit.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
-#include "xfa/fwl/core/cfwl_edit.h"
+#include "xfa/fwl/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_event.h"
-#include "xfa/fwl/core/cfwl_evtcheckword.h"
-#include "xfa/fwl/core/cfwl_evttextchanged.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/fwl/cfwl_app.h"
+#include "xfa/fwl/cfwl_caret.h"
+#include "xfa/fwl/cfwl_event.h"
+#include "xfa/fwl/cfwl_eventcheckword.h"
+#include "xfa/fwl/cfwl_eventtextchanged.h"
+#include "xfa/fwl/cfwl_eventvalidate.h"
+#include "xfa/fwl/cfwl_messagekey.h"
+#include "xfa/fwl/cfwl_messagemouse.h"
+#include "xfa/fwl/cfwl_themebackground.h"
+#include "xfa/fwl/cfwl_themepart.h"
+#include "xfa/fwl/cfwl_widgetmgr.h"
+#include "xfa/fwl/ifwl_themeprovider.h"
 #include "xfa/fxfa/xfa_ffdoc.h"
 #include "xfa/fxfa/xfa_ffwidget.h"
 #include "xfa/fxgraphics/cfx_path.h"
 
 namespace {
 
 const int kEditMargin = 3;
 
 bool FX_EDIT_ISLATINWORD(FX_WCHAR c) {
   return c == 0x2D || (c <= 0x005A && c >= 0x0041) ||
@@ skipping 144 matching lines @@
   }
 }
 
 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(this);
+  CFWL_EventCheckWord checkWordEvent(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();
@@ skipping 225 matching lines @@
   }
 }
 
 void CFWL_Edit::OnTextChanged(const FDE_TXTEDT_TEXTCHANGE_INFO& ChangeInfo) {
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_VAlignMask)
     UpdateVAlignment();
 
   CFX_RectF rtTemp;
   GetClientRect(rtTemp);
 
-  CFWL_EvtTextChanged event(this);
+  CFWL_EventTextChanged event(this);
   event.wsPrevText = ChangeInfo.wsPrevText;
   DispatchEvent(&event);
 
   LayoutScrollBar();
   Repaint(&rtTemp);
 }
 
 void CFWL_Edit::OnSelChanged() {
   CFX_RectF rtTemp;
   GetClientRect(rtTemp);
@@ skipping 20 matching lines @@
 
 void CFWL_Edit::OnAddDoRecord(std::unique_ptr<IFDE_TxtEdtDoRecord> pRecord) {
   AddDoRecord(std::move(pRecord));
 }
 
 bool CFWL_Edit::OnValidate(const CFX_WideString& wsText) {
   CFWL_Widget* pDst = GetOuter();
   if (!pDst)
     pDst = this;
 
-  CFWL_EvtValidate event(this);
+  CFWL_EventValidate event(this);
   event.wsInsert = wsText;
   event.bValidate = true;
   DispatchEvent(&event);
   return event.bValidate;
 }
 
 void CFWL_Edit::SetScrollOffset(FX_FLOAT fScrollOffset) {
   m_fScrollOffsetY = fScrollOffset;
 }
 
@@ skipping 784 matching lines @@
     return;
 
   switch (pMessage->GetType()) {
     case CFWL_Message::Type::SetFocus:
       OnFocusChanged(pMessage, true);
       break;
     case CFWL_Message::Type::KillFocus:
       OnFocusChanged(pMessage, false);
       break;
     case CFWL_Message::Type::Mouse: {
-      CFWL_MsgMouse* pMsg = static_cast<CFWL_MsgMouse*>(pMessage);
+      CFWL_MessageMouse* pMsg = static_cast<CFWL_MessageMouse*>(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_Message::Type::Key: {
-      CFWL_MsgKey* pKey = static_cast<CFWL_MsgKey*>(pMessage);
+      CFWL_MessageKey* pKey = static_cast<CFWL_MessageKey*>(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->GetType() != CFWL_Event::Type::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);
+    CFWL_EventScroll* pScrollEvent = static_cast<CFWL_EventScroll*>(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) {
+void CFWL_Edit::DoButtonDown(CFWL_MessageMouse* 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;
@@ skipping 31 matching lines @@
   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) {
+void CFWL_Edit::OnLButtonDown(CFWL_MessageMouse* 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) {
+void CFWL_Edit::OnLButtonUp(CFWL_MessageMouse* pMsg) {
   m_bLButtonDown = false;
   SetGrab(false);
 }
 
-void CFWL_Edit::OnButtonDblClk(CFWL_MsgMouse* pMsg) {
+void CFWL_Edit::OnButtonDblClk(CFWL_MessageMouse* 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) {
+void CFWL_Edit::OnMouseMove(CFWL_MessageMouse* 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) {
+void CFWL_Edit::OnKeyDown(CFWL_MessageKey* 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: {
@@ skipping 33 matching lines @@
     }
     case FWL_VKEY_F2:
     case FWL_VKEY_Tab:
     default:
       break;
   }
   if (MoveCaret != MC_MoveNone)
     m_EdtEngine.MoveCaretPos(MoveCaret, bShift, bCtrl);
 }
 
-void CFWL_Edit::OnChar(CFWL_MsgKey* pMsg) {
+void CFWL_Edit::OnChar(CFWL_MessageKey* 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:
@@ skipping 34 matching lines @@
       }
       iError = m_EdtEngine.Insert(nCaret, &c, 1);
       break;
     }
   }
   if (iError < 0)
     ProcessInsertError(iError);
 }
 
 bool CFWL_Edit::OnScroll(CFWL_ScrollBar* pScrollBar,
-                         CFWL_EvtScroll::Code dwCode,
+                         CFWL_EventScroll::Code 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 CFWL_EvtScroll::Code::Min: {
+    case CFWL_EventScroll::Code::Min: {
       fPos = fs.x;
       break;
     }
-    case CFWL_EvtScroll::Code::Max: {
+    case CFWL_EventScroll::Code::Max: {
       fPos = fs.y;
       break;
     }
-    case CFWL_EvtScroll::Code::StepBackward: {
+    case CFWL_EventScroll::Code::StepBackward: {
       fPos -= fStep;
       if (fPos < fs.x + fStep / 2) {
         fPos = fs.x;
       }
       break;
     }
-    case CFWL_EvtScroll::Code::StepForward: {
+    case CFWL_EventScroll::Code::StepForward: {
       fPos += fStep;
       if (fPos > fs.y - fStep / 2) {
         fPos = fs.y;
       }
       break;
     }
-    case CFWL_EvtScroll::Code::PageBackward: {
+    case CFWL_EventScroll::Code::PageBackward: {
       fPos -= pScrollBar->GetPageSize();
       if (fPos < fs.x) {
         fPos = fs.x;
       }
       break;
     }
-    case CFWL_EvtScroll::Code::PageForward: {
+    case CFWL_EventScroll::Code::PageForward: {
       fPos += pScrollBar->GetPageSize();
       if (fPos > fs.y) {
         fPos = fs.y;
       }
       break;
     }
-    case CFWL_EvtScroll::Code::Pos:
-    case CFWL_EvtScroll::Code::TrackPos:
-    case CFWL_EvtScroll::Code::None:
+    case CFWL_EventScroll::Code::Pos:
+    case CFWL_EventScroll::Code::TrackPos:
+    case CFWL_EventScroll::Code::None:
       break;
-    case CFWL_EvtScroll::Code::EndScroll:
+    case CFWL_EventScroll::Code::EndScroll:
       return false;
   }
   if (iCurPos == fPos)
     return true;
 
   pScrollBar->SetPos(fPos);
   pScrollBar->SetTrackPos(fPos);
   UpdateOffset(pScrollBar, fPos - iCurPos);
   UpdateCaret();
 
   CFX_RectF rect = GetWidgetRect();
   CFX_RectF rtInvalidate;
   rtInvalidate.Set(0, 0, rect.width + 2, rect.height + 2);
   Repaint(&rtInvalidate);
   return true;
 }