Cleanup IFWL_Widget visibility and virtual parameters

xfa/fwl/core/ifwl_widget.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/ifwl_widget.h"
 
 #include <algorithm>
 
 #include "xfa/fde/tto/fde_textout.h"
 #include "xfa/fwl/core/cfwl_message.h"
 #include "xfa/fwl/core/cfwl_themebackground.h"
 #include "xfa/fwl/core/cfwl_themepart.h"
 #include "xfa/fwl/core/cfwl_themetext.h"
 #include "xfa/fwl/core/cfwl_widgetmgr.h"
 #include "xfa/fwl/core/fwl_noteimp.h"
 #include "xfa/fwl/core/ifwl_app.h"
 #include "xfa/fwl/core/ifwl_combobox.h"
 #include "xfa/fwl/core/ifwl_form.h"
 #include "xfa/fwl/core/ifwl_themeprovider.h"
 #include "xfa/fwl/core/ifwl_widget.h"
 #include "xfa/fxfa/xfa_ffapp.h"
 
 #define FWL_STYLEEXT_MNU_Vert (1L << 0)
+#define FWL_WGT_CalcHeight 2048
+#define FWL_WGT_CalcWidth 2048
+#define FWL_WGT_CalcMultiLineDefWidth 120.0f
 
 IFWL_Widget::IFWL_Widget(const IFWL_App* app,
                          std::unique_ptr<CFWL_WidgetProperties> properties,
                          IFWL_Widget* pOuter)
     : m_pOwnerApp(app),
       m_pWidgetMgr(app->GetWidgetMgr()),
       m_pProperties(std::move(properties)),
       m_pOuter(pOuter),
+      m_iLock(0),
       m_pLayoutItem(nullptr),
       m_pAssociate(nullptr),
-      m_iLock(0),
       m_nEventKey(0),
       m_pDelegate(nullptr) {
   ASSERT(m_pWidgetMgr);
 
   IFWL_Widget* pParent = m_pProperties->m_pParent;
   m_pWidgetMgr->InsertWidget(pParent, this);
   if (IsChild())
     return;
 
   IFWL_Widget* pOwner = m_pProperties->m_pOwner;
   if (pOwner)
     m_pWidgetMgr->SetOwner(pOwner, this);
 }
 
 IFWL_Widget::~IFWL_Widget() {
   NotifyDriver();
   m_pWidgetMgr->RemoveWidget(this);
 }
 
 bool IFWL_Widget::IsInstance(const CFX_WideStringC& wsClass) const {
   return false;
 }
 
-FWL_Error IFWL_Widget::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
+void IFWL_Widget::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
   if (bAutoSize) {
     if (HasEdge()) {
       FX_FLOAT fEdge = GetEdgeWidth();
       rect.Inflate(fEdge, fEdge);
     }
     if (HasBorder()) {
       FX_FLOAT fBorder = GetBorderSize();
       rect.Inflate(fBorder, fBorder);
     }
   } else {
     rect = m_pProperties->m_rtWidget;
   }
-  return FWL_Error::Succeeded;
 }
 
-FWL_Error IFWL_Widget::GetGlobalRect(CFX_RectF& rect) {
+void IFWL_Widget::GetGlobalRect(CFX_RectF& rect) {
   IFWL_Widget* pForm = m_pWidgetMgr->GetSystemFormWidget(this);
   if (!pForm)
-    return FWL_Error::Indefinite;
+    return;
 
   rect.Set(0, 0, m_pProperties->m_rtWidget.width,
            m_pProperties->m_rtWidget.height);
   if (pForm == this)
-    return FWL_Error::Succeeded;
+    return;
 
-  return TransformTo(pForm, rect);
+  TransformTo(pForm, rect.left, rect.top);
 }
 
-FWL_Error IFWL_Widget::SetWidgetRect(const CFX_RectF& rect) {
+void IFWL_Widget::SetWidgetRect(const CFX_RectF& rect) {
   CFX_RectF rtOld = m_pProperties->m_rtWidget;
   m_pProperties->m_rtWidget = rect;
   if (IsChild()) {
     if (FXSYS_fabs(rtOld.width - rect.width) > 0.5f ||
         FXSYS_fabs(rtOld.height - rect.height) > 0.5f) {
       CFWL_EvtSizeChanged ev;
       ev.m_pSrcTarget = this;
       ev.m_rtOld = rtOld;
       ev.m_rtNew = rect;
 
       if (IFWL_WidgetDelegate* pDelegate = GetDelegate())
         pDelegate->OnProcessEvent(&ev);
     }
-    return FWL_Error::Succeeded;
+    return;
   }
   m_pWidgetMgr->SetWidgetRect_Native(this, rect);
-  return FWL_Error::Succeeded;
 }
 
-FWL_Error IFWL_Widget::GetClientRect(CFX_RectF& rect) {
+void IFWL_Widget::GetClientRect(CFX_RectF& rect) {
   GetEdgeRect(rect);
   if (HasEdge()) {
     FX_FLOAT fEdge = GetEdgeWidth();
     rect.Deflate(fEdge, fEdge);
   }
-  return FWL_Error::Succeeded;
 }
 
-IFWL_Widget* IFWL_Widget::GetParent() {
-  return m_pWidgetMgr->GetParentWidget(this);
+void IFWL_Widget::SetParent(IFWL_Widget* pParent) {
+  m_pProperties->m_pParent = pParent;
+  m_pWidgetMgr->SetParent(pParent, this);
 }
 
-FWL_Error IFWL_Widget::SetParent(IFWL_Widget* pParent) {
-  m_pProperties->m_pParent = pParent;
-  m_pWidgetMgr->SetParent(pParent, this);
-  return FWL_Error::Succeeded;
+void IFWL_Widget::ModifyStyles(uint32_t dwStylesAdded,
+                               uint32_t dwStylesRemoved) {
+  m_pProperties->m_dwStyles =
+      (m_pProperties->m_dwStyles & ~dwStylesRemoved) | dwStylesAdded;
 }
 
-IFWL_Widget* IFWL_Widget::GetOwner() {
-  return m_pWidgetMgr->GetOwnerWidget(this);
-}
-
-FWL_Error IFWL_Widget::SetOwner(IFWL_Widget* pOwner) {
-  m_pProperties->m_pOwner = pOwner;
-  m_pWidgetMgr->SetOwner(pOwner, this);
-  return FWL_Error::Succeeded;
-}
-
-IFWL_Widget* IFWL_Widget::GetOuter() {
-  return m_pOuter;
-}
-
-uint32_t IFWL_Widget::GetStyles() {
-  return m_pProperties->m_dwStyles;
-}
-
-FWL_Error IFWL_Widget::ModifyStyles(uint32_t dwStylesAdded,
-                                    uint32_t dwStylesRemoved) {
-  m_pProperties->m_dwStyles =
-      (m_pProperties->m_dwStyles & ~dwStylesRemoved) | dwStylesAdded;
-  return FWL_Error::Succeeded;
-}
-
-uint32_t IFWL_Widget::GetStylesEx() {
-  return m_pProperties->m_dwStyleExes;
-}
-
-FWL_Error IFWL_Widget::ModifyStylesEx(uint32_t dwStylesExAdded,
-                                      uint32_t dwStylesExRemoved) {
+void IFWL_Widget::ModifyStylesEx(uint32_t dwStylesExAdded,
+                                 uint32_t dwStylesExRemoved) {
   m_pProperties->m_dwStyleExes =
       (m_pProperties->m_dwStyleExes & ~dwStylesExRemoved) | dwStylesExAdded;
-  return FWL_Error::Succeeded;
-}
-
-uint32_t IFWL_Widget::GetStates() {
-  return m_pProperties->m_dwStates;
 }
 
 static void NotifyHideChildWidget(CFWL_WidgetMgr* widgetMgr,
                                   IFWL_Widget* widget,
                                   CFWL_NoteDriver* noteDriver) {
   IFWL_Widget* child = widgetMgr->GetFirstChildWidget(widget);
   while (child) {
     noteDriver->NotifyTargetHide(child);
     NotifyHideChildWidget(widgetMgr, child, noteDriver);
     child = widgetMgr->GetNextSiblingWidget(child);
@@ skipping 12 matching lines @@
   noteDriver->NotifyTargetHide(this);
   IFWL_Widget* child = widgetMgr->GetFirstChildWidget(this);
   while (child) {
     noteDriver->NotifyTargetHide(child);
     NotifyHideChildWidget(widgetMgr, child, noteDriver);
     child = widgetMgr->GetNextSiblingWidget(child);
   }
   return;
 }
 
-FWL_Error IFWL_Widget::Update() {
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Widget::LockUpdate() {
-  m_iLock++;
-  return FWL_Error::Succeeded;
-}
-
-FWL_Error IFWL_Widget::UnlockUpdate() {
-  if (IsLocked()) {
-    m_iLock--;
-  }
-  return FWL_Error::Succeeded;
-}
+void IFWL_Widget::Update() {}
 
 FWL_WidgetHit IFWL_Widget::HitTest(FX_FLOAT fx, FX_FLOAT fy) {
   CFX_RectF rtClient;
   GetClientRect(rtClient);
   if (rtClient.Contains(fx, fy))
     return FWL_WidgetHit::Client;
   if (HasEdge()) {
     CFX_RectF rtEdge;
     GetEdgeRect(rtEdge);
     if (rtEdge.Contains(fx, fy))
       return FWL_WidgetHit::Edge;
   }
   if (HasBorder()) {
     CFX_RectF rtRelative;
     GetRelativeRect(rtRelative);
     if (rtRelative.Contains(fx, fy))
       return FWL_WidgetHit::Border;
   }
   return FWL_WidgetHit::Unknown;
 }
 
-FWL_Error IFWL_Widget::TransformTo(IFWL_Widget* pWidget,
-                                   FX_FLOAT& fx,
-                                   FX_FLOAT& fy) {
+void IFWL_Widget::TransformTo(IFWL_Widget* pWidget,
+                              FX_FLOAT& fx,
+                              FX_FLOAT& fy) {
   if (m_pWidgetMgr->IsFormDisabled()) {
     CFX_SizeF szOffset;
     if (IsParent(pWidget)) {
       szOffset = GetOffsetFromParent(pWidget);
     } else {
       szOffset = pWidget->GetOffsetFromParent(this);
       szOffset.x = -szOffset.x;
       szOffset.y = -szOffset.y;
     }
     fx += szOffset.x;
     fy += szOffset.y;
-    return FWL_Error::Succeeded;
+    return;
   }
   CFX_RectF r;
   CFX_Matrix m;
   IFWL_Widget* parent = GetParent();
   if (parent) {
     GetWidgetRect(r);
     fx += r.left;
     fy += r.top;
     GetMatrix(m, true);
     m.TransformPoint(fx, fy);
   }
   IFWL_Widget* form1 = m_pWidgetMgr->GetSystemFormWidget(this);
   if (!form1)
-    return FWL_Error::Indefinite;
+    return;
   if (!pWidget) {
     form1->GetWidgetRect(r);
     fx += r.left;
     fy += r.top;
-    return FWL_Error::Succeeded;
+    return;
   }
   IFWL_Widget* form2 = m_pWidgetMgr->GetSystemFormWidget(pWidget);
   if (!form2)
-    return FWL_Error::Indefinite;
+    return;
   if (form1 != form2) {
     form1->GetWidgetRect(r);
     fx += r.left;
     fy += r.top;
     form2->GetWidgetRect(r);
     fx -= r.left;
     fy -= r.top;
   }
   parent = pWidget->GetParent();
   if (parent) {
     pWidget->GetMatrix(m, true);
     CFX_Matrix m1;
     m1.SetIdentity();
     m1.SetReverse(m);
     m1.TransformPoint(fx, fy);
     pWidget->GetWidgetRect(r);
     fx -= r.left;
     fy -= r.top;
   }
-  return FWL_Error::Succeeded;
 }
 
-FWL_Error IFWL_Widget::TransformTo(IFWL_Widget* pWidget, CFX_RectF& rt) {
-  return TransformTo(pWidget, rt.left, rt.top);
-}
-
-FWL_Error IFWL_Widget::GetMatrix(CFX_Matrix& matrix, bool bGlobal) {
+void IFWL_Widget::GetMatrix(CFX_Matrix& matrix, bool bGlobal) {
   if (!m_pProperties)
-    return FWL_Error::Indefinite;
+    return;
   if (bGlobal) {
     IFWL_Widget* parent = GetParent();
     CFX_ArrayTemplate<IFWL_Widget*> parents;
     while (parent) {
       parents.Add(parent);
       parent = parent->GetParent();
     }
     matrix.SetIdentity();
     CFX_Matrix ctmOnParent;
     CFX_RectF rect;
     int32_t count = parents.GetSize();
     for (int32_t i = count - 2; i >= 0; i--) {
       parent = parents.GetAt(i);
       parent->GetMatrix(ctmOnParent, false);
       parent->GetWidgetRect(rect);
       matrix.Concat(ctmOnParent, true);
       matrix.Translate(rect.left, rect.top, true);
     }
-    matrix.Concat(m_pProperties->m_ctmOnParent, true);
+    CFX_Matrix m;
+    m.SetIdentity();
+    matrix.Concat(m, true);
     parents.RemoveAll();
   } else {
-    matrix = m_pProperties->m_ctmOnParent;
+    matrix.SetIdentity();
   }
-  return FWL_Error::Succeeded;
 }
 
-FWL_Error IFWL_Widget::SetMatrix(const CFX_Matrix& matrix) {
-  if (!m_pProperties)
-    return FWL_Error::Indefinite;
-  IFWL_Widget* parent = GetParent();
-  if (!parent) {
-    return FWL_Error::Indefinite;
-  }
-  m_pProperties->m_ctmOnParent = matrix;
-  return FWL_Error::Succeeded;
-}
+void IFWL_Widget::DrawWidget(CFX_Graphics* pGraphics,
+                             const CFX_Matrix* pMatrix) {}
 
-FWL_Error IFWL_Widget::DrawWidget(CFX_Graphics* pGraphics,
-                                  const CFX_Matrix* pMatrix) {
-  return FWL_Error::Indefinite;
-}
-
-IFWL_ThemeProvider* IFWL_Widget::GetThemeProvider() {
-  return m_pProperties->m_pThemeProvider;
-}
-FWL_Error IFWL_Widget::SetThemeProvider(IFWL_ThemeProvider* pThemeProvider) {
+void IFWL_Widget::SetThemeProvider(IFWL_ThemeProvider* pThemeProvider) {
   m_pProperties->m_pThemeProvider = pThemeProvider;
-  return FWL_Error::Succeeded;
-}
-
-const IFWL_App* IFWL_Widget::GetOwnerApp() const {
-  return m_pOwnerApp;
-}
-
-uint32_t IFWL_Widget::GetEventKey() const {
-  return m_nEventKey;
-}
-
-void IFWL_Widget::SetEventKey(uint32_t key) {
-  m_nEventKey = key;
-}
-
-void* IFWL_Widget::GetLayoutItem() const {
-  return m_pLayoutItem;
-}
-
-void IFWL_Widget::SetLayoutItem(void* pItem) {
-  m_pLayoutItem = pItem;
-}
-
-void IFWL_Widget::SetAssociateWidget(CFWL_Widget* pAssociate) {
-  m_pAssociate = pAssociate;
-}
-bool IFWL_Widget::IsEnabled() const {
-  return (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled) == 0;
-}
-
-bool IFWL_Widget::IsVisible() const {
-  return (m_pProperties->m_dwStates & FWL_WGTSTATE_Invisible) == 0;
-}
-
-bool IFWL_Widget::IsActive() const {
-  return (m_pProperties->m_dwStates & FWL_WGTSTATE_Deactivated) == 0;
-}
-
-bool IFWL_Widget::IsOverLapper() const {
-  return (m_pProperties->m_dwStyles & FWL_WGTSTYLE_WindowTypeMask) ==
-         FWL_WGTSTYLE_OverLapper;
-}
-
-bool IFWL_Widget::IsPopup() const {
-  return !!(m_pProperties->m_dwStyles & FWL_WGTSTYLE_Popup);
-}
-
-bool IFWL_Widget::IsChild() const {
-  return !!(m_pProperties->m_dwStyles & FWL_WGTSTYLE_Child);
-}
-
-bool IFWL_Widget::IsLocked() const {
-  return m_iLock > 0;
-}
-
-bool IFWL_Widget::IsOffscreen() const {
-  return !!(m_pProperties->m_dwStyles & FWL_WGTSTYLE_Offscreen);
-}
-
-bool IFWL_Widget::HasBorder() const {
-  return !!(m_pProperties->m_dwStyles & FWL_WGTSTYLE_Border);
-}
-
-bool IFWL_Widget::HasEdge() const {
-  return !!(m_pProperties->m_dwStyles & FWL_WGTSTYLE_EdgeMask);
 }
 
 void IFWL_Widget::GetEdgeRect(CFX_RectF& rtEdge) {
   rtEdge = m_pProperties->m_rtWidget;
   rtEdge.left = rtEdge.top = 0;
   if (HasBorder()) {
     FX_FLOAT fCX = GetBorderSize();
     FX_FLOAT fCY = GetBorderSize(false);
     rtEdge.Deflate(fCX, fCY);
   }
@@ skipping 65 matching lines @@
 IFWL_Widget* IFWL_Widget::GetRootOuter() {
   IFWL_Widget* pRet = m_pOuter;
   if (!pRet)
     return nullptr;
   while (IFWL_Widget* pOuter = pRet->GetOuter()) {
     pRet = pOuter;
   }
   return pRet;
 }
 
-#define FWL_WGT_CalcHeight 2048
-#define FWL_WGT_CalcWidth 2048
-#define FWL_WGT_CalcMultiLineDefWidth 120.0f
-
 CFX_SizeF IFWL_Widget::CalcTextSize(const CFX_WideString& wsText,
                                     IFWL_ThemeProvider* pTheme,
                                     bool bMultiLine,
                                     int32_t iLineWidth) {
   if (!pTheme)
     return CFX_SizeF();
 
   CFWL_ThemeText calPart;
   calPart.m_pWidget = this;
   calPart.m_wsText = wsText;
@@ skipping 71 matching lines @@
   }
   return GetPopupPosGeneral(fMinHeight, fMaxHeight, rtAnchor, rtPopup);
 }
 
 bool IFWL_Widget::GetPopupPosMenu(FX_FLOAT fMinHeight,
                                   FX_FLOAT fMaxHeight,
                                   const CFX_RectF& rtAnchor,
                                   CFX_RectF& rtPopup) {
   FX_FLOAT fx = 0;
   FX_FLOAT fy = 0;
-  FX_FLOAT fScreenWidth = 0;
-  FX_FLOAT fScreenHeight = 0;
-  GetScreenSize(fScreenWidth, fScreenHeight);
+
   if (GetStylesEx() & FWL_STYLEEXT_MNU_Vert) {
     bool bLeft = m_pProperties->m_rtWidget.left < 0;
     FX_FLOAT fRight = rtAnchor.right() + rtPopup.width;
     TransformTo(nullptr, fx, fy);
-    if (fRight + fx > fScreenWidth || bLeft) {
+    if (fRight + fx > 0.0f || bLeft) {
       rtPopup.Set(rtAnchor.left - rtPopup.width, rtAnchor.top, rtPopup.width,
                   rtPopup.height);
     } else {
       rtPopup.Set(rtAnchor.right(), rtAnchor.top, rtPopup.width,
                   rtPopup.height);
     }
   } else {
     FX_FLOAT fBottom = rtAnchor.bottom() + rtPopup.height;
     TransformTo(nullptr, fx, fy);
-    if (fBottom + fy > fScreenHeight) {
+    if (fBottom + fy > 0.0f) {
       rtPopup.Set(rtAnchor.left, rtAnchor.top - rtPopup.height, rtPopup.width,
                   rtPopup.height);
     } else {
       rtPopup.Set(rtAnchor.left, rtAnchor.bottom(), rtPopup.width,
                   rtPopup.height);
     }
   }
   rtPopup.Offset(fx, fy);
   return true;
 }
 
 bool IFWL_Widget::GetPopupPosComboBox(FX_FLOAT fMinHeight,
                                       FX_FLOAT fMaxHeight,
                                       const CFX_RectF& rtAnchor,
                                       CFX_RectF& rtPopup) {
   FX_FLOAT fx = 0;
   FX_FLOAT fy = 0;
-  FX_FLOAT fScreenWidth = 0;
-  FX_FLOAT fScreenHeight = 0;
-  GetScreenSize(fScreenWidth, fScreenHeight);
+
   FX_FLOAT fPopHeight = rtPopup.height;
   if (rtPopup.height > fMaxHeight) {
     fPopHeight = fMaxHeight;
   } else if (rtPopup.height < fMinHeight) {
     fPopHeight = fMinHeight;
   }
   FX_FLOAT fWidth = std::max(rtAnchor.width, rtPopup.width);
   FX_FLOAT fBottom = rtAnchor.bottom() + fPopHeight;
   TransformTo(nullptr, fx, fy);
-  if (fBottom + fy > fScreenHeight) {
+  if (fBottom + fy > 0.0f) {
     rtPopup.Set(rtAnchor.left, rtAnchor.top - fPopHeight, fWidth, fPopHeight);
   } else {
     rtPopup.Set(rtAnchor.left, rtAnchor.bottom(), fWidth, fPopHeight);
   }
   rtPopup.Offset(fx, fy);
   return true;
 }
 
 bool IFWL_Widget::GetPopupPosGeneral(FX_FLOAT fMinHeight,
                                      FX_FLOAT fMaxHeight,
                                      const CFX_RectF& rtAnchor,
                                      CFX_RectF& rtPopup) {
   FX_FLOAT fx = 0;
   FX_FLOAT fy = 0;
-  FX_FLOAT fScreenWidth = 0;
-  FX_FLOAT fScreenHeight = 0;
-  GetScreenSize(fScreenWidth, fScreenHeight);
+
   TransformTo(nullptr, fx, fy);
-  if (rtAnchor.bottom() + fy > fScreenHeight) {
+  if (rtAnchor.bottom() + fy > 0.0f) {
     rtPopup.Set(rtAnchor.left, rtAnchor.top - rtPopup.height, rtPopup.width,
                 rtPopup.height);
   } else {
     rtPopup.Set(rtAnchor.left, rtAnchor.bottom(), rtPopup.width,
                 rtPopup.height);
   }
   rtPopup.Offset(fx, fy);
   return true;
 }
 
-bool IFWL_Widget::GetScreenSize(FX_FLOAT& fx, FX_FLOAT& fy) {
-  return false;
-}
-
 void IFWL_Widget::RegisterEventTarget(IFWL_Widget* pEventSource,
                                       uint32_t dwFilter) {
   const IFWL_App* pApp = GetOwnerApp();
   if (!pApp)
     return;
 
   CFWL_NoteDriver* pNoteDriver = pApp->GetNoteDriver();
   if (!pNoteDriver)
     return;
 
@@ skipping 209 matching lines @@
     }
     default:
       break;
   }
 }
 
 void IFWL_Widget::OnProcessEvent(CFWL_Event* pEvent) {}
 
 void IFWL_Widget::OnDrawWidget(CFX_Graphics* pGraphics,
                                const CFX_Matrix* pMatrix) {}