xbmc/guilib/GUIBaseContainer.h

   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 #pragma once
  10
  11 /*!
  12 \file GUIListContainer.h
  13 \brief
  14 */
  15
  16 #include "GUIAction.h"
  17 #include "IGUIContainer.h"
  18 #include "utils/Stopwatch.h"
  19
  20 #include <list>
  21 #include <memory>
  22 #include <utility>
  23 #include <vector>
  24
  25 /*!
  26  \ingroup controls
  27  \brief
  28  */
  29
  30 class IListProvider;
  31 class TiXmlElement;
  32 class TiXmlNode;
  33 class CGUIListItemLayout;
  34
  35 class CGUIBaseContainer : public IGUIContainer
  36 {
  37 public:
  38   CGUIBaseContainer(int parentID, int controlID, float posX, float posY, float width, float height, ORIENTATION orientation, const CScroller& scroller, int preloadItems);
  39   explicit CGUIBaseContainer(const CGUIBaseContainer& other);
  40   ~CGUIBaseContainer(void) override;
  41
  42   bool OnAction(const CAction &action) override;
  43   void OnDown() override;
  44   void OnUp() override;
  45   void OnLeft() override;
  46   void OnRight() override;
  47   bool OnMouseOver(const CPoint &point) override;
  48   bool CanFocus() const override;
  49   bool OnMessage(CGUIMessage& message) override;
  50   void SetFocus(bool bOnOff) override;
  51   void AllocResources() override;
  52   void FreeResources(bool immediately = false) override;
  53   void UpdateVisibility(const CGUIListItem *item = NULL) override;
  54   void AssignDepth() override;
  55
  56   virtual unsigned int GetRows() const;
  57
  58   virtual bool HasNextPage() const;
  59   virtual bool HasPreviousPage() const;
  60
  61   void SetPageControl(int id);
  62
  63   std::string GetDescription() const override;
  64   void SaveStates(std::vector<CControlState> &states) override;
  65   virtual int GetSelectedItem() const;
  66
  67   void DoProcess(unsigned int currentTime, CDirtyRegionList &dirtyregions) override;
  68   void Process(unsigned int currentTime, CDirtyRegionList &dirtyregions) override;
  69
  70   void LoadLayout(TiXmlElement *layout);
  71   void LoadListProvider(TiXmlElement *content, int defaultItem, bool defaultAlways);
  72
  73   std::shared_ptr<CGUIListItem> GetListItem(int offset, unsigned int flag = 0) const override;
  74
  75   bool GetCondition(int condition, int data) const override;
  76   std::string GetLabel(int info) const override;
  77
  78   /*! \brief Set the list provider for this container (for python).
  79    \param provider the list provider to use for this container.
  80    */
  81   void SetListProvider(std::unique_ptr<IListProvider> provider);
  82
  83   /*! \brief Set the offset of the first item in the container from the container's position
  84    Useful for lists/panels where the focused item may be larger than the non-focused items and thus
  85    normally cut off from the clipping window defined by the container's position + size.
  86    \param offset CPoint holding the offset in skin coordinates.
  87    */
  88   void SetRenderOffset(const CPoint &offset);
  89
  90   void SetClickActions(const CGUIAction& clickActions) { m_clickActions = clickActions; }
  91   void SetFocusActions(const CGUIAction& focusActions) { m_focusActions = focusActions; }
  92   void SetUnFocusActions(const CGUIAction& unfocusActions) { m_unfocusActions = unfocusActions; }
  93
  94   void SetAutoScrolling(const TiXmlNode *node);
  95   void ResetAutoScrolling();
  96   void UpdateAutoScrolling(unsigned int currentTime);
  97
  98 #ifdef _DEBUG
  99   void DumpTextureUse() override;
 100 #endif
 101 protected:
 102   EVENT_RESULT OnMouseEvent(const CPoint& point, const KODI::MOUSE::CMouseEvent& event) override;
 103   bool OnClick(int actionID);
 104
 105   virtual void ProcessItem(float posX,
 106                            float posY,
 107                            std::shared_ptr<CGUIListItem>& item,
 108                            bool focused,
 109                            unsigned int currentTime,
 110                            CDirtyRegionList& dirtyregions);
 111
 112   void Render() override;
 113   virtual void RenderItem(float posX, float posY, CGUIListItem *item, bool focused);
 114   virtual void Scroll(int amount);
 115   virtual bool MoveDown(bool wrapAround);
 116   virtual bool MoveUp(bool wrapAround);
 117   virtual bool GetOffsetRange(int &minOffset, int &maxOffset) const;
 118   virtual void ValidateOffset();
 119   virtual int  CorrectOffset(int offset, int cursor) const;
 120   virtual void UpdateLayout(bool refreshAllItems = false);
 121   virtual void SetPageControlRange();
 122   virtual void UpdatePageControl(int offset);
 123   virtual void CalculateLayout();
 124   virtual void SelectItem(int item) {}
 125   virtual bool SelectItemFromPoint(const CPoint& point) { return false; }
 126   virtual int GetCursorFromPoint(const CPoint& point, CPoint* itemPoint = NULL) const { return -1; }
 127   virtual void Reset();
 128   virtual size_t GetNumItems() const { return m_items.size(); }
 129   virtual int GetCurrentPage() const;
 130   bool InsideLayout(const CGUIListItemLayout *layout, const CPoint &point) const;
 131   void OnFocus() override;
 132   void OnUnFocus() override;
 133   void UpdateListProvider(bool forceRefresh = false);
 134
 135   int ScrollCorrectionRange() const;
 136   inline float Size() const;
 137   void FreeMemory(int keepStart, int keepEnd);
 138   void GetCurrentLayouts();
 139   CGUIListItemLayout *GetFocusedLayout() const;
 140
 141   CPoint m_renderOffset; ///< \brief render offset of the first item in the list \sa SetRenderOffset
 142
 143   float m_analogScrollCount;
 144   unsigned int m_lastHoldTime;
 145
 146   ORIENTATION m_orientation;
 147   int m_itemsPerPage;
 148
 149   std::vector<std::shared_ptr<CGUIListItem>> m_items;
 150   typedef std::vector<std::shared_ptr<CGUIListItem>>::iterator iItems;
 151   std::shared_ptr<CGUIListItem> m_lastItem;
 152
 153   int m_pageControl;
 154
 155   std::list<CGUIListItemLayout> m_layouts;
 156   std::list<CGUIListItemLayout> m_focusedLayouts;
 157
 158   CGUIListItemLayout* m_layout{nullptr};
 159   CGUIListItemLayout* m_focusedLayout{nullptr};
 160   bool m_layoutCondition = false;
 161   bool m_focusedLayoutCondition = false;
 162
 163   virtual void ScrollToOffset(int offset);
 164   void SetContainerMoving(int direction);
 165   void UpdateScrollOffset(unsigned int currentTime);
 166
 167   CScroller m_scroller;
 168
 169   std::unique_ptr<IListProvider> m_listProvider;
 170
 171   bool m_wasReset;  // true if we've received a Reset message until we've rendered once.  Allows
 172                     // us to make sure we don't tell the infomanager that we've been moving when
 173                     // the "movement" was simply due to the list being repopulated (thus cursor position
 174                     // changing around)
 175
 176   void UpdateScrollByLetter();
 177   void GetCacheOffsets(int &cacheBefore, int &cacheAfter) const;
 178   int GetCacheCount() const { return m_cacheItems; }
 179   bool ScrollingDown() const { return m_scroller.IsScrollingDown(); }
 180   bool ScrollingUp() const { return m_scroller.IsScrollingUp(); }
 181   void OnNextLetter();
 182   void OnPrevLetter();
 183   void OnJumpLetter(const std::string& letter, bool skip = false);
 184   void OnJumpSMS(int letter);
 185   std::vector< std::pair<int, std::string> > m_letterOffsets;
 186
 187   /*! \brief Set the cursor position
 188    Should be used by all base classes rather than directly setting it, as
 189    this also marks the control as dirty (if needed)
 190    */
 191   virtual void SetCursor(int cursor);
 192   inline int GetCursor() const { return m_cursor; }
 193
 194   /*! \brief Set the container offset
 195    Should be used by all base classes rather than directly setting it, as
 196    this also marks the control as dirty (if needed)
 197    */
 198   void SetOffset(int offset);
 199   /*! \brief Returns the index of the first visible row
 200    returns the first row. This may be outside of the range of available items. Use GetItemOffset() to retrieve the first visible item in the list.
 201    \sa GetItemOffset
 202   */
 203   inline int GetOffset() const { return m_offset; }
 204   /*! \brief Returns the index of the first visible item
 205    returns the first visible item. This will always be in the range of available items. Use GetOffset() to retrieve the first visible row in the list.
 206    \sa GetOffset
 207   */
 208   inline int GetItemOffset() const { return CorrectOffset(GetOffset(), 0); }
 209
 210   // autoscrolling
 211   INFO::InfoPtr m_autoScrollCondition;
 212   int           m_autoScrollMoveTime;   // time between to moves
 213   unsigned int  m_autoScrollDelayTime;  // current offset into the delay
 214   bool          m_autoScrollIsReversed; // scroll backwards
 215
 216   unsigned int m_lastRenderTime;
 217
 218   struct RENDERITEM
 219   {
 220     float posX;
 221     float posY;
 222     std::shared_ptr<CGUIListItem> item;
 223     bool focused;
 224   };
 225
 226 private:
 227   bool OnContextMenu();
 228
 229   int m_cursor;
 230   int m_offset;
 231   int m_cacheItems;
 232   CStopWatch m_scrollTimer;
 233   CStopWatch m_lastScrollStartTimer;
 234   CStopWatch m_pageChangeTimer;
 235
 236   CGUIAction m_clickActions;
 237   CGUIAction m_focusActions;
 238   CGUIAction m_unfocusActions;
 239
 240   // letter match searching
 241   CStopWatch m_matchTimer;
 242   std::string m_match;
 243   float m_scrollItemsPerFrame;
 244   static const int letter_match_timeout = 1000;
 245
 246   bool m_gestureActive = false;
 247
 248   // early inertial scroll cancellation
 249   bool m_waitForScrollEnd = false;
 250   float m_lastScrollValue = 0.0f;
 251 };
 252
 253