Revert "Replace CPDF_Rect and CPDF_Point with CFX types."

fpdfsdk/src/pdfwindow/PWL_Wnd.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 <map>
 
 #include "fpdfsdk/include/pdfwindow/PWL_ScrollBar.h"
 #include "fpdfsdk/include/pdfwindow/PWL_Utils.h"
@@ skipping 255 matching lines @@
     m_bCreated = FALSE;
   }
 
   DestroyMsgControl();
 
   FXSYS_memset(&m_sPrivateParam, 0, sizeof(PWL_CREATEPARAM));
   m_aChildren.RemoveAll();
   m_pVScrollBar = NULL;
 }
 
-void CPWL_Wnd::Move(const CFX_FloatRect& rcNew,
-                    FX_BOOL bReset,
-                    FX_BOOL bRefresh) {
+void CPWL_Wnd::Move(const CPDF_Rect& rcNew, FX_BOOL bReset, FX_BOOL bRefresh) {
   if (IsValid()) {
-    CFX_FloatRect rcOld = GetWindowRect();
+    CPDF_Rect rcOld = GetWindowRect();
 
     m_rcWindow = rcNew;
     m_rcWindow.Normalize();
 
     if (rcOld.left != rcNew.left || rcOld.right != rcNew.right ||
         rcOld.top != rcNew.top || rcOld.bottom != rcNew.bottom) {
       if (bReset) {
         RePosChildWnd();
       }
     }
     if (bRefresh) {
       InvalidateRectMove(rcOld, rcNew);
     }
 
     m_sPrivateParam.rcRectWnd = m_rcWindow;
   }
 }
 
-void CPWL_Wnd::InvalidateRectMove(const CFX_FloatRect& rcOld,
-                                  const CFX_FloatRect& rcNew) {
-  CFX_FloatRect rcUnion = rcOld;
+void CPWL_Wnd::InvalidateRectMove(const CPDF_Rect& rcOld,
+                                  const CPDF_Rect& rcNew) {
+  CPDF_Rect rcUnion = rcOld;
   rcUnion.Union(rcNew);
 
   InvalidateRect(&rcUnion);
 }
 
 void CPWL_Wnd::GetAppearanceStream(CFX_ByteTextBuf& sAppStream) {
   if (IsValid() && IsVisible()) {
     GetThisAppearanceStream(sAppStream);
     GetChildAppearanceStream(sAppStream);
   }
 }
 
 // if don't set,Get default apperance stream
 void CPWL_Wnd::GetThisAppearanceStream(CFX_ByteTextBuf& sAppStream) {
-  CFX_FloatRect rectWnd = GetWindowRect();
+  CPDF_Rect rectWnd = GetWindowRect();
   if (!rectWnd.IsEmpty()) {
     CFX_ByteTextBuf sThis;
 
     if (HasFlag(PWS_BACKGROUND))
       sThis << CPWL_Utils::GetRectFillAppStream(rectWnd, GetBackgroundColor());
 
     if (HasFlag(PWS_BORDER)) {
       sThis << CPWL_Utils::GetBorderAppStream(
           rectWnd, (FX_FLOAT)GetBorderWidth(), GetBorderColor(),
           GetBorderLeftTopColor(GetBorderStyle()),
@@ skipping 16 matching lines @@
 void CPWL_Wnd::DrawAppearance(CFX_RenderDevice* pDevice,
                               CFX_Matrix* pUser2Device) {
   if (IsValid() && IsVisible()) {
     DrawThisAppearance(pDevice, pUser2Device);
     DrawChildAppearance(pDevice, pUser2Device);
   }
 }
 
 void CPWL_Wnd::DrawThisAppearance(CFX_RenderDevice* pDevice,
                                   CFX_Matrix* pUser2Device) {
-  CFX_FloatRect rectWnd = GetWindowRect();
+  CPDF_Rect rectWnd = GetWindowRect();
   if (!rectWnd.IsEmpty()) {
     if (HasFlag(PWS_BACKGROUND)) {
-      CFX_FloatRect rcClient = CPWL_Utils::DeflateRect(
+      CPDF_Rect rcClient = CPWL_Utils::DeflateRect(
           rectWnd, (FX_FLOAT)(GetBorderWidth() + GetInnerBorderWidth()));
       CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rcClient,
                                GetBackgroundColor(), GetTransparency());
     }
 
     if (HasFlag(PWS_BORDER))
       CPWL_Utils::DrawBorder(pDevice, pUser2Device, rectWnd,
                              (FX_FLOAT)GetBorderWidth(), GetBorderColor(),
                              GetBorderLeftTopColor(GetBorderStyle()),
                              GetBorderRightBottomColor(GetBorderStyle()),
                              GetBorderStyle(), GetTransparency());
   }
 }
 
 void CPWL_Wnd::DrawChildAppearance(CFX_RenderDevice* pDevice,
                                    CFX_Matrix* pUser2Device) {
   for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
     if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
       CFX_Matrix mt = pChild->GetChildMatrix();
       if (mt.IsIdentity()) {
         pChild->DrawAppearance(pDevice, pUser2Device);
       } else {
         mt.Concat(*pUser2Device);
         pChild->DrawAppearance(pDevice, &mt);
       }
     }
   }
 }
 
-void CPWL_Wnd::InvalidateRect(CFX_FloatRect* pRect) {
+void CPWL_Wnd::InvalidateRect(CPDF_Rect* pRect) {
   if (IsValid()) {
-    CFX_FloatRect rcRefresh = pRect ? *pRect : GetWindowRect();
+    CPDF_Rect rcRefresh = pRect ? *pRect : GetWindowRect();
 
     if (!HasFlag(PWS_NOREFRESHCLIP)) {
-      CFX_FloatRect rcClip = GetClipRect();
+      CPDF_Rect rcClip = GetClipRect();
       if (!rcClip.IsEmpty()) {
         rcRefresh.Intersect(rcClip);
       }
     }
 
     FX_RECT rcWin = PWLtoWnd(rcRefresh);
     rcWin.left -= PWL_INVALIDATE_INFLATE;
     rcWin.top -= PWL_INVALIDATE_INFLATE;
     rcWin.right += PWL_INVALIDATE_INFLATE;
     rcWin.bottom += PWL_INVALIDATE_INFLATE;
@@ skipping 16 matching lines @@
               return pChild->key_method_name(nChar, nFlag);            \
             }                                                          \
           }                                                            \
         }                                                              \
       }                                                                \
     }                                                                  \
     return FALSE;                                                      \
   }
 
 #define PWL_IMPLEMENT_MOUSE_METHOD(mouse_method_name)                        \
-  FX_BOOL CPWL_Wnd::mouse_method_name(const CFX_FloatPoint& point,           \
+  FX_BOOL CPWL_Wnd::mouse_method_name(const CPDF_Point& point,               \
                                       FX_DWORD nFlag) {                      \
     if (IsValid() && IsVisible() && IsEnabled()) {                           \
       if (IsWndCaptureMouse(this)) {                                         \
         for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {       \
           if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {                     \
             if (IsWndCaptureMouse(pChild)) {                                 \
               return pChild->mouse_method_name(pChild->ParentToChild(point), \
                                                nFlag);                       \
             }                                                                \
           }                                                                  \
@@ skipping 23 matching lines @@
 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDblClk)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMouseMove)
 
 FX_BOOL CPWL_Wnd::OnMouseWheel(short zDelta,
-                               const CFX_FloatPoint& point,
+                               const CPDF_Point& point,
                                FX_DWORD nFlag) {
   if (IsValid() && IsVisible() && IsEnabled()) {
     SetCursor();
     if (IsWndCaptureKeyboard(this)) {
       for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
         if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
           if (IsWndCaptureKeyboard(pChild)) {
             return pChild->OnMouseWheel(zDelta, pChild->ParentToChild(point),
                                         nFlag);
           }
@@ skipping 40 matching lines @@
 }
 
 const PWL_CREATEPARAM& CPWL_Wnd::GetCreationParam() const {
   return m_sPrivateParam;
 }
 
 CPWL_Wnd* CPWL_Wnd::GetParentWindow() const {
   return m_sPrivateParam.pParentWnd;
 }
 
-CFX_FloatRect CPWL_Wnd::GetWindowRect() const {
+CPDF_Rect CPWL_Wnd::GetWindowRect() const {
   return m_rcWindow;
 }
 
-CFX_FloatRect CPWL_Wnd::GetClientRect() const {
-  CFX_FloatRect rcWindow = GetWindowRect();
-  CFX_FloatRect rcClient = CPWL_Utils::DeflateRect(
+CPDF_Rect CPWL_Wnd::GetClientRect() const {
+  CPDF_Rect rcWindow = GetWindowRect();
+  CPDF_Rect rcClient = CPWL_Utils::DeflateRect(
       rcWindow, (FX_FLOAT)(GetBorderWidth() + GetInnerBorderWidth()));
   if (CPWL_ScrollBar* pVSB = GetVScrollBar())
     rcClient.right -= pVSB->GetScrollBarWidth();
 
   rcClient.Normalize();
-  return rcWindow.Contains(rcClient) ? rcClient : CFX_FloatRect();
+  return rcWindow.Contains(rcClient) ? rcClient : CPDF_Rect();
 }
 
-CFX_FloatPoint CPWL_Wnd::GetCenterPoint() const {
-  CFX_FloatRect rcClient = GetClientRect();
-  return CFX_FloatPoint((rcClient.left + rcClient.right) * 0.5f,
-                        (rcClient.top + rcClient.bottom) * 0.5f);
+CPDF_Point CPWL_Wnd::GetCenterPoint() const {
+  CPDF_Rect rcClient = GetClientRect();
+  return CPDF_Point((rcClient.left + rcClient.right) * 0.5f,
+                    (rcClient.top + rcClient.bottom) * 0.5f);
 }
 
 FX_BOOL CPWL_Wnd::HasFlag(FX_DWORD dwFlags) const {
   return (m_sPrivateParam.dwFlags & dwFlags) != 0;
 }
 
 void CPWL_Wnd::RemoveFlag(FX_DWORD dwFlags) {
   m_sPrivateParam.dwFlags &= ~dwFlags;
 }
 
@@ skipping 115 matching lines @@
   if (CPWL_MsgControl* pMsgCtrl = GetMsgControl()) {
     if (pMsgCtrl->IsWndCaptureKeyboard(this))
       pMsgCtrl->KillFocus();
   }
 }
 
 void CPWL_Wnd::OnSetFocus() {}
 
 void CPWL_Wnd::OnKillFocus() {}
 
-FX_BOOL CPWL_Wnd::WndHitTest(const CFX_FloatPoint& point) const {
+FX_BOOL CPWL_Wnd::WndHitTest(const CPDF_Point& point) const {
   return IsValid() && IsVisible() && GetWindowRect().Contains(point.x, point.y);
 }
 
-FX_BOOL CPWL_Wnd::ClientHitTest(const CFX_FloatPoint& point) const {
+FX_BOOL CPWL_Wnd::ClientHitTest(const CPDF_Point& point) const {
   return IsValid() && IsVisible() && GetClientRect().Contains(point.x, point.y);
 }
 
 const CPWL_Wnd* CPWL_Wnd::GetRootWnd() const {
   if (m_sPrivateParam.pParentWnd)
     return m_sPrivateParam.pParentWnd->GetRootWnd();
 
   return this;
 }
 
 void CPWL_Wnd::SetVisible(FX_BOOL bVisible) {
   if (IsValid()) {
     for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
       if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
         pChild->SetVisible(bVisible);
       }
     }
 
     if (bVisible != m_bVisible) {
       m_bVisible = bVisible;
       RePosChildWnd();
       InvalidateRect();
     }
   }
 }
 
-void CPWL_Wnd::SetClipRect(const CFX_FloatRect& rect) {
+void CPWL_Wnd::SetClipRect(const CPDF_Rect& rect) {
   m_rcClip = rect;
   m_rcClip.Normalize();
 }
 
-const CFX_FloatRect& CPWL_Wnd::GetClipRect() const {
+const CPDF_Rect& CPWL_Wnd::GetClipRect() const {
   return m_rcClip;
 }
 
 FX_BOOL CPWL_Wnd::IsReadOnly() const {
   return HasFlag(PWS_READONLY);
 }
 
 void CPWL_Wnd::RePosChildWnd() {
-  CFX_FloatRect rcContent = CPWL_Utils::DeflateRect(
+  CPDF_Rect rcContent = CPWL_Utils::DeflateRect(
       GetWindowRect(), (FX_FLOAT)(GetBorderWidth() + GetInnerBorderWidth()));
 
   CPWL_ScrollBar* pVSB = GetVScrollBar();
 
-  CFX_FloatRect rcVScroll =
-      CFX_FloatRect(rcContent.right - PWL_SCROLLBAR_WIDTH, rcContent.bottom,
-                    rcContent.right - 1.0f, rcContent.top);
+  CPDF_Rect rcVScroll =
+      CPDF_Rect(rcContent.right - PWL_SCROLLBAR_WIDTH, rcContent.bottom,
+                rcContent.right - 1.0f, rcContent.top);
 
   if (pVSB)
     pVSB->Move(rcVScroll, TRUE, FALSE);
 }
 
 void CPWL_Wnd::CreateChildWnd(const PWL_CREATEPARAM& cp) {}
 
 void CPWL_Wnd::SetCursor() {
   if (IsValid()) {
     if (IFX_SystemHandler* pSH = GetSystemHandler()) {
@@ skipping 36 matching lines @@
   return FALSE;
 }
 
 FX_BOOL CPWL_Wnd::IsFocused() const {
   if (CPWL_MsgControl* pCtrl = GetMsgControl())
     return pCtrl->IsMainCaptureKeyboard(this);
 
   return FALSE;
 }
 
-CFX_FloatRect CPWL_Wnd::GetFocusRect() const {
+CPDF_Rect CPWL_Wnd::GetFocusRect() const {
   return CPWL_Utils::InflateRect(GetWindowRect(), 1);
 }
 
 FX_FLOAT CPWL_Wnd::GetFontSize() const {
   return m_sPrivateParam.fFontSize;
 }
 
 void CPWL_Wnd::SetFontSize(FX_FLOAT fFontSize) {
   m_sPrivateParam.fFontSize = fFontSize;
 }
@@ skipping 74 matching lines @@
   CFX_Matrix mt = GetChildToRoot();
 
   if (IPWL_Provider* pProvider = GetProvider()) {
     mt.Concat(pProvider->GetWindowMatrix(GetAttachedData()));
     return mt;
   }
 
   return mt;
 }
 
-void CPWL_Wnd::PWLtoWnd(const CFX_FloatPoint& point,
-                        int32_t& x,
-                        int32_t& y) const {
+void CPWL_Wnd::PWLtoWnd(const CPDF_Point& point, int32_t& x, int32_t& y) const {
   CFX_Matrix mt = GetWindowMatrix();
-  CFX_FloatPoint pt = point;
+  CPDF_Point pt = point;
   mt.Transform(pt.x, pt.y);
   x = (int32_t)(pt.x + 0.5);
   y = (int32_t)(pt.y + 0.5);
 }
 
-FX_RECT CPWL_Wnd::PWLtoWnd(const CFX_FloatRect& rect) const {
-  CFX_FloatRect rcTemp = rect;
+FX_RECT CPWL_Wnd::PWLtoWnd(const CPDF_Rect& rect) const {
+  CPDF_Rect rcTemp = rect;
   CFX_Matrix mt = GetWindowMatrix();
   mt.TransformRect(rcTemp);
   return FX_RECT((int32_t)(rcTemp.left + 0.5), (int32_t)(rcTemp.bottom + 0.5),
                  (int32_t)(rcTemp.right + 0.5), (int32_t)(rcTemp.top + 0.5));
 }
 
 FX_HWND CPWL_Wnd::GetAttachedHWnd() const {
   return m_sPrivateParam.hAttachedWnd;
 }
 
-CFX_FloatPoint CPWL_Wnd::ChildToParent(const CFX_FloatPoint& point) const {
+CPDF_Point CPWL_Wnd::ChildToParent(const CPDF_Point& point) const {
   CFX_Matrix mt = GetChildMatrix();
   if (mt.IsIdentity())
     return point;
 
-  CFX_FloatPoint pt = point;
+  CPDF_Point pt = point;
   mt.Transform(pt.x, pt.y);
   return pt;
 }
 
-CFX_FloatRect CPWL_Wnd::ChildToParent(const CFX_FloatRect& rect) const {
+CPDF_Rect CPWL_Wnd::ChildToParent(const CPDF_Rect& rect) const {
   CFX_Matrix mt = GetChildMatrix();
   if (mt.IsIdentity())
     return rect;
 
-  CFX_FloatRect rc = rect;
+  CPDF_Rect rc = rect;
   mt.TransformRect(rc);
   return rc;
 }
 
-CFX_FloatPoint CPWL_Wnd::ParentToChild(const CFX_FloatPoint& point) const {
+CPDF_Point CPWL_Wnd::ParentToChild(const CPDF_Point& point) const {
   CFX_Matrix mt = GetChildMatrix();
   if (mt.IsIdentity())
     return point;
 
   mt.SetReverse(mt);
-  CFX_FloatPoint pt = point;
+  CPDF_Point pt = point;
   mt.Transform(pt.x, pt.y);
   return pt;
 }
 
-CFX_FloatRect CPWL_Wnd::ParentToChild(const CFX_FloatRect& rect) const {
+CPDF_Rect CPWL_Wnd::ParentToChild(const CPDF_Rect& rect) const {
   CFX_Matrix mt = GetChildMatrix();
   if (mt.IsIdentity())
     return rect;
 
   mt.SetReverse(mt);
-  CFX_FloatRect rc = rect;
+  CPDF_Rect rc = rect;
   mt.TransformRect(rc);
   return rc;
 }
 
 CFX_Matrix CPWL_Wnd::GetChildToRoot() const {
   CFX_Matrix mt(1, 0, 0, 1, 0, 0);
   if (HasFlag(PWS_CHILD)) {
     const CPWL_Wnd* pParent = this;
     while (pParent) {
       mt.Concat(pParent->GetChildMatrix());
@@ skipping 71 matching lines @@
   return FALSE;
 }
 
 FX_BOOL CPWL_Wnd::IsINSERTpressed(FX_DWORD nFlag) const {
   if (IFX_SystemHandler* pSystemHandler = GetSystemHandler()) {
     return pSystemHandler->IsINSERTKeyDown(nFlag);
   }
 
   return FALSE;
 }