Remove unused CFWL_ListBox code

xfa/fwl/cfwl_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/cfwl_listbox.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 118 matching lines @@
     m_pProperties->m_pThemeProvider = pThemeProvider;
 }
 
 int32_t CFWL_ListBox::CountSelItems() {
   int32_t iRet = 0;
   int32_t iCount = CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = GetItem(this, i);
     if (!pItem)
       continue;
-    if (pItem->GetStyles() & FWL_ITEMSTATE_LTB_Selected)
+    if (pItem->GetStates() & FWL_ITEMSTATE_LTB_Selected)
       iRet++;
   }
   return iRet;
 }
 
 CFWL_ListItem* CFWL_ListBox::GetSelItem(int32_t nIndexSel) {
   int32_t idx = GetSelIndex(nIndexSel);
   if (idx < 0)
     return nullptr;
   return GetItem(this, idx);
 }
 
 int32_t CFWL_ListBox::GetSelIndex(int32_t nIndex) {
   int32_t index = 0;
   int32_t iCount = CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = GetItem(this, i);
     if (!pItem)
       return -1;
-    if (pItem->GetStyles() & FWL_ITEMSTATE_LTB_Selected) {
+    if (pItem->GetStates() & FWL_ITEMSTATE_LTB_Selected) {
       if (index == nIndex)
         return i;
       index++;
     }
   }
   return -1;
 }
 
 void CFWL_ListBox::SetSelItem(CFWL_ListItem* pItem, bool bSelect) {
   if (!pItem) {
@@ skipping 65 matching lines @@
   for (; iStart <= iEnd; iStart++) {
     CFWL_ListItem* pItem = GetItem(this, iStart);
     SetSelectionDirect(pItem, bSelected);
   }
 }
 
 void CFWL_ListBox::SetSelectionDirect(CFWL_ListItem* pItem, bool bSelect) {
   if (!pItem)
     return;
 
-  uint32_t dwOldStyle = pItem->GetStyles();
+  uint32_t dwOldStyle = pItem->GetStates();
   bSelect ? dwOldStyle |= FWL_ITEMSTATE_LTB_Selected
           : dwOldStyle &= ~FWL_ITEMSTATE_LTB_Selected;
-  pItem->SetStyles(dwOldStyle);
+  pItem->SetStates(dwOldStyle);
 }
 
 bool CFWL_ListBox::IsMultiSelection() const {
   return m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiSelection;
 }
 
 bool CFWL_ListBox::IsItemSelected(CFWL_ListItem* pItem) {
   if (!pItem)
     return false;
-  return (pItem->GetStyles() & FWL_ITEMSTATE_LTB_Selected) != 0;
+  return (pItem->GetStates() & FWL_ITEMSTATE_LTB_Selected) != 0;
 }
 
 void CFWL_ListBox::ClearSelection() {
   bool bMulti = IsMultiSelection();
   int32_t iCount = CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = GetItem(this, i);
     if (!pItem)
       continue;
-    if (!(pItem->GetStyles() & FWL_ITEMSTATE_LTB_Selected))
+    if (!(pItem->GetStates() & FWL_ITEMSTATE_LTB_Selected))
       continue;
     SetSelectionDirect(pItem, false);
     if (!bMulti)
       return;
   }
 }
 
 void CFWL_ListBox::SelectAll() {
   if (!IsMultiSelection())
     return;
 
   int32_t iCount = CountItems(this);
   if (iCount <= 0)
     return;
 
   CFWL_ListItem* pItemStart = GetItem(this, 0);
   CFWL_ListItem* pItemEnd = GetItem(this, iCount - 1);
   SetSelection(pItemStart, pItemEnd, false);
 }
 
 CFWL_ListItem* CFWL_ListBox::GetFocusedItem() {
   int32_t iCount = CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = GetItem(this, i);
     if (!pItem)
       return nullptr;
-    if (pItem->GetStyles() & FWL_ITEMSTATE_LTB_Focused)
+    if (pItem->GetStates() & FWL_ITEMSTATE_LTB_Focused)
       return pItem;
   }
   return nullptr;
 }
 
 void CFWL_ListBox::SetFocusItem(CFWL_ListItem* pItem) {
   CFWL_ListItem* hFocus = GetFocusedItem();
   if (pItem == hFocus)
     return;
 
   if (hFocus) {
-    uint32_t dwStyle = hFocus->GetStyles();
+    uint32_t dwStyle = hFocus->GetStates();
     dwStyle &= ~FWL_ITEMSTATE_LTB_Focused;
-    hFocus->SetStyles(dwStyle);
+    hFocus->SetStates(dwStyle);
   }
   if (pItem) {
-    uint32_t dwStyle = pItem->GetStyles();
+    uint32_t dwStyle = pItem->GetStates();
     dwStyle |= FWL_ITEMSTATE_LTB_Focused;
-    pItem->SetStyles(dwStyle);
+    pItem->SetStates(dwStyle);
   }
 }
 
 CFWL_ListItem* CFWL_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();
 
   int32_t nCount = CountItems(this);
   for (int32_t i = 0; i < nCount; i++) {
     CFWL_ListItem* pItem = GetItem(this, i);
     if (!pItem)
       continue;
 
     CFX_RectF rtItem = pItem->GetRect();
     rtItem.Offset(-fPosX, -fPosY);
     if (rtItem.Contains(fx, fy))
       return pItem;
   }
   return nullptr;
 }
 
-bool CFWL_ListBox::GetItemChecked(CFWL_ListItem* pItem) {
-  if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check))
-    return false;
-  return !!(pItem->GetCheckState() & FWL_ITEMSTATE_LTB_Checked);
-}
-
-bool CFWL_ListBox::SetItemChecked(CFWL_ListItem* pItem, bool bChecked) {
-  if (!(m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check))
-    return false;
-
-  pItem->SetCheckState(bChecked ? FWL_ITEMSTATE_LTB_Checked : 0);
-  return true;
-}
-
 bool CFWL_ListBox::ScrollToVisible(CFWL_ListItem* pItem) {
   if (!m_pVertScrollBar)
     return false;
 
   CFX_RectF rtItem = pItem ? pItem->GetRect() : CFX_RectF();
   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;
@@ skipping 44 matching lines @@
   FX_FLOAT fPosY = 0.0f;
   if (m_pVertScrollBar)
     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);
   int32_t iCount = CountItems(this);
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* pItem = GetItem(this, i);
     if (!pItem)
       continue;
 
     CFX_RectF rtItem = pItem->GetRect();
     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);
+    DrawItem(pGraphics, pTheme, pItem, i, rtItem, pMatrix);
   }
 }
 
 void CFWL_ListBox::DrawItem(CFX_Graphics* pGraphics,
                             IFWL_ThemeProvider* pTheme,
                             CFWL_ListItem* pItem,
                             int32_t Index,
                             const CFX_RectF& rtItem,
                             const CFX_Matrix* pMatrix) {
-  uint32_t dwItemStyles = pItem ? pItem->GetStyles() : 0;
+  uint32_t dwItemStyles = pItem ? pItem->GetStates() : 0;
   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;
   }
 
   CFWL_ThemeBackground bg_param;
   bg_param.m_pWidget = this;
   bg_param.m_iPart = CFWL_Part::ListItem;
   bg_param.m_dwStates = dwPartStates;
   bg_param.m_pGraphics = pGraphics;
   bg_param.m_matrix.Concat(*pMatrix);
   bg_param.m_rtPart = rtItem;
   bg_param.m_bMaximize = true;
   CFX_RectF rtFocus(rtItem);
   bg_param.m_pData = &rtFocus;
   if (m_pVertScrollBar && !m_pHorzScrollBar &&
       (dwPartStates & CFWL_PartState_Focused)) {
     bg_param.m_rtPart.left += 1;
     bg_param.m_rtPart.width -= (m_fScorllBarWidth + 1);
     rtFocus.Deflate(0.5, 0.5, 1 + m_fScorllBarWidth, 1);
   }
   pTheme->DrawBackground(&bg_param);
 
-  bool bHasIcon = !!(GetStylesEx() & FWL_STYLEEXT_LTB_Icon);
-  if (bHasIcon) {
-    CFX_RectF rtDIB;
-    CFX_DIBitmap* pDib = pItem->GetIcon();
-    rtDIB.Set(rtItem.left, rtItem.top, rtItem.height, rtItem.height);
-    if (pDib) {
-      CFWL_ThemeBackground param;
-      param.m_pWidget = this;
-      param.m_iPart = CFWL_Part::Icon;
-      param.m_pGraphics = pGraphics;
-      param.m_matrix.Concat(*pMatrix);
-      param.m_rtPart = rtDIB;
-      param.m_bMaximize = true;
-      param.m_pImage = pDib;
-      pTheme->DrawBackground(&param);
-    }
-  }
-
-  bool bHasCheck = !!(GetStylesEx() & FWL_STYLEEXT_LTB_Check);
-  if (bHasCheck) {
-    CFX_RectF rtCheck;
-    rtCheck.Set(rtItem.left, rtItem.top, rtItem.height, rtItem.height);
-    rtCheck.Deflate(2, 2, 2, 2);
-    pItem->SetCheckRect(rtCheck);
-
-    CFWL_ThemeBackground param;
-    param.m_pWidget = this;
-    param.m_iPart = CFWL_Part::Check;
-    param.m_pGraphics = pGraphics;
-    if (GetItemChecked(pItem))
-      param.m_dwStates = CFWL_PartState_Checked;
-    else
-      param.m_dwStates = CFWL_PartState_Normal;
-    param.m_matrix.Concat(*pMatrix);
-    param.m_rtPart = rtCheck;
-    param.m_bMaximize = true;
-    pTheme->DrawBackground(&param);
-  }
-
   if (!pItem)
     return;
 
   CFX_WideString wsText = pItem->GetText();
   if (wsText.GetLength() <= 0)
     return;
 
   CFX_RectF rtText(rtItem);
   rtText.Deflate(kItemTextMargin, kItemTextMargin);
-  if (bHasIcon || bHasCheck)
-    rtText.Deflate(rtItem.height, 0, 0, 0);
 
   CFWL_ThemeText textParam;
   textParam.m_pWidget = this;
   textParam.m_iPart = CFWL_Part::ListItem;
   textParam.m_dwStates = dwPartStates;
   textParam.m_pGraphics = pGraphics;
   textParam.m_matrix.Concat(*pMatrix);
   textParam.m_rtPart = rtText;
   textParam.m_wsText = wsText;
   textParam.m_dwTTOStyles = m_dwTTOStyles;
@@ skipping 19 matching lines @@
     }
   }
 
   FX_FLOAT fWidth = GetMaxTextWidth();
   fWidth += 2 * kItemTextMargin;
   if (!bAutoSize) {
     FX_FLOAT fActualWidth =
         m_rtClient.width - rtUIMargin.left - rtUIMargin.width;
     fWidth = std::max(fWidth, fActualWidth);
   }
-
   m_fItemHeight = CalcItemHeight();
-  if ((GetStylesEx() & FWL_STYLEEXT_LTB_Icon))
-    fWidth += m_fItemHeight;
 
   int32_t iCount = CountItems(this);
   CFX_SizeF fs;
   for (int32_t i = 0; i < iCount; i++) {
     CFWL_ListItem* htem = GetItem(this, i);
     fs = GetItemSize(htem, fWidth, m_fItemHeight, bAutoSize);
   }
   if (bAutoSize)
     return fs;
 
   FX_FLOAT iWidth = m_rtClient.width - rtUIMargin.left - rtUIMargin.width;
   FX_FLOAT iHeight = m_rtClient.height;
-  bool bShowVertScr =
-      (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_ShowScrollBarAlaways) &&
-      (m_pProperties->m_dwStyles & FWL_WGTSTYLE_VScroll);
-  bool bShowHorzScr =
-      (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_ShowScrollBarAlaways) &&
-      (m_pProperties->m_dwStyles & FWL_WGTSTYLE_HScroll);
-  if (!bShowVertScr && m_pProperties->m_dwStyles & FWL_WGTSTYLE_VScroll &&
-      (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiColumn) == 0) {
+  bool bShowVertScr = false;
+  bool bShowHorzScr = false;
+  if (!bShowVertScr && m_pProperties->m_dwStyles & FWL_WGTSTYLE_VScroll)
     bShowVertScr = (fs.y > iHeight);
-  }
   if (!bShowHorzScr && m_pProperties->m_dwStyles & FWL_WGTSTYLE_HScroll)
     bShowHorzScr = (fs.x > iWidth);
 
   CFX_SizeF szRange;
   if (bShowVertScr) {
     if (!m_pVertScrollBar)
       InitVerticalScrollBar();
 
     CFX_RectF rtScrollBar;
     rtScrollBar.Set(m_rtClient.right() - m_fScorllBarWidth, m_rtClient.top,
@@ skipping 60 matching lines @@
                    m_rtClient.bottom() - m_fScorllBarWidth, m_fScorllBarWidth,
                    m_fScorllBarWidth);
   }
   return fs;
 }
 
 CFX_SizeF CFWL_ListBox::GetItemSize(CFWL_ListItem* pItem,
                                     FX_FLOAT fWidth,
                                     FX_FLOAT fItemHeight,
                                     bool bAutoSize) {
-  if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_MultiColumn)
-    return CFX_SizeF();
-
   CFX_SizeF size;
   if (!bAutoSize && pItem) {
     CFX_RectF rtItem;
     rtItem.Set(0, size.y, fWidth, fItemHeight);
     pItem->SetRect(rtItem);
   }
   size.x = fWidth;
   size.y += fItemHeight;
   return size;
 }
@@ skipping 169 matching lines @@
         SetSelection(m_hAnchor, pItem, true);
       else
         SetSelectionDirect(pItem, true);
     } else {
       SetSelection(pItem, pItem, true);
       m_hAnchor = pItem;
     }
   } else {
     SetSelection(pItem, pItem, true);
   }
-  if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check) {
-    CFWL_ListItem* hSelectedItem = GetItemAtPoint(pMsg->m_fx, pMsg->m_fy);
-    CFX_RectF rtCheck;
-    if (m_pProperties->m_dwStyleExes & FWL_STYLEEXT_LTB_Check)
-      rtCheck = hSelectedItem->GetCheckRect();
 
-    bool bChecked = GetItemChecked(pItem);
-    if (rtCheck.Contains(pMsg->m_fx, pMsg->m_fy)) {
-      SetItemChecked(pItem, !bChecked);
-      Update();
-    }
-  }
   SetFocusItem(pItem);
   ScrollToVisible(pItem);
   SetGrab(true);
   RepaintRect(m_rtClient);
 }
 
 void CFWL_ListBox::OnLButtonUp(CFWL_MessageMouse* pMsg) {
   if (!m_bLButtonDown)
     return;
 
@@ skipping 145 matching lines @@
 void CFWL_ListBox::DeleteString(CFWL_ListItem* pItem) {
   int32_t nIndex = GetItemIndex(this, pItem);
   if (nIndex < 0 || static_cast<size_t>(nIndex) >= m_ItemArray.size())
     return;
 
   int32_t iSel = nIndex + 1;
   if (iSel >= CountItems(this))
     iSel = nIndex - 1;
   if (iSel >= 0) {
     if (CFWL_ListItem* item = GetItem(this, iSel))
-      item->SetStyles(item->GetStyles() | FWL_ITEMSTATE_LTB_Selected);
+      item->SetStates(item->GetStates() | FWL_ITEMSTATE_LTB_Selected);
   }
 
   m_ItemArray.erase(m_ItemArray.begin() + nIndex);
 }
 
 void CFWL_ListBox::DeleteAll() {
   m_ItemArray.clear();
 }