UI_grid_view.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <optional>
 
#include "BLI_function_ref.hh"
#include "BLI_map.hh"
#include "BLI_vector.hh"
 
#include "UI_abstract_view.hh"
#include "UI_resources.hh"
 
struct bContext;
struct uiBlock;
struct uiLayout;
struct View2D;
 
namespace blender::ui {
 
class AbstractGridView;
class GridViewItemDropTarget;
 
/* ---------------------------------------------------------------------- */
class AbstractGridViewItem : public AbstractViewItem {
  friend class AbstractGridView;
  friend class GridViewLayoutBuilder;
 
 protected:
  StringRef identifier_{};
 
 public:
  /* virtual */ ~AbstractGridViewItem() override = default;
 
  virtual void build_grid_tile(const bContext &C, uiLayout &layout) const = 0;
 
  /* virtual */ std::optional<std::string> debug_name() const override;
 
  AbstractGridView &get_view() const;
 
 protected:
  AbstractGridViewItem(StringRef identifier);
 
  /* virtual */ bool matches(const AbstractViewItem &other) const override;
 
  /* virtual */ std::unique_ptr<DropTargetInterface> create_item_drop_target() final;
  virtual std::unique_ptr<GridViewItemDropTarget> create_drop_target();
 
 private:
  static void grid_tile_click_fn(bContext *, void *but_arg1, void *);
  void add_grid_tile_button(uiBlock &block);
};
 
/* ---------------------------------------------------------------------- */
struct GridViewStyle {
  GridViewStyle(int width, int height);
  int tile_width = 0;
  int tile_height = 0;
};
 
class AbstractGridView : public AbstractView {
  friend class AbstractGridViewItem;
  friend class GridViewBuilder;
  friend class GridViewLayoutBuilder;
 
 protected:
  Vector<std::unique_ptr<AbstractGridViewItem>> items_;
  mutable std::optional<int> item_count_filtered_;
  Map<StringRef, AbstractGridViewItem *> item_map_;
  GridViewStyle style_;
 
 public:
  AbstractGridView();
  /* virtual */ ~AbstractGridView() override = default;
 
  using ItemIterFn = FunctionRef<void(AbstractGridViewItem &)>;
  void foreach_item(ItemIterFn iter_fn) const;
  void foreach_filtered_item(ItemIterFn iter_fn) const;
 
  template<class ItemT, typename... Args> inline ItemT &add_item(Args &&...args);
  const GridViewStyle &get_style() const;
  int get_item_count() const;
  int get_item_count_filtered() const;
 
  void set_tile_size(int tile_width, int tile_height);
 
 protected:
  virtual void build_items() = 0;
 
 private:
  void foreach_view_item(FunctionRef<void(AbstractViewItem &)> iter_fn) const final;
  void update_children_from_old(const AbstractView &old_view) override;
  AbstractGridViewItem *find_matching_item(const AbstractGridViewItem &item_to_match,
                                           const AbstractGridView &view_to_search_in) const;
 
  AbstractGridViewItem &add_item(std::unique_ptr<AbstractGridViewItem> item);
};
 
/* ---------------------------------------------------------------------- */
class GridViewItemDropTarget : public DropTargetInterface {
 protected:
  AbstractGridView &view_;
 
 public:
  GridViewItemDropTarget(AbstractGridView &view);
 
  template<class ViewType> inline ViewType &get_view() const;
};
 
/* ---------------------------------------------------------------------- */
class GridViewBuilder {
 public:
  GridViewBuilder(uiBlock &block);
 
  void build_grid_view(const bContext &C,
                       AbstractGridView &grid_view,
                       const View2D &v2d,
                       uiLayout &layout,
                       std::optional<StringRef> search_string = {});
};
 
/* ---------------------------------------------------------------------- */
class PreviewGridItem : public AbstractGridViewItem {
 public:
  using IsActiveFn = std::function<bool()>;
  using ActivateFn = std::function<void(bContext &C, PreviewGridItem &new_active)>;
 
 protected:
  ActivateFn activate_fn_;
  IsActiveFn is_active_fn_;
  bool hide_label_ = false;
 
 public:
  std::string label;
  int preview_icon_id = ICON_NONE;
 
  PreviewGridItem(StringRef identifier, StringRef label, int preview_icon_id);
 
  void build_grid_tile(const bContext &C, uiLayout &layout) const override;
 
  void build_grid_tile_button(uiLayout &layout,
                              BIFIconID override_preview_icon_id = ICON_NONE) const;
 
  void set_on_activate_fn(ActivateFn fn);
  void set_is_active_fn(IsActiveFn fn);
 
  void hide_label();
 
 private:
  std::optional<bool> should_be_active() const override;
  void on_activate(bContext &C) override;
};
 
/* ---------------------------------------------------------------------- */
 
template<class ItemT, typename... Args> inline ItemT &AbstractGridView::add_item(Args &&...args)
{
  static_assert(std::is_base_of<AbstractGridViewItem, ItemT>::value,
                "Type must derive from and implement the AbstractGridViewItem interface");
 
  return dynamic_cast<ItemT &>(add_item(std::make_unique<ItemT>(std::forward<Args>(args)...)));
}
 
template<class ViewType> ViewType &GridViewItemDropTarget::get_view() const
{
  static_assert(std::is_base_of<AbstractGridView, ViewType>::value,
                "Type must derive from and implement the ui::AbstractGridView interface");
  return dynamic_cast<ViewType &>(view_);
}
 
}  // namespace blender::ui