/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved. * * SPDX-License-Identifier: GPL-2.0-or-later */ /** \file * \ingroup DNA */ #pragma once #include "BLI_utildefines.h" #include "DNA_asset_types.h" #include "DNA_defs.h" #include "DNA_listBase.h" #include "DNA_vec_types.h" #include "DNA_view2d_types.h" #include "DNA_ID.h" struct ARegion; struct ARegionType; struct PanelType; struct PointerRNA; struct Scene; struct SpaceLink; struct SpaceType; struct uiBlock; struct uiLayout; struct uiList; struct uiListType; struct wmDrawBuffer; struct wmTimer; struct wmTooltipState; struct Panel_Runtime; #ifdef __cplusplus namespace blender::bke { struct FileHandlerType; } using FileHandlerTypeHandle = blender::bke::FileHandlerType; #else typedef struct FileHandlerTypeHandle FileHandlerTypeHandle; #endif /* TODO: Doing this is quite ugly :) * Once the top-bar is merged bScreen should be refactored to use ScrAreaMap. */ #define AREAMAP_FROM_SCREEN(screen) ((ScrAreaMap *)&(screen)->vertbase) typedef struct bScreen { ID id; /* TODO: Should become ScrAreaMap now. * NOTE: KEEP ORDER IN SYNC WITH #ScrAreaMap! (see AREAMAP_FROM_SCREEN macro above). */ /** Screens have vertices/edges to define areas. */ ListBase vertbase; ListBase edgebase; ListBase areabase; /* End variables that must be in sync with #ScrAreaMap. */ /** Screen level regions (menus), runtime only. */ ListBase regionbase; struct Scene *scene DNA_DEPRECATED; /** General flags. */ short flag; /** Window-ID from WM, starts with 1. */ short winid; /** User-setting for which editors get redrawn during animation playback. */ short redraws_flag; /** Temp screen in a temp window, don't save (like user-preferences). */ char temp; /** Temp screen for image render display or file-select. */ char state; /** Notifier for drawing edges. */ char do_draw; /** Notifier for scale screen, changed screen, etc. */ char do_refresh; /** Notifier for gesture draw. */ char do_draw_gesture; /** Notifier for paint cursor draw. */ char do_draw_paintcursor; /** Notifier for dragging draw. */ char do_draw_drag; /** Set to delay screen handling after switching back from maximized area. */ char skip_handling; /** Set when scrubbing to avoid some costly updates. */ char scrubbing; char _pad[1]; /** Active region that has mouse focus. */ struct ARegion *active_region; /** If set, screen has timer handler added in window. */ struct wmTimer *animtimer; /** Context callback. */ void /*bContextDataCallback*/ *context; /** Runtime. */ struct wmTooltipState *tool_tip; PreviewImage *preview; } bScreen; typedef struct ScrVert { struct ScrVert *next, *prev, *newv; vec2s vec; /* first one used internally, second one for tools */ short flag, editflag; } ScrVert; typedef struct ScrEdge { struct ScrEdge *next, *prev; ScrVert *v1, *v2; /** 1 when at edge of screen. */ short border; short flag; char _pad[4]; } ScrEdge; typedef struct ScrAreaMap { /* ** NOTE: KEEP ORDER IN SYNC WITH LISTBASES IN bScreen! ** */ /** ScrVert - screens have vertices/edges to define areas. */ ListBase vertbase; /** ScrEdge. */ ListBase edgebase; /** ScrArea. */ ListBase areabase; } ScrAreaMap; typedef struct LayoutPanelState { struct LayoutPanelState *next, *prev; /** Identifier of the panel. */ char *idname; uint8_t flag; char _pad[7]; } LayoutPanelState; enum LayoutPanelStateFlag { /** If set, the panel is currently open. Otherwise it is collapsed. */ LAYOUT_PANEL_STATE_FLAG_OPEN = (1 << 0), }; /** The part from uiBlock that needs saved in file. */ typedef struct Panel { struct Panel *next, *prev; /** Runtime. */ struct PanelType *type; /** Runtime for drawing. */ struct uiLayout *layout; /** Defined as #BKE_ST_MAXNAME. */ char panelname[64]; /** Panel name is identifier for restoring location. */ char *drawname; /** Offset within the region. */ int ofsx, ofsy; /** Panel size including children. */ int sizex, sizey; /** Panel size excluding children. */ int blocksizex, blocksizey; short labelofs; short flag, runtime_flag; char _pad[6]; /** Panels are aligned according to increasing sort-order. */ int sortorder; /** Runtime for panel manipulation. */ void *activedata; /** Sub panels. */ ListBase children; /** * List of #LayoutPanelState. This stores the open-close-state of layout-panels created with * `layout.panel(...)` in Python. For more information on layout-panels, see `uiLayoutPanelProp`. */ ListBase layout_panel_states; struct Panel_Runtime *runtime; } Panel; /** * Used for passing expansion between instanced panel data and the panels themselves. * There are 16 defines because the expansion data is typically stored in a short. * * \note Expansion for instanced panels is stored in depth first order. For example, the value of * UI_SUBPANEL_DATA_EXPAND_2 correspond to mean the expansion of the second sub-panel or the first * sub-panel's first sub-panel. */ typedef enum uiPanelDataExpansion { UI_PANEL_DATA_EXPAND_ROOT = (1 << 0), UI_SUBPANEL_DATA_EXPAND_1 = (1 << 1), UI_SUBPANEL_DATA_EXPAND_2 = (1 << 2), UI_SUBPANEL_DATA_EXPAND_3 = (1 << 3), UI_SUBPANEL_DATA_EXPAND_4 = (1 << 4), UI_SUBPANEL_DATA_EXPAND_5 = (1 << 5), UI_SUBPANEL_DATA_EXPAND_6 = (1 << 6), UI_SUBPANEL_DATA_EXPAND_7 = (1 << 7), UI_SUBPANEL_DATA_EXPAND_8 = (1 << 8), UI_SUBPANEL_DATA_EXPAND_9 = (1 << 9), UI_SUBPANEL_DATA_EXPAND_10 = (1 << 10), UI_SUBPANEL_DATA_EXPAND_11 = (1 << 11), UI_SUBPANEL_DATA_EXPAND_12 = (1 << 12), UI_SUBPANEL_DATA_EXPAND_13 = (1 << 13), UI_SUBPANEL_DATA_EXPAND_14 = (1 << 14), UI_SUBPANEL_DATA_EXPAND_15 = (1 << 15), } uiPanelDataExpansion; /** * Notes on Panel Categories: * * - #ARegion.panels_category (#PanelCategoryDyn) * is a runtime only list of categories collected during draw. * * - #ARegion.panels_category_active (#PanelCategoryStack) * is basically a list of strings (category id's). * * Clicking on a tab moves it to the front of region->panels_category_active, * If the context changes so this tab is no longer displayed, * then the first-most tab in #ARegion.panels_category_active is used. * * This way you can change modes and always have the tab you last clicked on. */ /* region level tabs */ # # typedef struct PanelCategoryDyn { struct PanelCategoryDyn *next, *prev; char idname[64]; rcti rect; } PanelCategoryDyn; /** Region stack of active tabs. */ typedef struct PanelCategoryStack { struct PanelCategoryStack *next, *prev; char idname[64]; } PanelCategoryStack; typedef void (*uiListFreeRuntimeDataFunc)(struct uiList *ui_list); /* uiList dynamic data... */ /* These two lines with # tell `makesdna` this struct can be excluded. */ # # typedef struct uiListDyn { /** Callback to free UI data when freeing UI-Lists in BKE. */ uiListFreeRuntimeDataFunc free_runtime_data_fn; /** Number of rows needed to draw all elements. */ int height; /** Actual visual height of the list (in rows). */ int visual_height; /** Minimal visual height of the list (in rows). */ int visual_height_min; /** Number of columns drawn for grid layouts. */ int columns; /** Number of items in collection. */ int items_len; /** Number of items actually visible after filtering. */ int items_shown; /* Those are temp data used during drag-resize with GRIP button * (they are in pixels, the meaningful data is the * difference between resize_prev and resize)... */ int resize; int resize_prev; /** Allocated custom data. Freed together with the #uiList (and when re-assigning). */ void *customdata; /* Filtering data. */ /** This bit-field is effectively exposed in Python, and scripts are explicitly allowed to assign * any own meaning to the lower 16 ones. * #items_len length. */ int *items_filter_flags; /** Org_idx -> new_idx, items_len length. */ int *items_filter_neworder; struct wmOperatorType *custom_drag_optype; struct PointerRNA *custom_drag_opptr; struct wmOperatorType *custom_activate_optype; struct PointerRNA *custom_activate_opptr; } uiListDyn; typedef struct uiList { /* some list UI data need to be saved in file */ struct uiList *next, *prev; /** Runtime. */ struct uiListType *type; /** Defined as UI_MAX_NAME_STR. */ char list_id[128]; /** How items are laid out in the list. */ int layout_type; int flag; int list_scroll; int list_grip; int list_last_len; int list_last_activei; /* Filtering data. */ /** Defined as UI_MAX_NAME_STR. */ char filter_byname[128]; int filter_flag; int filter_sort_flag; /** Custom sub-classes properties. */ IDProperty *properties; /** Dynamic data (runtime). */ uiListDyn *dyn_data; } uiList; typedef struct TransformOrientation { struct TransformOrientation *next, *prev; /** MAX_NAME. */ char name[64]; float mat[3][3]; char _pad[4]; } TransformOrientation; /** Some preview UI data need to be saved in file. */ typedef struct uiPreview { struct uiPreview *next, *prev; /** Defined as #BKE_ST_MAXNAME. */ char preview_id[64]; short height; char _pad1[6]; } uiPreview; typedef struct ScrGlobalAreaData { /** * Global areas have a non-dynamic size. That means, changing the window size doesn't * affect their size at all. However, they can still be 'collapsed', by changing this value. * Ignores DPI (#ED_area_global_size_y and winx/winy don't). */ short cur_fixed_height; /** * For global areas, this is the min and max size they can use depending on * if they are 'collapsed' or not. */ short size_min, size_max; /** GlobalAreaAlign. */ short align; /** GlobalAreaFlag. */ short flag; char _pad[2]; } ScrGlobalAreaData; enum GlobalAreaFlag { GLOBAL_AREA_IS_HIDDEN = (1 << 0), }; typedef enum GlobalAreaAlign { GLOBAL_AREA_ALIGN_TOP = 0, GLOBAL_AREA_ALIGN_BOTTOM = 1, } GlobalAreaAlign; typedef struct ScrArea_Runtime { struct bToolRef *tool; char is_tool_set; char _pad0[7]; } ScrArea_Runtime; typedef struct ScrArea { DNA_DEFINE_CXX_METHODS(ScrArea) struct ScrArea *next, *prev; /** Ordered (bottom-left, top-left, top-right, bottom-right). */ ScrVert *v1, *v2, *v3, *v4; /** If area==full, this is the parent. */ bScreen *full; /** Rect bound by v1 v2 v3 v4. */ rcti totrct; /** * eSpace_Type (SPACE_FOO). * * Temporarily used while switching area type, otherwise this should be SPACE_EMPTY. * Also, versioning uses it to nicely replace deprecated * editors. * It's been there for ages, name doesn't fit any more. */ char spacetype; /** #eSpace_Type (SPACE_FOO). */ char butspacetype; short butspacetype_subtype; /** Size. */ short winx, winy; /** OLD! 0=no header, 1= down, 2= up. */ char headertype DNA_DEPRECATED; /** Private, for spacetype refresh callback. */ char do_refresh; short flag; /** * Index of last used region of 'RGN_TYPE_WINDOW' * runtime variable, updated by executing operators. */ short region_active_win; char _pad[2]; /** Callbacks for this space type. */ struct SpaceType *type; /** Non-NULL if this area is global. */ ScrGlobalAreaData *global; /** * #SpaceLink. * A list of space links (editors) that were open in this area before. When * changing the editor type, we try to reuse old editor data from this list. * The first item is the active/visible one. */ ListBase spacedata; /** * #ARegion. * \note This region list is the one from the active/visible editor (first item in * spacedata list). Use SpaceLink.regionbase if it's inactive (but only then)! */ ListBase regionbase; /** #wmEventHandler. */ ListBase handlers; /** #AZone. */ ListBase actionzones; ScrArea_Runtime runtime; } ScrArea; typedef struct ARegion_Runtime { /** Panel category to use between 'layout' and 'draw'. */ const char *category; /** * The visible part of the region, use with region overlap not to draw * on top of the overlapping regions. * * Lazy initialize, zero'd when unset, relative to #ARegion.winrct x/y min. */ rcti visible_rect; /* The offset needed to not overlap with window scroll-bars. Only used by HUD regions for now. */ int offset_x, offset_y; /** Maps #uiBlock::name to uiBlock for faster lookups. */ struct GHash *block_name_map; /* Dummy panel used in popups so they can support layout panels. */ Panel *popup_block_panel; } ARegion_Runtime; typedef struct ARegion { struct ARegion *next, *prev; /** 2D-View scrolling/zoom info (most regions are 2d anyways). */ View2D v2d; /** Coordinates of region. */ rcti winrct; /** Runtime for partial redraw, same or smaller than winrct. */ rcti drawrct; /** Size. */ short winx, winy; /** * This is a Y offset on the panel tabs that represents pixels, * where zero represents no scroll - the first category always shows first at the top. */ int category_scroll; char _pad0[4]; /** Region is currently visible on screen. */ short visible; /** Window, header, etc. identifier for drawing. */ short regiontype; /** How it should split. */ short alignment; /** Hide, .... */ short flag; /** Current split size in unscaled pixels (if zero it uses regiontype). * To convert to pixels use: `UI_SCALE_FAC * region->sizex + 0.5f`. * However to get the current region size, you should usually use winx/winy from above, not this! */ short sizex, sizey; /** Private, cached notifier events. */ short do_draw; /** Private, cached notifier events. */ short do_draw_paintcursor; /** Private, set for indicate drawing overlapped. */ short overlap; /** Temporary copy of flag settings for clean full-screen. */ short flagfullscreen; /** Callbacks for this region type. */ struct ARegionType *type; /** #uiBlock. */ ListBase uiblocks; /** Panel. */ ListBase panels; /** Stack of panel categories. */ ListBase panels_category_active; /** #uiList. */ ListBase ui_lists; /** #uiPreview. */ ListBase ui_previews; /** #wmEventHandler. */ ListBase handlers; /** Panel categories runtime. */ ListBase panels_category; /** Gizmo-map of this region. */ struct wmGizmoMap *gizmo_map; /** Blend in/out. */ struct wmTimer *regiontimer; struct wmDrawBuffer *draw_buffer; /** Use this string to draw info. */ char *headerstr; /** XXX 2.50, need spacedata equivalent? */ void *regiondata; ARegion_Runtime runtime; } ARegion; /** #ScrArea.flag */ enum { HEADER_NO_PULLDOWN = (1 << 0), // AREA_FLAG_UNUSED_1 = (1 << 1), // AREA_FLAG_UNUSED_2 = (1 << 2), #ifdef DNA_DEPRECATED_ALLOW AREA_TEMP_INFO = (1 << 3), /* versioned to make slot reusable */ #endif /** Update size of regions within the area. */ AREA_FLAG_REGION_SIZE_UPDATE = (1 << 3), AREA_FLAG_ACTIVE_TOOL_UPDATE = (1 << 4), // AREA_FLAG_UNUSED_5 = (1 << 5), AREA_FLAG_UNUSED_6 = (1 << 6), /* cleared */ /** * For temporary full-screens (file browser, image editor render) * that are opened above user set full-screens. */ AREA_FLAG_STACKED_FULLSCREEN = (1 << 7), /** Update action zones (even if the mouse is not intersecting them). */ AREA_FLAG_ACTIONZONES_UPDATE = (1 << 8), /** For off-screen areas. */ AREA_FLAG_OFFSCREEN = (1 << 9), }; #define AREAGRID 4 #define AREAMINX 29 #define HEADER_PADDING_Y 6 #define HEADERY (20 + HEADER_PADDING_Y) /** #bScreen.flag */ enum { SCREEN_DEPRECATED = 1, SCREEN_COLLAPSE_STATUSBAR = 2, }; /** #bScreen.state */ enum { SCREENNORMAL = 0, /** One editor taking over the screen. */ SCREENMAXIMIZED = 1, /** One editor taking over the screen with no bare-minimum UI elements. */ SCREENFULL = 2, }; /** #bScreen.redraws_flag */ typedef enum eScreen_Redraws_Flag { TIME_REGION = (1 << 0), TIME_ALL_3D_WIN = (1 << 1), TIME_ALL_ANIM_WIN = (1 << 2), TIME_ALL_BUTS_WIN = (1 << 3), // TIME_WITH_SEQ_AUDIO = (1 << 4), /* DEPRECATED */ TIME_SEQ = (1 << 5), TIME_ALL_IMAGE_WIN = (1 << 6), // TIME_CONTINUE_PHYSICS = (1 << 7), /* UNUSED */ TIME_NODES = (1 << 8), TIME_CLIPS = (1 << 9), TIME_SPREADSHEETS = (1 << 10), TIME_FOLLOW = (1 << 15), } eScreen_Redraws_Flag; /** #Panel.flag */ enum { PNL_SELECT = (1 << 0), PNL_UNUSED_1 = (1 << 1), /* Cleared */ PNL_CLOSED = (1 << 2), // PNL_TABBED = (1 << 3), /* UNUSED */ // PNL_OVERLAP = (1 << 4), /* UNUSED */ PNL_PIN = (1 << 5), PNL_POPOVER = (1 << 6), /** The panel has been drag-drop reordered and the instanced panel list needs to be rebuilt. */ PNL_INSTANCED_LIST_ORDER_CHANGED = (1 << 7), }; /** Fallback panel category (only for old scripts which need updating). */ #define PNL_CATEGORY_FALLBACK "Misc" /** #uiList.layout_type */ enum { UILST_LAYOUT_DEFAULT = 0, UILST_LAYOUT_COMPACT = 1, UILST_LAYOUT_GRID = 2, UILST_LAYOUT_BIG_PREVIEW_GRID = 3, }; /** #uiList.flag */ enum { /** Scroll list to make active item visible. */ UILST_SCROLL_TO_ACTIVE_ITEM = 1 << 0, }; /** Value (in number of items) we have to go below minimum shown items to enable auto size. */ #define UI_LIST_AUTO_SIZE_THRESHOLD 1 /** uiList filter flags (dyn_data) * * \warning Lower 16 bits are meant for custom use in Python, don't use them here! Only use the * higher 16 bits. * \warning Those values are used by integer RNA too, which does not handle well values > INT_MAX. * So please do not use 32nd bit here. */ enum { /* Don't use (1 << 0) to (1 << 15) here! See warning above. */ /* Filtering returned #UI_LIST_ITEM_NEVER_SHOW. */ UILST_FLT_ITEM_NEVER_SHOW = (1 << 16), UILST_FLT_ITEM = 1 << 30, /* This item has passed the filter process successfully. */ }; /** #uiList.filter_flag */ enum { UILST_FLT_SHOW = 1 << 0, /* Show filtering UI. */ UILST_FLT_EXCLUDE = UILST_FLT_ITEM, /* Exclude filtered items, *must* use this same value. */ }; /** #uiList.filter_sort_flag */ enum { /* Plain values (only one is valid at a time, once masked with UILST_FLT_SORT_MASK. */ /** Just for sake of consistency. */ /* UILST_FLT_SORT_INDEX = 0, */ /* UNUSED */ UILST_FLT_SORT_ALPHA = 1, /* Bitflags affecting behavior of any kind of sorting. */ /** Special flag to indicate that order is locked (not user-changeable). */ UILST_FLT_SORT_LOCK = 1u << 30, /** Special value, bit-flag used to reverse order! */ UILST_FLT_SORT_REVERSE = 1u << 31, }; #define UILST_FLT_SORT_MASK (((unsigned int)(UILST_FLT_SORT_REVERSE | UILST_FLT_SORT_LOCK)) - 1) /** * regiontype, first two are the default set. * \warning Do NOT change order, append on end. Types are hard-coded needed. */ typedef enum eRegion_Type { RGN_TYPE_WINDOW = 0, RGN_TYPE_HEADER = 1, RGN_TYPE_CHANNELS = 2, RGN_TYPE_TEMPORARY = 3, RGN_TYPE_UI = 4, RGN_TYPE_TOOLS = 5, RGN_TYPE_TOOL_PROPS = 6, RGN_TYPE_PREVIEW = 7, RGN_TYPE_HUD = 8, /* Region to navigate the main region from (RGN_TYPE_WINDOW). */ RGN_TYPE_NAV_BAR = 9, /* A place for buttons to trigger execution of something that was set up in other regions. */ RGN_TYPE_EXECUTE = 10, RGN_TYPE_FOOTER = 11, RGN_TYPE_TOOL_HEADER = 12, /* Region type used exclusively by internal code and add-ons to register draw callbacks to the XR * context (surface, mirror view). Does not represent any real region. */ RGN_TYPE_XR = 13, RGN_TYPE_ASSET_SHELF = 14, RGN_TYPE_ASSET_SHELF_HEADER = 15, #define RGN_TYPE_NUM (RGN_TYPE_ASSET_SHELF_HEADER + 1) } eRegion_Type; /** Use for function args. */ #define RGN_TYPE_ANY -1 /** Region supports panel tabs (categories). */ #define RGN_TYPE_HAS_CATEGORY_MASK (1 << RGN_TYPE_UI) /** Check for any kind of header region. */ #define RGN_TYPE_IS_HEADER_ANY(regiontype) \ (((1 << (regiontype)) & ((1 << RGN_TYPE_HEADER) | 1 << (RGN_TYPE_TOOL_HEADER) | \ (1 << RGN_TYPE_FOOTER) | (1 << RGN_TYPE_ASSET_SHELF_HEADER))) != 0) /** #ARegion.alignment */ enum { RGN_ALIGN_NONE = 0, RGN_ALIGN_TOP = 1, RGN_ALIGN_BOTTOM = 2, RGN_ALIGN_LEFT = 3, RGN_ALIGN_RIGHT = 4, RGN_ALIGN_HSPLIT = 5, RGN_ALIGN_VSPLIT = 6, RGN_ALIGN_FLOAT = 7, RGN_ALIGN_QSPLIT = 8, /* Maximum 15. */ /* Flags start here. */ /** Region is split into the previous one, they share the same space along a common edge. * Includes the #RGN_ALIGN_HIDE_WITH_PREV behavior. */ RGN_SPLIT_PREV = 1 << 5, /** Always let scaling this region scale the previous region instead. Useful to let regions * appear like they are one (while having independent layout, scrolling, etc.). */ RGN_SPLIT_SCALE_PREV = 1 << 6, /** Whenever the previous region is hidden, this region becomes invisible too. #RGN_FLAG_HIDDEN * should only be set for the previous region, not this. The evaluated visibility respecting this * flag can be queried via #ARegion.visible */ RGN_ALIGN_HIDE_WITH_PREV = 1 << 7, }; /** Mask out flags so we can check the alignment. */ #define RGN_ALIGN_ENUM_FROM_MASK(align) ((align) & ((1 << 4) - 1)) #define RGN_ALIGN_FLAG_FROM_MASK(align) ((align) & ~((1 << 4) - 1)) /** #ARegion.flag */ enum { RGN_FLAG_HIDDEN = (1 << 0), RGN_FLAG_TOO_SMALL = (1 << 1), /** Enable dynamically changing the region size in the #ARegionType::layout() callback. */ RGN_FLAG_DYNAMIC_SIZE = (1 << 2), /** Region data is NULL'd on read, never written. */ RGN_FLAG_TEMP_REGIONDATA = (1 << 3), /** Region resizing by the user is disabled, but the region edge can still be dragged to * hide/unhide the region. */ RGN_FLAG_NO_USER_RESIZE = (1 << 4), /** Size has been clamped (floating regions only). */ RGN_FLAG_SIZE_CLAMP_X = (1 << 5), RGN_FLAG_SIZE_CLAMP_Y = (1 << 6), /** When the user sets the region is hidden, * needed for floating regions that may be hidden for other reasons. */ RGN_FLAG_HIDDEN_BY_USER = (1 << 7), /** Property search filter is active. */ RGN_FLAG_SEARCH_FILTER_ACTIVE = (1 << 8), /** * Update the expansion of the region's panels and switch contexts. Only Set * temporarily when the search filter is updated and cleared at the end of the * region's layout pass. so that expansion is still interactive, */ RGN_FLAG_SEARCH_FILTER_UPDATE = (1 << 9), /** #ARegionType.poll() failed for the current context, and the region should be treated as if it * wouldn't exist. Runtime only flag. */ RGN_FLAG_POLL_FAILED = (1 << 10), RGN_FLAG_RESIZE_RESPECT_BUTTON_SECTIONS = (1 << 11), }; /** #ARegion.do_draw */ enum { /** Region must be fully redrawn. */ RGN_DRAW = 1, /** * Redraw only part of region, for sculpting and painting to get smoother * stroke painting on heavy meshes. */ RGN_DRAW_PARTIAL = 2, /** * For outliner, to do faster redraw without rebuilding outliner tree. * For 3D viewport, to display a new progressive render sample without * while other buffers and overlays remain unchanged. */ RGN_DRAW_NO_REBUILD = 4, /** Set while region is being drawn. */ RGN_DRAWING = 8, /** For popups, to refresh UI layout along with drawing. */ RGN_REFRESH_UI = 16, /** Only editor overlays (currently gizmos only!) should be redrawn. */ RGN_DRAW_EDITOR_OVERLAYS = 32, }; typedef struct AssetShelfSettings { struct AssetShelfSettings *next, *prev; AssetLibraryReference asset_library_reference; ListBase enabled_catalog_paths; /* #LinkData */ /** If not set (null or empty string), all assets will be displayed ("All" catalog behavior). */ const char *active_catalog_path; /** For filtering assets displayed in the asset view. */ char search_string[64]; short preview_size; short display_flag; /* #AssetShelfSettings_DisplayFlag */ char _pad1[4]; #ifdef __cplusplus /* Zero initializes. */ AssetShelfSettings(); /* Proper deep copy. */ AssetShelfSettings(const AssetShelfSettings &other); AssetShelfSettings &operator=(const AssetShelfSettings &other); ~AssetShelfSettings(); #endif } AssetShelfSettings; typedef struct AssetShelf { DNA_DEFINE_CXX_METHODS(AssetShelf) struct AssetShelf *next, *prev; /** Identifier that matches the #AssetShelfType.idname this shelf was created with. Used to * restore the #AssetShelf.type pointer below on file read. */ char idname[64]; /* MAX_NAME */ /** Runtime. */ struct AssetShelfType *type; AssetShelfSettings settings; short preferred_row_count; char _pad[6]; } AssetShelf; /** * Region-data for the main asset shelf region (#RGN_TYPE_ASSET_SHELF). Managed by the asset shelf * internals. * * Contains storage for all previously activated asset shelf instances plus info on the currently * active one (only one can be active at any time). */ typedef struct RegionAssetShelf { /** Owning list of previously activated asset shelves. */ ListBase shelves; /** * The currently active shelf, if any. Updated on redraw, so that context changes are reflected. * Note that this may still be set even though the shelf isn't available anymore * (#AssetShelfType.poll() fails). The pointer isn't necessarily unset when polling. */ AssetShelf *active_shelf; /* Non-owning. */ #ifdef __cplusplus static RegionAssetShelf *get_from_asset_shelf_region(const ARegion ®ion); #endif } RegionAssetShelf; /* #AssetShelfSettings.display_flag */ typedef enum AssetShelfSettings_DisplayFlag { ASSETSHELF_SHOW_NAMES = (1 << 0), } AssetShelfSettings_DisplayFlag; ENUM_OPERATORS(AssetShelfSettings_DisplayFlag, ASSETSHELF_SHOW_NAMES); typedef struct FileHandler { DNA_DEFINE_CXX_METHODS(FileHandler) /** Runtime. */ FileHandlerTypeHandle *type; } FileHandler;