Cleanup default FWL params part I

xfa/fwl/core/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 <algorithm>
 #include <memory>
@@ skipping 104 matching lines @@
   if (iTextLen > 0) {
     CFX_WideString wsText = m_EdtEngine.GetText(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) {
+void CFWL_Edit::SetStates(uint32_t dwStates) {
   if ((m_pProperties->m_dwStates & FWL_WGTSTATE_Invisible) ||
       (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)) {
     HideCaret(nullptr);
   }
-  CFWL_Widget::SetStates(dwStates, bSet);
+  CFWL_Widget::SetStates(dwStates);

[Tom Sepez, 2016/12/06 22:38:26]

Sure this didn't ever used to do a RemoveStates equivalent?

[dsinclair, 2016/12/07 15:03:27]

If we remove the Invisible or Disabled state, then they would have already been
set, so the cursor would already have been Hidden, no? So, Does false actually
do anything in this case other then proxy to CFWL_Widget::SetStates?

 }
 
 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);
+      m_pVertScrollBar->GetWidgetRect(rect, false);
       if (rect.Contains(fx, fy))
         return FWL_WidgetHit::VScrollBar;
     }
     if (IsShowScrollBar(false)) {
       CFX_RectF rect;
-      m_pHorzScrollBar->GetWidgetRect(rect);
+      m_pHorzScrollBar->GetWidgetRect(rect, false);
       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,
@@ skipping 256 matching lines @@
     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);
+      pScroll->GetWidgetRect(rtInvalid, false);
       bRepaintScroll = true;
     }
   }
   if (bRepaintContent || bRepaintScroll) {
     if (bRepaintContent)
       rtInvalid.Union(m_rtEngine);
     Repaint(&rtInvalid);
   }
 }
 
@@ skipping 78 matching lines @@
   if (dwStates)
     param.m_dwStates = CFWL_PartState_Disabled;
   param.m_pGraphics = pGraphics;
   param.m_matrix = *pMatrix;
   param.m_rtPart = m_rtClient;
   pTheme->DrawBackground(&param);
 
   if (!IsShowScrollBar(true) || !IsShowScrollBar(false))
     return;
 
-  CFX_RectF rtScorll;
-  m_pHorzScrollBar->GetWidgetRect(rtScorll);
+  CFX_RectF rtScroll;
+  m_pHorzScrollBar->GetWidgetRect(rtScroll, false);
 
   CFX_RectF rtStatic;
-  rtStatic.Set(m_rtClient.right() - rtScorll.height,
-               m_rtClient.bottom() - rtScorll.height, rtScorll.height,
-               rtScorll.height);
+  rtStatic.Set(m_rtClient.right() - rtScroll.height,
+               m_rtClient.bottom() - rtScroll.height, rtScroll.height,
+               rtScroll.height);
   param.m_bStaticBackground = true;
   param.m_bMaximize = true;
   param.m_rtPart = rtStatic;
   pTheme->DrawBackground(&param);
 }
 
 void CFWL_Edit::DrawContent(CFX_Graphics* pGraphics,
                             IFWL_ThemeProvider* pTheme,
                             const CFX_Matrix* pMatrix) {
   IFDE_TxtEdtPage* pPage = m_EdtEngine.GetPage(0);
@@ skipping 358 matching lines @@
     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);
+    m_pHorzScrollBar->GetWidgetRect(rtScroll, false);
     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->RemoveStates(FWL_WGTSTATE_Disabled);
       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->SetStates(FWL_WGTSTATE_Disabled);
       m_pHorzScrollBar->UnlockUpdate();
       m_pHorzScrollBar->Update();
       pRepaint = m_pHorzScrollBar.get();
     }
   }
 
   if (bShowVert) {
     CFX_RectF rtScroll;
-    m_pVertScrollBar->GetWidgetRect(rtScroll);
+    m_pVertScrollBar->GetWidgetRect(rtScroll, false);
     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->RemoveStates(FWL_WGTSTATE_Disabled);
       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->SetStates(FWL_WGTSTATE_Disabled);
       m_pVertScrollBar->UnlockUpdate();
       m_pVertScrollBar->Update();
       pRepaint = m_pVertScrollBar.get();
     }
   }
   return pRepaint;
 }
 
 bool CFWL_Edit::IsShowScrollBar(bool bVert) {
   bool bShow =
@@ skipping 73 matching lines @@
                     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->RemoveStates(FWL_WGTSTATE_Invisible);
     m_pVertScrollBar->Update();
   } else if (m_pVertScrollBar) {
-    m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
+    m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible);
   }
 
   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->RemoveStates(FWL_WGTSTATE_Invisible);
     m_pHorzScrollBar->Update();
   } else if (m_pHorzScrollBar) {
-    m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
+    m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible);
   }
 }
 
 void CFWL_Edit::LayoutScrollBar() {
   if ((m_pProperties->m_dwStyleExes & FWL_STYLEEXT_EDT_ShowScrollbarFocus) ==
       0) {
     return;
   }
 
   FX_FLOAT* pfWidth = nullptr;
@@ skipping 11 matching lines @@
                       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);
+    m_pVertScrollBar->RemoveStates(FWL_WGTSTATE_Invisible);
   } else if (m_pVertScrollBar) {
-    m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
+    m_pVertScrollBar->SetStates(FWL_WGTSTATE_Invisible);
   }
 
   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);
+    m_pHorzScrollBar->RemoveStates(FWL_WGTSTATE_Invisible);
   } else if (m_pHorzScrollBar) {
-    m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible, true);
+    m_pHorzScrollBar->SetStates(FWL_WGTSTATE_Invisible);
   }
   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;
 }
 
@@ skipping 22 matching lines @@
     Repaint(&m_rtEngine);
     return;
   }
 
   CFWL_Widget* pOuter = this;
   pRect->Offset(m_pProperties->m_rtWidget.left, m_pProperties->m_rtWidget.top);
   while (pOuter->GetOuter()) {
     pOuter = pOuter->GetOuter();
 
     CFX_RectF rtOuter;
-    pOuter->GetWidgetRect(rtOuter);
+    pOuter->GetWidgetRect(rtOuter, false);
     pRect->Offset(rtOuter.left, rtOuter.top);
   }
 
   CXFA_FFWidget* pXFAWidget =
       static_cast<CXFA_FFWidget*>(pOuter->GetLayoutItem());
   if (!pXFAWidget)
     return;
 
   IXFA_DocEnvironment* pDocEnvironment =
       pXFAWidget->GetDoc()->GetDocEnvironment();
@@ skipping 445 matching lines @@
   }
   if (iCurPos == fPos)
     return true;
 
   pScrollBar->SetPos(fPos);
   pScrollBar->SetTrackPos(fPos);
   UpdateOffset(pScrollBar, fPos - iCurPos);
   UpdateCaret();
 
   CFX_RectF rect;
-  GetWidgetRect(rect);
+  GetWidgetRect(rect, false);
   CFX_RectF rtInvalidate;
   rtInvalidate.Set(0, 0, rect.width + 2, rect.height + 2);
   Repaint(&rtInvalidate);
   return true;
 }