BKE_screen.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once

 
#include <memory>
#include <string>
 
#include "BLI_compiler_attrs.h"
#include "BLI_map.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_string_ref.hh"
#include "BLI_vector.hh"
 
#include "DNA_vec_types.h"
 
#include "RNA_types.hh"
 
#include "BKE_context.hh"
 
namespace blender::bke::id {
class IDRemapper;
}
 
namespace blender::asset_system {
class AssetRepresentation;
}
 
struct ARegion;
struct AssetShelfType;
struct BlendDataReader;
struct BlendLibReader;
struct BlendWriter;
struct Header;
struct ID;
struct LayoutPanelState;
struct LibraryForeachIDData;
struct ListBase;
struct Menu;
struct Panel;
struct Scene;
struct ScrArea;
struct ScrAreaMap;
struct ScrEdge;
struct ScrVert;
struct SpaceType;
struct View3D;
struct View3DShading;
struct WorkSpace;
struct bContext;
struct bScreen;
struct uiBlock;
struct uiLayout;
struct uiList;
struct wmDrawBuffer;
struct wmGizmoMap;
struct wmKeyConfig;
struct wmMsgBus;
struct wmNotifier;
struct wmTimer;
struct wmWindow;
struct wmWindowManager;
 
/* spacetype has everything stored to get an editor working, it gets initialized via
 * #ED_spacetypes_init() in `editors/space_api/spacetypes.cc` */
/* an editor in Blender is a combined ScrArea + SpaceType + SpaceData. */
 
#define BKE_ST_MAXNAME 64
 
struct wmSpaceTypeListenerParams {
  wmWindow *window;
  ScrArea *area;
  const wmNotifier *notifier;
  const Scene *scene;
};
 
struct SpaceType {
  char name[BKE_ST_MAXNAME];
  int spaceid;
  int iconid;

  SpaceLink *(*create)(const ScrArea *area, const Scene *scene);
  void (*free)(SpaceLink *sl);

  void (*init)(wmWindowManager *wm, ScrArea *area);
  void (*exit)(wmWindowManager *wm, ScrArea *area);
  void (*listener)(const wmSpaceTypeListenerParams *params);

  void (*deactivate)(ScrArea *area);

  void (*refresh)(const bContext *C, ScrArea *area);

  SpaceLink *(*duplicate)(SpaceLink *sl);

  void (*operatortypes)();
  void (*keymap)(wmKeyConfig *keyconf);
  void (*dropboxes)();

  void (*gizmos)();

  bContextDataCallback context;

  void (*id_remap)(ScrArea *area, SpaceLink *sl, const blender::bke::id::IDRemapper &mappings);

  void (*foreach_id)(SpaceLink *space_link, LibraryForeachIDData *data);
 
  int (*space_subtype_get)(ScrArea *area);
  void (*space_subtype_set)(ScrArea *area, int value);
  void (*space_subtype_item_extend)(bContext *C, EnumPropertyItem **item, int *totitem);

  blender::StringRefNull (*space_name_get)(const ScrArea *area);
  int (*space_icon_get)(const ScrArea *area);

  void (*blend_read_data)(BlendDataReader *reader, SpaceLink *space_link);

  void (*blend_read_after_liblink)(BlendLibReader *reader, ID *parent_id, SpaceLink *space_link);

  void (*blend_write)(BlendWriter *writer, SpaceLink *space_link);

  ListBase regiontypes;
 
  /* read and write... */

  int keymapflag;
 
  ~SpaceType();
};
 
/* Region types are also defined using spacetypes_init, via a callback. */
 
struct wmRegionListenerParams {
  wmWindow *window;
  ScrArea *area;
  ARegion *region;
  const wmNotifier *notifier;
  const Scene *scene;
};
 
struct wmRegionMessageSubscribeParams {
  const bContext *context;
  wmMsgBus *message_bus;
  WorkSpace *workspace;
  Scene *scene;
  bScreen *screen;
  ScrArea *area;
  ARegion *region;
};
 
struct RegionPollParams {
  const bScreen *screen;
  const ScrArea *area;
  const ARegion *region;

  const bContext *context;
};
 
/* #ARegionType::lock */
enum ARegionDrawLockFlags {
  REGION_DRAW_LOCK_NONE = 0,
  REGION_DRAW_LOCK_RENDER = (1 << 0),
  REGION_DRAW_LOCK_BAKING = (1 << 1),
  REGION_DRAW_LOCK_ALL = (REGION_DRAW_LOCK_RENDER | REGION_DRAW_LOCK_BAKING)
};
 
struct ARegionType {
  ARegionType *next, *prev;
  int regionid;

  void (*init)(wmWindowManager *wm, ARegion *region);
  void (*exit)(wmWindowManager *wm, ARegion *region);
  bool (*poll)(const RegionPollParams *params);
  void (*draw)(const bContext *C, ARegion *region);
  void (*draw_overlay)(const bContext *C, ARegion *region);
  void (*layout)(const bContext *C, ARegion *region);
  int (*snap_size)(const ARegion *region, int size, int axis);
  void (*listener)(const wmRegionListenerParams *params);
  void (*message_subscribe)(const wmRegionMessageSubscribeParams *params);
 
  void (*free)(ARegion *);

  void *(*duplicate)(void *poin);

  void (*operatortypes)();
  void (*keymap)(wmKeyConfig *keyconf);
  void (*cursor)(wmWindow *win, ScrArea *area, ARegion *region);

  bContextDataCallback context;

  void (*on_poll_success)(const bContext *C, ARegion *region);

  void (*on_user_resize)(const ARegion *region);
  void (*on_view2d_changed)(const bContext *C, ARegion *region);

  ListBase drawcalls;

  ListBase paneltypes;

  ListBase headertypes;

  int minsizex, minsizey;
  int prefsizex, prefsizey;
  int keymapflag;
  short do_lock, lock;
  bool clip_gizmo_events_by_ui;
  short event_cursor;
};
 
/* Panel types. */
 
struct PanelType {
  PanelType *next, *prev;

  char idname[BKE_ST_MAXNAME];
  char label[BKE_ST_MAXNAME];
  const char *description;
  char translation_context[BKE_ST_MAXNAME];
  char context[BKE_ST_MAXNAME];
  char category[BKE_ST_MAXNAME];
  char owner_id[128];
  char parent_id[BKE_ST_MAXNAME];
  char active_property[BKE_ST_MAXNAME];
  char pin_to_last_property[BKE_ST_MAXNAME];
  short space_type;
  short region_type;
  int ui_units_x;
  blender::float2 offset_units_xy;
  int order;
 
  int flag;

  bool (*poll)(const bContext *C, PanelType *pt);
  void (*draw_header)(const bContext *C, Panel *panel);
  void (*draw_header_preset)(const bContext *C, Panel *panel);
  void (*draw)(const bContext *C, Panel *panel);
  void (*listener)(const wmRegionListenerParams *params);
 
  /* For instanced panels corresponding to a list: */

  void (*reorder)(bContext *C, Panel *pa, int new_index);
  short (*get_list_data_expand_flag)(const bContext *C, Panel *pa);
  void (*set_list_data_expand_flag)(const bContext *C, Panel *pa, short expand_flag);

  PanelType *parent;
  ListBase children;

  ExtensionRNA rna_ext;
};

enum {
  PANEL_TYPE_DEFAULT_CLOSED = (1 << 0),
  PANEL_TYPE_NO_HEADER = (1 << 1),
  PANEL_TYPE_HEADER_EXPAND = (1 << 2),
  PANEL_TYPE_LAYOUT_VERT_BAR = (1 << 3),
  PANEL_TYPE_INSTANCED = (1 << 4),
  PANEL_TYPE_NO_SEARCH = (1 << 7),
};
 
struct LayoutPanelHeader {
  float start_y;
  float end_y;
  PointerRNA open_owner_ptr;
  std::string open_prop_name;
};
 
struct LayoutPanelBody {
  float start_y;
  float end_y;
};

struct LayoutPanels {
  blender::Vector<LayoutPanelHeader> headers;
  blender::Vector<LayoutPanelBody> bodies;
 
  void clear()
  {
    this->headers.clear();
    this->bodies.clear();
  }
};
 
struct Panel_Runtime {
  int region_ofsx = 0;

  PointerRNA *custom_data_ptr = nullptr;

  uiBlock *block = nullptr;

  bContextStore *context = nullptr;

  LayoutPanels layout_panels;
};
 
namespace blender::bke {
 
struct ARegionRuntime {
  struct ARegionType *type;

  rcti drawrct = {};

  rcti visible_rect = {};

  int offset_x = 0;
  int offset_y = 0;

  const char *category = nullptr;

  Map<std::string, uiBlock *> block_name_map;
  ListBase uiblocks = {};

  ListBase handlers = {};

  char *headerstr = nullptr;

  wmGizmoMap *gizmo_map = nullptr;

  wmTimer *regiontimer = nullptr;
 
  wmDrawBuffer *draw_buffer = nullptr;

  ListBase panels_category = {};

  short visible = 0;

  short do_draw = 0;

  short do_draw_paintcursor;

  Panel *popup_block_panel = nullptr;
};
 
}  // namespace blender::bke
 
/* #uiList types. */

using uiListDrawItemFunc = void (*)(uiList *ui_list,
                                    const bContext *C,
                                    uiLayout *layout,
                                    PointerRNA *dataptr,
                                    PointerRNA *itemptr,
                                    int icon,
                                    PointerRNA *active_dataptr,
                                    const char *active_propname,
                                    int index,
                                    int flt_flag);

using uiListDrawFilterFunc = void (*)(uiList *ui_list, const bContext *C, uiLayout *layout);

using uiListFilterItemsFunc = void (*)(uiList *ui_list,
                                       const bContext *C,
                                       PointerRNA *,
                                       const char *propname);

using uiListListener = void (*)(uiList *ui_list, wmRegionListenerParams *params);
 
struct uiListType {
  uiListType *next, *prev;

  char idname[BKE_ST_MAXNAME];
 
  uiListDrawItemFunc draw_item;
  uiListDrawFilterFunc draw_filter;
  uiListFilterItemsFunc filter_items;

  uiListListener listener;

  ExtensionRNA rna_ext;
};
 
/* Header types. */
 
struct HeaderType {
  HeaderType *next, *prev;
  char idname[BKE_ST_MAXNAME];
  int space_type;
  int region_type;
 
  bool (*poll)(const bContext *C, HeaderType *ht);
  void (*draw)(const bContext *C, Header *header);

  ExtensionRNA rna_ext;
};
 
struct Header {
  HeaderType *type;
  uiLayout *layout;
};
 
/* Menu types. */
 
enum class MenuTypeFlag {
  ContextDependent = (1 << 0),
  SearchOnKeyPress = (1 << 1),
};
ENUM_OPERATORS(MenuTypeFlag, MenuTypeFlag::ContextDependent)
 
struct MenuType {
  MenuType *next, *prev;

  char idname[BKE_ST_MAXNAME];
  char label[BKE_ST_MAXNAME];
  char translation_context[BKE_ST_MAXNAME];
  char owner_id[128];
  const char *description;

  bool (*poll)(const bContext *C, MenuType *mt);
  void (*draw)(const bContext *C, Menu *menu);
  void (*listener)(const wmRegionListenerParams *params);
 
  MenuTypeFlag flag;

  ExtensionRNA rna_ext;
};
 
struct Menu {
  MenuType *type;
  uiLayout *layout;
};
 
/* Asset shelf types. */
 
/* #AssetShelfType.flag */
enum AssetShelfTypeFlag {
  ASSET_SHELF_TYPE_FLAG_NO_ASSET_DRAG = (1 << 0),
  ASSET_SHELF_TYPE_FLAG_DEFAULT_VISIBLE = (1 << 1),
  ASSET_SHELF_TYPE_FLAG_STORE_CATALOGS_IN_PREFS = (1 << 2),
  ASSET_SHELF_TYPE_FLAG_ACTIVATE_FOR_CONTEXT_MENU = (1 << 3),
 
  ASSET_SHELF_TYPE_FLAG_MAX
};
ENUM_OPERATORS(AssetShelfTypeFlag, ASSET_SHELF_TYPE_FLAG_MAX);
 
#define ASSET_SHELF_PREVIEW_SIZE_DEFAULT 48
 
struct AssetShelfType {
  char idname[BKE_ST_MAXNAME];
 
  int space_type;

  std::string activate_operator;
  std::string drag_operator;
 
  AssetShelfTypeFlag flag;
 
  short default_preview_size;

  bool (*poll)(const bContext *C, const AssetShelfType *shelf_type);

  bool (*asset_poll)(const AssetShelfType *shelf_type,
                     const blender::asset_system::AssetRepresentation *asset);

  void (*draw_context_menu)(const bContext *C,
                            const AssetShelfType *shelf_type,
                            const blender::asset_system::AssetRepresentation *asset,
                            uiLayout *layout);
 
  const AssetWeakReference *(*get_active_asset)(const AssetShelfType *shelf_type);

  ExtensionRNA rna_ext;
};
 
/* Space-types. */
 
SpaceType *BKE_spacetype_from_id(int spaceid);
ARegionType *BKE_regiontype_from_id(const SpaceType *st, int regionid);
blender::Span<std::unique_ptr<SpaceType>> BKE_spacetypes_list();
void BKE_spacetype_register(std::unique_ptr<SpaceType> st);
bool BKE_spacetype_exists(int spaceid);
void BKE_spacetypes_free();
 
/* Space-data. */
 
void BKE_spacedata_freelist(ListBase *lb);
void BKE_spacedata_copylist(ListBase *lb_dst, ListBase *lb_src);

void BKE_spacedata_draw_locks(ARegionDrawLockFlags lock_flags);

ARegion *BKE_spacedata_find_region_type(const SpaceLink *slink,
                                        const ScrArea *area,
                                        int region_type) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();
 
void BKE_spacedata_callback_id_remap_set(
    void (*func)(ScrArea *area, SpaceLink *sl, ID *old_id, ID *new_id));
void BKE_spacedata_id_unref(ScrArea *area, SpaceLink *sl, ID *id);
 
/* Area/regions. */
 
ARegion *BKE_area_region_copy(const SpaceType *st, const ARegion *region);
 
ARegion *BKE_area_region_new();

void BKE_area_region_free(SpaceType *st, ARegion *region);
void BKE_area_region_panels_free(ListBase *panels);
Panel *BKE_panel_new(PanelType *panel_type);
void BKE_panel_free(Panel *panel);
void BKE_screen_area_free(ScrArea *area);
void BKE_region_callback_free_gizmomap_set(void (*callback)(wmGizmoMap *));
void BKE_region_callback_refresh_tag_gizmomap_set(void (*callback)(wmGizmoMap *));

LayoutPanelState *BKE_panel_layout_panel_state_ensure(Panel *panel,
                                                      blender::StringRef idname,
                                                      bool default_closed);

ARegion *BKE_region_find_in_listbase_by_type(const ListBase *regionbase, const int region_type);
ARegion *BKE_area_find_region_type(const ScrArea *area, int region_type);
ARegion *BKE_area_find_region_active_win(const ScrArea *area);
ARegion *BKE_area_find_region_xy(const ScrArea *area, int regiontype, const int xy[2])
    ATTR_NONNULL(3);

ARegion *BKE_screen_find_region_type(const bScreen *screen, int region_type) ATTR_NONNULL(1);
ARegion *BKE_screen_find_region_xy(const bScreen *screen,
                                   int regiontype,
                                   const int xy[2]) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1, 3);
 
ARegion *BKE_screen_find_main_region_at_xy(const bScreen *screen, int space_type, const int xy[2])
    ATTR_NONNULL(1, 3);
ScrArea *BKE_screen_find_area_from_space(const bScreen *screen,
                                         const SpaceLink *sl) ATTR_WARN_UNUSED_RESULT
    ATTR_NONNULL(1, 2);
std::optional<std::string> BKE_screen_path_from_screen_to_space(const PointerRNA *ptr);
ScrArea *BKE_screen_find_big_area(const bScreen *screen, int spacetype, short min);
ScrArea *BKE_screen_area_map_find_area_xy(const ScrAreaMap *areamap,
                                          int spacetype,
                                          const int xy[2]) ATTR_NONNULL(1, 3);
ScrArea *BKE_screen_find_area_xy(const bScreen *screen, int spacetype, const int xy[2])
    ATTR_NONNULL(1, 3);
 
void BKE_screen_gizmo_tag_refresh(bScreen *screen);

void BKE_screen_runtime_refresh_for_blendfile(bScreen *screen);
 
void BKE_screen_view3d_sync(View3D *v3d, Scene *scene);
void BKE_screen_view3d_scene_sync(bScreen *screen, Scene *scene);
bool BKE_screen_is_fullscreen_area(const bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();
bool BKE_screen_is_used(const bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();
 
/* Zoom factor conversion. */
 
float BKE_screen_view3d_zoom_to_fac(float camzoom);
float BKE_screen_view3d_zoom_from_fac(float zoomfac);
 
void BKE_screen_view3d_shading_init(View3DShading *shading);
 
/* Screen. */

void BKE_screen_foreach_id_screen_area(LibraryForeachIDData *data, ScrArea *area);

void BKE_screen_free_data(bScreen *screen);
void BKE_screen_area_map_free(ScrAreaMap *area_map) ATTR_NONNULL();
 
ScrEdge *BKE_screen_find_edge(const bScreen *screen, ScrVert *v1, ScrVert *v2);
void BKE_screen_sort_scrvert(ScrVert **v1, ScrVert **v2);
void BKE_screen_remove_double_scrverts(bScreen *screen);
void BKE_screen_remove_double_scredges(bScreen *screen);
void BKE_screen_remove_unused_scredges(bScreen *screen);
void BKE_screen_remove_unused_scrverts(bScreen *screen);
 
void BKE_screen_header_alignment_reset(bScreen *screen);
 
/* .blend file I/O */
 
void BKE_screen_view3d_shading_blend_write(BlendWriter *writer, View3DShading *shading);
void BKE_screen_view3d_shading_blend_read_data(BlendDataReader *reader, View3DShading *shading);
 
void BKE_screen_area_map_blend_write(BlendWriter *writer, ScrAreaMap *area_map);
bool BKE_screen_area_map_blend_read_data(BlendDataReader *reader, ScrAreaMap *area_map);
void BKE_screen_view3d_do_versions_250(View3D *v3d, ListBase *regions);

void BKE_screen_area_blend_read_after_liblink(BlendLibReader *reader,
                                              ID *parent_id,
                                              ScrArea *area);
bool BKE_screen_blend_read_data(BlendDataReader *reader, bScreen *screen);