Split fwl/core class pt I.

xfa/fwl/core/ifwl_listbox.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_listbox.h"
 
 #include "third_party/base/ptr_util.h"
 #include "xfa/fde/tto/fde_textout.h"
 #include "xfa/fwl/core/cfwl_msgkey.h"
 #include "xfa/fwl/core/cfwl_msgmouse.h"
 #include "xfa/fwl/core/cfwl_msgmousewheel.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/ifwl_app.h"
+#include "xfa/fwl/core/ifwl_listbox.h"
 #include "xfa/fwl/core/ifwl_themeprovider.h"
 
 namespace {
 
 const int kItemTextMargin = 2;
 
 }  // namespace
 
 IFWL_ListBox::IFWL_ListBox(const IFWL_App* app,
                            std::unique_ptr<CFWL_WidgetProperties> properties,
@@ skipping 111 matching lines @@
 void IFWL_ListBox::SetThemeProvider(IFWL_ThemeProvider* pThemeProvider) {
   if (pThemeProvider)
     m_pProperties->m_pThemeProvider = pThemeProvider;
 }
 
 int32_t IFWL_ListBox::CountSelItems() {
   if (!m_pProperties->m_pDataProvider)
     return 0;
 
   int32_t iRet = 0;
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = pData->GetItem(this, i);
     if (!pItem)
       continue;
 
     uint32_t dwStyle = pData->GetItemStyles(this, pItem);
     if (dwStyle & FWL_ITEMSTATE_LTB_Selected)
       iRet++;
   }
   return iRet;
 }
 
 CFWL_ListItem* IFWL_ListBox::GetSelItem(int32_t nIndexSel) {
   int32_t idx = GetSelIndex(nIndexSel);
   if (idx < 0)
     return nullptr;
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   return pData->GetItem(this, idx);
 }
 
 int32_t IFWL_ListBox::GetSelIndex(int32_t nIndex) {
   if (!m_pProperties->m_pDataProvider)
     return -1;
 
   int32_t index = 0;
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = pData->GetItem(this, i);
     if (!pItem)
       return -1;
 
     uint32_t dwStyle = pData->GetItemStyles(this, pItem);
     if (dwStyle & FWL_ITEMSTATE_LTB_Selected) {
       if (index == nIndex)
         return i;
@@ skipping 18 matching lines @@
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection)
     SetSelectionDirect(pItem, bSelect);
   else
     SetSelection(pItem, pItem, bSelect);
 }
 
 void IFWL_ListBox::GetItemText(CFWL_ListItem* pItem, CFX_WideString& wsText) {
   if (!m_pProperties->m_pDataProvider)
     return;
 
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   if (!pItem)
     return;
 
   pData->GetItemText(this, pItem, wsText);
 }
 
 CFWL_ListItem* IFWL_ListBox::GetItem(CFWL_ListItem* pItem, uint32_t dwKeyCode) {
   CFWL_ListItem* hRet = nullptr;
   switch (dwKeyCode) {
     case FWL_VKEY_Up:
     case FWL_VKEY_Down:
     case FWL_VKEY_Home:
     case FWL_VKEY_End: {
       const bool bUp = dwKeyCode == FWL_VKEY_Up;
       const bool bDown = dwKeyCode == FWL_VKEY_Down;
       const bool bHome = dwKeyCode == FWL_VKEY_Home;
-      IFWL_ListBoxDP* pData =
-          static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+      IFWL_ListBox::DataProvider* pData =
+          static_cast<IFWL_ListBox::DataProvider*>(
+              m_pProperties->m_pDataProvider);
       int32_t iDstItem = -1;
       if (bUp || bDown) {
         int32_t index = pData->GetItemIndex(this, pItem);
         iDstItem = dwKeyCode == FWL_VKEY_Up ? index - 1 : index + 1;
       } else if (bHome) {
         iDstItem = 0;
       } else {
         int32_t iCount = pData->CountItems(this);
         iDstItem = iCount - 1;
       }
       hRet = pData->GetItem(this, iDstItem);
       break;
     }
     default:
       break;
   }
   return hRet;
 }
 
 void IFWL_ListBox::SetSelection(CFWL_ListItem* hStart,
                                 CFWL_ListItem* hEnd,
                                 bool bSelected) {
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t iStart = pData->GetItemIndex(this, hStart);
   int32_t iEnd = pData->GetItemIndex(this, hEnd);
   if (iStart > iEnd) {
     int32_t iTemp = iStart;
     iStart = iEnd;
     iEnd = iTemp;
   }
   if (bSelected) {
     int32_t iCount = pData->CountItems(this);
     for (int32_t i = 0; i < iCount; i++) {
       CFWL_ListItem* pItem = pData->GetItem(this, i);
       SetSelectionDirect(pItem, false);
     }
   }
   for (; iStart <= iEnd; iStart++) {
     CFWL_ListItem* pItem = pData->GetItem(this, iStart);
     SetSelectionDirect(pItem, bSelected);
   }
 }
 
 void IFWL_ListBox::SetSelectionDirect(CFWL_ListItem* pItem, bool bSelect) {
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   uint32_t dwOldStyle = pData->GetItemStyles(this, pItem);
   bSelect ? dwOldStyle |= FWL_ITEMSTATE_LTB_Selected
           : dwOldStyle &= ~FWL_ITEMSTATE_LTB_Selected;
   pData->SetItemStyles(this, pItem, dwOldStyle);
 }
 
 bool IFWL_ListBox::IsItemSelected(CFWL_ListItem* pItem) {
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   uint32_t dwState = pData->GetItemStyles(this, pItem);
   return (dwState & FWL_ITEMSTATE_LTB_Selected) != 0;
 }
 
 void IFWL_ListBox::ClearSelection() {
   bool bMulti = m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection;
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = pData->GetItem(this, i);
     uint32_t dwState = pData->GetItemStyles(this, pItem);
     if (!(dwState & FWL_ITEMSTATE_LTB_Selected))
       continue;
     SetSelectionDirect(pItem, false);
     if (!bMulti)
       return;
   }
 }
 
 void IFWL_ListBox::SelectAll() {
   if (!m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection)
     return;
 
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   if (iCount <= 0)
     return;
 
   CFWL_ListItem* pItemStart = pData->GetItem(this, 0);
   CFWL_ListItem* pItemEnd = pData->GetItem(this, iCount - 1);
   SetSelection(pItemStart, pItemEnd, false);
 }
 
 CFWL_ListItem* IFWL_ListBox::GetFocusedItem() {
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = pData->GetItem(this, i);
     if (!pItem)
       return nullptr;
     if (pData->GetItemStyles(this, pItem) & FWL_ITEMSTATE_LTB_Focused)
       return pItem;
   }
   return nullptr;
 }
 
 void IFWL_ListBox::SetFocusItem(CFWL_ListItem* pItem) {
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   CFWL_ListItem* hFocus = GetFocusedItem();
   if (pItem == hFocus)
     return;
 
   if (hFocus) {
     uint32_t dwStyle = pData->GetItemStyles(this, hFocus);
     dwStyle &= ~FWL_ITEMSTATE_LTB_Focused;
     pData->SetItemStyles(this, hFocus, dwStyle);
   }
   if (pItem) {
     uint32_t dwStyle = pData->GetItemStyles(this, pItem);
     dwStyle |= FWL_ITEMSTATE_LTB_Focused;
     pData->SetItemStyles(this, pItem, dwStyle);
   }
 }
 
 CFWL_ListItem* IFWL_ListBox::GetItemAtPoint(FX_FLOAT fx, FX_FLOAT fy) {
   fx -= m_rtConent.left, fy -= m_rtConent.top;
   FX_FLOAT fPosX = 0.0f;
   if (m_pHorzScrollBar)
     fPosX = m_pHorzScrollBar->GetPos();
 
   FX_FLOAT fPosY = 0.0;
   if (m_pVertScrollBar)
     fPosY = m_pVertScrollBar->GetPos();
 
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t nCount = pData->CountItems(this);
   for (int32_t i = 0; i < nCount; i++) {
     CFWL_ListItem* pItem = pData->GetItem(this, i);
     if (!pItem)
       continue;
 
     CFX_RectF rtItem;
     pData->GetItemRect(this, pItem, rtItem);
     rtItem.Offset(-fPosX, -fPosY);
     if (rtItem.Contains(fx, fy))
       return pItem;
   }
   return nullptr;
 }
 
 bool IFWL_ListBox::GetItemCheckRect(CFWL_ListItem* pItem, CFX_RectF& rtCheck) {
   if (!m_pProperties->m_pDataProvider)
     return false;
   if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check))
     return false;
 
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   pData->GetItemCheckRect(this, pItem, rtCheck);
   return true;
 }
 
 bool IFWL_ListBox::GetItemChecked(CFWL_ListItem* pItem) {
   if (!m_pProperties->m_pDataProvider)
     return false;
   if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check))
     return false;
 
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   return !!(pData->GetItemCheckState(this, pItem) & FWL_ITEMSTATE_LTB_Checked);
 }
 
 bool IFWL_ListBox::SetItemChecked(CFWL_ListItem* pItem, bool bChecked) {
   if (!m_pProperties->m_pDataProvider)
     return false;
   if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check))
     return false;
 
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   pData->SetItemCheckState(this, pItem,
                            bChecked ? FWL_ITEMSTATE_LTB_Checked : 0);
   return true;
 }
 
 bool IFWL_ListBox::ScrollToVisible(CFWL_ListItem* pItem) {
   if (!m_pVertScrollBar)
     return false;
 
   CFX_RectF rtItem;
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   pData->GetItemRect(this, pItem, rtItem);
 
   bool bScroll = false;
   FX_FLOAT fPosY = m_pVertScrollBar->GetPos();
   rtItem.Offset(0, -fPosY + m_rtConent.top);
   if (rtItem.top < m_rtConent.top) {
     fPosY += rtItem.top - m_rtConent.top;
     bScroll = true;
   } else if (rtItem.bottom() > m_rtConent.bottom()) {
     fPosY += rtItem.bottom() - m_rtConent.bottom();
@@ skipping 43 matching lines @@
     fPosY = m_pVertScrollBar->GetPos();
 
   CFX_RectF rtView(m_rtConent);
   if (m_pHorzScrollBar)
     rtView.height -= m_fScorllBarWidth;
   if (m_pVertScrollBar)
     rtView.width -= m_fScorllBarWidth;
 
   bool bMultiCol =
       !!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiColumn);
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = pData->GetItem(this, i);
     if (!pItem)
       continue;
 
     CFX_RectF rtItem;
     pData->GetItemRect(this, pItem, rtItem);
     rtItem.Offset(m_rtConent.left - fPosX, m_rtConent.top - fPosY);
     if (rtItem.bottom() < m_rtConent.top)
       continue;
     if (rtItem.top >= m_rtConent.bottom())
       break;
     if (bMultiCol && rtItem.left > m_rtConent.right())
       break;
 
     if (!(GetStylesEx() & FWL_STYLEEXT_LTB_OwnerDraw))
       DrawItem(pGraphics, pTheme, pItem, i, rtItem, pMatrix);
   }
 }
 
 void IFWL_ListBox::DrawItem(CFX_Graphics* pGraphics,
                             IFWL_ThemeProvider* pTheme,
                             CFWL_ListItem* pItem,
                             int32_t Index,
                             const CFX_RectF& rtItem,
                             const CFX_Matrix* pMatrix) {
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   uint32_t dwItemStyles = pData->GetItemStyles(this, pItem);
   uint32_t dwPartStates = CFWL_PartState_Normal;
   if (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)
     dwPartStates = CFWL_PartState_Disabled;
   else if (dwItemStyles & FWL_ITEMSTATE_LTB_Selected)
     dwPartStates = CFWL_PartState_Selected;
 
   if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused &&
       dwItemStyles & FWL_ITEMSTATE_LTB_Focused) {
     dwPartStates |= CFWL_PartState_Focused;
@@ skipping 92 matching lines @@
     CFX_RectF* pUIMargin = static_cast<CFX_RectF*>(
         GetThemeCapacity(CFWL_WidgetCapacity::UIMargin));
     if (pUIMargin) {
       m_rtConent.Deflate(pUIMargin->left, pUIMargin->top, pUIMargin->width,
                          pUIMargin->height);
     }
   }
 
   FX_FLOAT fWidth = 0;
   if (m_pProperties->m_pThemeProvider->IsCustomizedLayout(this)) {
-    IFWL_ListBoxDP* pData =
-        static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+    IFWL_ListBox::DataProvider* pData =
+        static_cast<IFWL_ListBox::DataProvider*>(
+            m_pProperties->m_pDataProvider);
     int32_t iCount = pData->CountItems(this);
     for (int32_t i = 0; i < iCount; i++) {
       CFWL_ListItem* pItem = pData->GetItem(this, i);
       if (!bAutoSize) {
         CFX_RectF rtItem;
         rtItem.Set(m_rtClient.left, m_rtClient.top + fs.y, 0, 0);
-        IFWL_ListBoxDP* pBox =
-            static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+        IFWL_ListBox::DataProvider* pBox =
+            static_cast<IFWL_ListBox::DataProvider*>(
+                m_pProperties->m_pDataProvider);
         pBox->SetItemRect(this, pItem, rtItem);
       }
       if (fs.x < 0) {
         fs.x = 0;
         fWidth = 0;
       }
     }
   } else {
     fWidth = GetMaxTextWidth();
     fWidth += 2 * kItemTextMargin;
     if (!bAutoSize) {
       FX_FLOAT fActualWidth =
           m_rtClient.width - rtUIMargin.left - rtUIMargin.width;
       fWidth = std::max(fWidth, fActualWidth);
     }
 
-    IFWL_ListBoxDP* pData =
-        static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+    IFWL_ListBox::DataProvider* pData =
+        static_cast<IFWL_ListBox::DataProvider*>(
+            m_pProperties->m_pDataProvider);
     m_fItemHeight = CalcItemHeight();
     if ((GetStylesEx() & FWL_STYLEEXT_LTB_Icon))
       fWidth += m_fItemHeight;
 
     int32_t iCount = pData->CountItems(this);
     for (int32_t i = 0; i < iCount; i++) {
       CFWL_ListItem* htem = pData->GetItem(this, i);
       GetItemSize(fs, htem, fWidth, m_fItemHeight, bAutoSize);
     }
   }
@@ skipping 92 matching lines @@
                                CFWL_ListItem* pItem,
                                FX_FLOAT fWidth,
                                FX_FLOAT fItemHeight,
                                bool bAutoSize) {
   if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiColumn)
     return;
 
   if (!bAutoSize) {
     CFX_RectF rtItem;
     rtItem.Set(0, size.y, fWidth, fItemHeight);
-    IFWL_ListBoxDP* pData =
-        static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+    IFWL_ListBox::DataProvider* pData =
+        static_cast<IFWL_ListBox::DataProvider*>(
+            m_pProperties->m_pDataProvider);
     pData->SetItemRect(this, pItem, rtItem);
   }
   size.x = fWidth;
   size.y += fItemHeight;
 }
 
 FX_FLOAT IFWL_ListBox::GetMaxTextWidth() {
   FX_FLOAT fRet = 0.0f;
-  IFWL_ListBoxDP* pData =
-      static_cast<IFWL_ListBoxDP*>(m_pProperties->m_pDataProvider);
+  IFWL_ListBox::DataProvider* pData =
+      static_cast<IFWL_ListBox::DataProvider*>(m_pProperties->m_pDataProvider);
   int32_t iCount = pData->CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = pData->GetItem(this, i);
     if (!pItem)
       continue;
 
     CFX_WideString wsText;
     pData->GetItemText(this, pItem, wsText);
     CFX_SizeF sz = CalcTextSize(wsText, m_pProperties->m_pThemeProvider);
     fRet = std::max(fRet, sz.x);
@@ skipping 272 matching lines @@
     case FWL_SCBCODE::EndScroll:
       return false;
   }
   if (iCurPos != fPos) {
     pScrollBar->SetPos(fPos);
     pScrollBar->SetTrackPos(fPos);
     Repaint(&m_rtClient);
   }
   return true;
 }