recycler.hpp

Go to the documentation of this file.

/*
    Copyright 2021 XITRIX
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
 
        http://www.apache.org/licenses/LICENSE-2.0
 
    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/
 
#pragma once
 
#include <functional>
#include <map>
#include <vector>
#include <aurore/core/application.hpp>
#include <aurore/core/bind.hpp>
#include <aurore/views/header.hpp>
#include <aurore/views/label.hpp>
#include <aurore/views/rectangle.hpp>
#include <aurore/views/scrolling_frame.hpp>
 
namespace aurore
{
 
struct IndexPath
{
    size_t section;
    int row;
    size_t item;
 
    IndexPath()
        : IndexPath(0, 0, 0)
    {
    }
 
    IndexPath(size_t section, size_t row, size_t item)
    {
        this->section = section;
        this->row     = row;
        this->item    = item;
    }
 
    IndexPath(size_t section, size_t row)
        : IndexPath(section, row, row)
    {
    }
 
    bool operator==(const IndexPath& other)
    {
        return section == other.section && row == other.row && item == other.item;
    }
};
 
class RecyclerCell : public Box
{
  public:
    RecyclerCell();
    ~RecyclerCell();
 
    IndexPath getIndexPath() const { return indexPath; }
 
    void setIndexPath(IndexPath value);
 
    std::string reuseIdentifier;
 
    virtual void prepareForReuse() { }
 
    static RecyclerCell* create();
 
    void onFocusGained() override;
    void onFocusLost() override;
    void onTextScaleChanged() override;
 
  protected:
    void growWithText();
 
  private:
    void showSeparator(bool show);
    bool growsWithText = false;
    bool grown         = false;
    IndexPath indexPath;
    Event<InputType>::Subscription subscription;
};
 
class RecyclerHeader
    : public RecyclerCell
{
  public:
    RecyclerHeader();
 
    void setTitle(std::string text);
    void setSubtitle(std::string text);
 
    static RecyclerHeader* create();
 
  private:
    Header* header;
};
 
class RecyclerFrame;
class RecyclerDataSource
{
  public:
    virtual int numberOfSections(RecyclerFrame* recycler) { return 1; }
 
    virtual int numberOfRows(RecyclerFrame* recycler, int section) { return 0; }
 
    virtual RecyclerCell* cellForRow(RecyclerFrame* recycler, IndexPath index) { return nullptr; }
 
    virtual RecyclerCell* cellForHeader(RecyclerFrame* recycler, int section);
 
    virtual float heightForRow(RecyclerFrame* recycler, IndexPath index) { return -1; }
 
    virtual float heightForHeader(RecyclerFrame* recycler, int section);
 
    virtual std::string titleForHeader(RecyclerFrame* recycler, int section) { return ""; }
 
    virtual void didSelectRowAt(RecyclerFrame* recycler, IndexPath index) { }
 
    virtual ~RecyclerDataSource() = default;
};
 
class RecyclerContentBox : public Box
{
  public:
    RecyclerContentBox(RecyclerFrame* recycler);
    View* getNextFocus(FocusDirection direction, View* currentView) override;
 
  private:
    RecyclerFrame* recycler;
};
 
class RecyclerFrame : public ScrollingFrame
{
  public:
    RecyclerFrame();
    ~RecyclerFrame();
 
    View* getNextCellFocus(FocusDirection direction, View* currentView);
    void draw(NVGcontext* vg, float x, float y, float width, float height, Style style, FrameContext* ctx) override;
    void onLayout() override;
    void onThemeChanged() override;
    void setPadding(float padding) override;
    void setPadding(float top, float right, float bottom, float left) override;
    void setPaddingTop(float top) override;
    void setPaddingRight(float right) override;
    void setPaddingBottom(float bottom) override;
    void setPaddingLeft(float left) override;
 
    void setDataSource(RecyclerDataSource* source, bool deleteDataSource = true);
 
    RecyclerDataSource* getDataSource() const;
 
    void reloadData();
 
    void registerCell(std::string identifier, std::function<RecyclerCell*(void)> allocation);
 
    RecyclerCell* dequeueReusableCell(std::string identifier);
 
    void selectRowAt(IndexPath indexPath, bool animated);
 
    float estimatedRowHeight = 44;
 
    IndexPath getDefaultCellFocus()
    {
        return this->defaultCellFocus;
    }
 
    void setDefaultCellFocus(IndexPath indexPath)
    {
        this->defaultCellFocus = indexPath;
    }
 
    static View* create();
 
  private:
    RecyclerDataSource* dataSource = nullptr;
    bool deleteDataSource          = false;
    bool layouted                  = false;
 
    uint32_t visibleMin, visibleMax;
 
    IndexPath defaultCellFocus;
 
    float paddingTop    = 0;
    float paddingRight  = 0;
    float paddingBottom = 0;
    float paddingLeft   = 0;
 
    Box* contentBox;
    Rect renderedFrame;
    std::vector<Size> cacheFramesData;
    std::vector<IndexPath> cacheIndexPathData;
    std::map<std::string, std::vector<RecyclerCell*>*> queueMap;
    std::map<std::string, std::function<RecyclerCell*(void)>> allocationMap;
 
    bool checkWidth();
    float oldWidth = 0;
 
    void cacheCellFrames();
    void cellsRecyclingLoop();
    void queueReusableCell(RecyclerCell* cell);
 
    void addCellAt(size_t index, size_t downSide);
    void removeCell(View* view);
};
 
} // namespace aurore