UI_interface.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include <functional>
#include <memory>
 
#include "BLI_function_ref.hh"
#include "BLI_string_ref.hh"
#include "BLI_vector.hh"
 
#include "UI_resources.hh"
 
#include "UI_interface_c.hh"  // IWYU pragma: export
 
namespace blender::nodes::geo_eval_log {
struct GeometryAttributeInfo;
}
 
struct ARegion;
struct bContext;
struct PointerRNA;
struct StructRNA;
struct uiBlock;
struct uiBut;
struct uiLayout;
struct uiList;
struct uiSearchItems;
struct wmDrag;
struct wmEvent;
namespace blender::ui {
class AbstractView;
class AbstractViewItem;
}  // namespace blender::ui
 
void UI_but_func_set(uiBut *but, std::function<void(bContext &)> func);
void UI_but_func_pushed_state_set(uiBut *but, std::function<bool(const uiBut &)> func);

template<typename T> void but_func_argN_free(void *argN)
{
  MEM_delete(static_cast<T *>(argN));
}

template<typename T> void *but_func_argN_copy(const void *argN)
{
  return MEM_new<T>(__func__, *static_cast<const T *>(argN));
}
 
namespace blender::ui {
 
class AbstractGridView;
class AbstractTreeView;
class DropTargetInterface;

struct ContextPathItem {
  /* Text to display in the UI. */
  std::string name;
  /* #BIFIconID */
  int icon;
  int icon_indicator_number;
 
  std::function<void(bContext &)> handle_func;
};
 
void context_path_add_generic(Vector<ContextPathItem> &path,
                              StructRNA &rna_type,
                              void *ptr,
                              const BIFIconID icon_override = ICON_NONE,
                              std::function<void(bContext &)> handle_func = nullptr);
 
void template_breadcrumbs(uiLayout &layout, Span<ContextPathItem> context_path);
 
void attribute_search_add_items(StringRef str,
                                bool can_create_attribute,
                                Span<const nodes::geo_eval_log::GeometryAttributeInfo *> infos,
                                uiSearchItems *items,
                                bool is_first);
void grease_pencil_layer_search_add_items(StringRef str,
                                          Span<const std::string *> layer_names,
                                          uiSearchItems &items,
                                          bool is_first);
 
bool asset_shelf_popover_invoke(bContext &C,
                                blender::StringRef asset_shelf_idname,
                                ReportList &reports);
enum class DropBehavior {
  Reorder,
  Insert,
  ReorderAndInsert,
};

enum class DropLocation {
  Into,
  Before,
  After,
};

struct DragInfo {
  const wmDrag &drag_data;
  const wmEvent &event;
  const DropLocation drop_location;
 
  DragInfo(const wmDrag &drag, const wmEvent &event, DropLocation drop_location);
};

class DropTargetInterface {
 public:
  DropTargetInterface() = default;
  virtual ~DropTargetInterface() = default;

  virtual bool can_drop(const wmDrag &drag, const char **r_disabled_hint) const = 0;

  virtual std::optional<DropLocation> choose_drop_location(const ARegion &region,
                                                           const wmEvent &event) const;
  virtual std::string drop_tooltip(const DragInfo &drag) const = 0;
  virtual bool on_drop(bContext *C, const DragInfo &drag) const = 0;
};

bool drop_target_apply_drop(bContext &C,
                            const ARegion &region,
                            const wmEvent &event,
                            const DropTargetInterface &drop_target,
                            const ListBase &drags);
std::string drop_target_tooltip(const ARegion &region,
                                const DropTargetInterface &drop_target,
                                const wmDrag &drag,
                                const wmEvent &event);

std::unique_ptr<DropTargetInterface> region_views_find_drop_target_at(const ARegion *region,
                                                                      const int xy[2]);
 
}  // namespace blender::ui
 
enum eUIListFilterResult {
  UI_LIST_ITEM_NEVER_SHOW,
  UI_LIST_ITEM_FILTER_MATCHES,
  UI_LIST_ITEM_FILTER_MISMATCHES,
};

class uiListNameFilter {
  /* Storage with an inline buffer for smaller strings (small buffer optimization). */
  struct {
    char filter_buff[32];
    char *filter_dyn = nullptr;
  } storage_;
  char *filter_ = nullptr;
 
 public:
  uiListNameFilter(uiList &list);
  ~uiListNameFilter();
 
  eUIListFilterResult operator()(const PointerRNA &itemptr,
                                 blender::StringRefNull name,
                                 int index);
};
 
using uiListItemFilterFn = blender::FunctionRef<eUIListFilterResult(
    const PointerRNA &itemptr, blender::StringRefNull name, int index)>;
using uiListItemGetNameFn =
    blender::FunctionRef<std::string(const PointerRNA &itemptr, int index)>;

void UI_list_filter_and_sort_items(uiList *ui_list,
                                   const bContext *C,
                                   uiListItemFilterFn item_filter_fn,
                                   PointerRNA *dataptr,
                                   const char *propname,
                                   uiListItemGetNameFn get_name_fn = nullptr);

blender::ui::AbstractGridView *UI_block_add_view(
    uiBlock &block,
    blender::StringRef idname,
    std::unique_ptr<blender::ui::AbstractGridView> grid_view);
blender::ui::AbstractTreeView *UI_block_add_view(
    uiBlock &block,
    blender::StringRef idname,
    std::unique_ptr<blender::ui::AbstractTreeView> tree_view);
 
void UI_alert(bContext *C,
              blender::StringRef title,
              blender::StringRef message,
              eAlertIcon icon,
              bool compact);