xbmc/guilib/GUIListContainer.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "GUIListContainer.h"
  10
  11 #include "GUIListItemLayout.h"
  12 #include "GUIMessage.h"
  13 #include "input/actions/Action.h"
  14 #include "input/actions/ActionIDs.h"
  15 #include "utils/StringUtils.h"
  16
  17 CGUIListContainer::CGUIListContainer(int parentID, int controlID, float posX, float posY, float width, float height, ORIENTATION orientation, const CScroller& scroller, int preloadItems)
  18     : CGUIBaseContainer(parentID, controlID, posX, posY, width, height, orientation, scroller, preloadItems)
  19 {
  20   ControlType = GUICONTAINER_LIST;
  21   m_type = VIEW_TYPE_LIST;
  22 }
  23
  24 CGUIListContainer::CGUIListContainer(const CGUIListContainer& other) : CGUIBaseContainer(other)
  25 {
  26 }
  27
  28 CGUIListContainer::~CGUIListContainer(void) = default;
  29
  30 bool CGUIListContainer::OnAction(const CAction &action)
  31 {
  32   switch (action.GetID())
  33   {
  34   case ACTION_PAGE_UP:
  35     {
  36       if (GetOffset() == 0)
  37       { // already on the first page, so move to the first item
  38         SetCursor(0);
  39       }
  40       else
  41       { // scroll up to the previous page
  42         Scroll( -m_itemsPerPage);
  43       }
  44       return true;
  45     }
  46     break;
  47   case ACTION_PAGE_DOWN:
  48     {
  49       if (GetOffset() == (int)m_items.size() - m_itemsPerPage || (int)m_items.size() < m_itemsPerPage)
  50       { // already at the last page, so move to the last item.
  51         SetCursor(m_items.size() - GetOffset() - 1);
  52       }
  53       else
  54       { // scroll down to the next page
  55         Scroll(m_itemsPerPage);
  56       }
  57       return true;
  58     }
  59     break;
  60     // smooth scrolling (for analog controls)
  61   case ACTION_SCROLL_UP:
  62     {
  63       m_analogScrollCount += action.GetAmount() * action.GetAmount();
  64       bool handled = false;
  65       while (m_analogScrollCount > 0.4f)
  66       {
  67         handled = true;
  68         m_analogScrollCount -= 0.4f;
  69         if (GetOffset() > 0 && GetCursor() <= m_itemsPerPage / 2)
  70         {
  71           Scroll(-1);
  72         }
  73         else if (GetCursor() > 0)
  74         {
  75           SetCursor(GetCursor() - 1);
  76         }
  77       }
  78       return handled;
  79     }
  80     break;
  81   case ACTION_SCROLL_DOWN:
  82     {
  83       m_analogScrollCount += action.GetAmount() * action.GetAmount();
  84       bool handled = false;
  85       while (m_analogScrollCount > 0.4f)
  86       {
  87         handled = true;
  88         m_analogScrollCount -= 0.4f;
  89         if (GetOffset() + m_itemsPerPage < (int)m_items.size() && GetCursor() >= m_itemsPerPage / 2)
  90         {
  91           Scroll(1);
  92         }
  93         else if (GetCursor() < m_itemsPerPage - 1 && GetOffset() + GetCursor() < (int)m_items.size() - 1)
  94         {
  95           SetCursor(GetCursor() + 1);
  96         }
  97       }
  98       return handled;
  99     }
 100     break;
 101   }
 102   return CGUIBaseContainer::OnAction(action);
 103 }
 104
 105 bool CGUIListContainer::OnMessage(CGUIMessage& message)
 106 {
 107   if (message.GetControlId() == GetID() )
 108   {
 109     if (message.GetMessage() == GUI_MSG_LABEL_RESET)
 110     {
 111       SetCursor(0);
 112       SetOffset(0);
 113       m_scroller.SetValue(0);
 114     }
 115   }
 116   return CGUIBaseContainer::OnMessage(message);
 117 }
 118
 119 bool CGUIListContainer::MoveUp(bool wrapAround)
 120 {
 121   if (GetCursor() > 0)
 122   {
 123     SetCursor(GetCursor() - 1);
 124   }
 125   else if (GetCursor() == 0 && GetOffset())
 126   {
 127     ScrollToOffset(GetOffset() - 1);
 128   }
 129   else if (wrapAround)
 130   {
 131     if (!m_items.empty())
 132     { // move 2 last item in list, and set our container moving up
 133       int offset = m_items.size() - m_itemsPerPage;
 134       if (offset < 0) offset = 0;
 135       SetCursor(m_items.size() - offset - 1);
 136       ScrollToOffset(offset);
 137       SetContainerMoving(-1);
 138     }
 139   }
 140   else
 141     return false;
 142   return true;
 143 }
 144
 145 bool CGUIListContainer::MoveDown(bool wrapAround)
 146 {
 147   if (GetOffset() + GetCursor() + 1 < (int)m_items.size())
 148   {
 149     if (GetCursor() + 1 < m_itemsPerPage)
 150     {
 151       SetCursor(GetCursor() + 1);
 152     }
 153     else
 154     {
 155       ScrollToOffset(GetOffset() + 1);
 156     }
 157   }
 158   else if(wrapAround)
 159   { // move first item in list, and set our container moving in the "down" direction
 160     SetCursor(0);
 161     ScrollToOffset(0);
 162     SetContainerMoving(1);
 163   }
 164   else
 165     return false;
 166   return true;
 167 }
 168
 169 // scrolls the said amount
 170 void CGUIListContainer::Scroll(int amount)
 171 {
 172   // increase or decrease the offset
 173   int offset = GetOffset() + amount;
 174   if (offset > (int)m_items.size() - m_itemsPerPage)
 175   {
 176     offset = m_items.size() - m_itemsPerPage;
 177   }
 178   if (offset < 0) offset = 0;
 179   ScrollToOffset(offset);
 180 }
 181
 182 void CGUIListContainer::ValidateOffset()
 183 {
 184   if (!m_layout) return;
 185   // first thing is we check the range of our offset
 186   // don't validate offset if we are scrolling in case the tween image exceed <0, 1> range
 187   int minOffset, maxOffset;
 188   GetOffsetRange(minOffset, maxOffset);
 189   if (GetOffset() > maxOffset || (!m_scroller.IsScrolling() && m_scroller.GetValue() > maxOffset * m_layout->Size(m_orientation)))
 190   {
 191     SetOffset(std::max(0, maxOffset));
 192     m_scroller.SetValue(GetOffset() * m_layout->Size(m_orientation));
 193   }
 194   if (GetOffset() < 0 || (!m_scroller.IsScrolling() && m_scroller.GetValue() < 0))
 195   {
 196     SetOffset(0);
 197     m_scroller.SetValue(0);
 198   }
 199 }
 200
 201 void CGUIListContainer::SetCursor(int cursor)
 202 {
 203   if (cursor > m_itemsPerPage - 1) cursor = m_itemsPerPage - 1;
 204   if (cursor < 0) cursor = 0;
 205   if (!m_wasReset)
 206     SetContainerMoving(cursor - GetCursor());
 207   CGUIBaseContainer::SetCursor(cursor);
 208 }
 209
 210 void CGUIListContainer::SelectItem(int item)
 211 {
 212   // Check that our offset is valid
 213   ValidateOffset();
 214   // only select an item if it's in a valid range
 215   if (item >= 0 && item < (int)m_items.size())
 216   {
 217     // Select the item requested
 218     if (item >= GetOffset() && item < GetOffset() + m_itemsPerPage)
 219     { // the item is on the current page, so don't change it.
 220       SetCursor(item - GetOffset());
 221     }
 222     else if (item < GetOffset())
 223     { // item is on a previous page - make it the first item on the page
 224       SetCursor(0);
 225       ScrollToOffset(item);
 226     }
 227     else // (item >= GetOffset()+m_itemsPerPage)
 228     { // item is on a later page - make it the last item on the page
 229       SetCursor(m_itemsPerPage - 1);
 230       ScrollToOffset(item - GetCursor());
 231     }
 232   }
 233 }
 234
 235 int CGUIListContainer::GetCursorFromPoint(const CPoint &point, CPoint *itemPoint) const
 236 {
 237   if (!m_focusedLayout || !m_layout)
 238     return -1;
 239
 240   int row = 0;
 241   float pos = (m_orientation == VERTICAL) ? point.y : point.x;
 242   while (row < m_itemsPerPage + 1)  // 1 more to ensure we get the (possible) half item at the end.
 243   {
 244     const CGUIListItemLayout *layout = (row == GetCursor()) ? m_focusedLayout : m_layout;
 245     if (pos < layout->Size(m_orientation) && row + GetOffset() < (int)m_items.size())
 246     { // found correct "row" -> check horizontal
 247       if (!InsideLayout(layout, point))
 248         return -1;
 249
 250       if (itemPoint)
 251         *itemPoint = m_orientation == VERTICAL ? CPoint(point.x, pos) : CPoint(pos, point.y);
 252       return row;
 253     }
 254     row++;
 255     pos -= layout->Size(m_orientation);
 256   }
 257   return -1;
 258 }
 259
 260 bool CGUIListContainer::SelectItemFromPoint(const CPoint &point)
 261 {
 262   CPoint itemPoint;
 263   int row = GetCursorFromPoint(point, &itemPoint);
 264   if (row < 0)
 265     return false;
 266
 267   SetCursor(row);
 268   CGUIListItemLayout *focusedLayout = GetFocusedLayout();
 269   if (focusedLayout)
 270     focusedLayout->SelectItemFromPoint(itemPoint);
 271   return true;
 272 }
 273
 274 //#ifdef GUILIB_PYTHON_COMPATIBILITY
 275 CGUIListContainer::CGUIListContainer(int parentID, int controlID, float posX, float posY, float width, float height,
 276                                  const CLabelInfo& labelInfo, const CLabelInfo& labelInfo2,
 277                                  const CTextureInfo& textureButton, const CTextureInfo& textureButtonFocus,
 278                                  float textureHeight, float itemWidth, float itemHeight, float spaceBetweenItems)
 279 : CGUIBaseContainer(parentID, controlID, posX, posY, width, height, VERTICAL, 200, 0)
 280 {
 281   m_layouts.emplace_back();
 282   m_layouts.back().CreateListControlLayouts(width, textureHeight + spaceBetweenItems, false, labelInfo, labelInfo2, textureButton, textureButtonFocus, textureHeight, itemWidth, itemHeight, "", "");
 283   std::string condition = StringUtils::Format("control.hasfocus({})", controlID);
 284   std::string condition2 = "!" + condition;
 285   m_focusedLayouts.emplace_back();
 286   m_focusedLayouts.back().CreateListControlLayouts(width, textureHeight + spaceBetweenItems, true, labelInfo, labelInfo2, textureButton, textureButtonFocus, textureHeight, itemWidth, itemHeight, condition2, condition);
 287   m_height = floor(m_height / (textureHeight + spaceBetweenItems)) * (textureHeight + spaceBetweenItems);
 288   ControlType = GUICONTAINER_LIST;
 289 }
 290 //#endif
 291
 292 bool CGUIListContainer::HasNextPage() const
 293 {
 294   return (GetOffset() != (int)m_items.size() - m_itemsPerPage && (int)m_items.size() >= m_itemsPerPage);
 295 }
 296
 297 bool CGUIListContainer::HasPreviousPage() const
 298 {
 299   return (GetOffset() > 0);
 300 }