Blender V5.3
screen_user_menu.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2009 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cfloat>
10#include <cstring>
11
12#include "MEM_guardedalloc.h"
13
14#include "AS_asset_library.hh"
16
17#include "BLT_translation.hh"
18
20#include "BKE_context.hh"
21#include "BKE_idprop.hh"
22#include "BKE_screen.hh"
23
24#include "BLI_listbase.hh"
25#include "BLI_string_utf8.hh"
26
27#include "WM_api.hh"
28#include "WM_types.hh"
29
30#include "ED_asset_list.hh"
32#include "ED_screen.hh"
33
35#include "UI_resources.hh"
36
37#include "RNA_access.hh"
38#include "RNA_path.hh"
39#include "RNA_prototypes.hh"
40
41namespace blender {
42
43/* -------------------------------------------------------------------- */
46
47static const char *screen_menu_context_string(const bContext *C, const SpaceLink *sl)
48{
49 if (sl->spacetype == SPACE_NODE) {
50 const SpaceNode *snode = reinterpret_cast<const SpaceNode *>(sl);
51 return snode->tree_idname;
52 }
53 return CTX_data_mode_string(C);
54}
55
57
58/* -------------------------------------------------------------------- */
61
63{
65
66 if (sl == nullptr) {
67 *r_len = 0;
68 return nullptr;
69 }
70
71 const char *context_mode = CTX_data_mode_string(C);
72 const char *context = screen_menu_context_string(C, sl);
73 uint array_len = 3;
74 bUserMenu **um_array = MEM_new_array_zeroed<bUserMenu *>(array_len, __func__);
75 um_array[0] = BKE_blender_user_menu_find(&U.user_menus, sl->spacetype, context);
76 um_array[1] = (sl->spacetype != SPACE_TOPBAR) ?
77 BKE_blender_user_menu_find(&U.user_menus, SPACE_TOPBAR, context_mode) :
78 nullptr;
79 um_array[2] = (sl->spacetype == SPACE_VIEW3D) ?
80 BKE_blender_user_menu_find(&U.user_menus, SPACE_PROPERTIES, context_mode) :
81 nullptr;
82
83 *r_len = array_len;
84 return um_array;
85}
86
88{
90 const char *context = screen_menu_context_string(C, sl);
91 return BKE_blender_user_menu_ensure(&U.user_menus, sl->spacetype, context);
92}
93
95
96/* -------------------------------------------------------------------- */
99
101 const wmOperatorType *ot,
102 IDProperty *prop,
103 const char *op_prop_enum,
104 wm::OpCallContext opcontext)
105{
106 for (bUserMenuItem &umi : *lb) {
107 if (umi.type == USER_MENU_TYPE_OPERATOR) {
108 bUserMenuItem_Op *umi_op = reinterpret_cast<bUserMenuItem_Op *>(&umi);
109 const bool is_strict = prop && umi_op->prop;
110 const bool ok_idprop = IDP_EqualsProperties_ex(prop, umi_op->prop, is_strict);
111 const bool ok_prop_enum = (umi_op->op_prop_enum[0] != '\0') ?
112 STREQ(umi_op->op_prop_enum, op_prop_enum) :
113 true;
114 if (STREQ(ot->idname, umi_op->op_idname) &&
115 (opcontext == wm::OpCallContext(umi_op->opcontext)) && ok_idprop && ok_prop_enum)
116 {
117 return umi_op;
118 }
119 }
120 }
121 return nullptr;
122}
123
125 const MenuType *mt)
126{
127 for (bUserMenuItem &umi : *lb) {
128 if (umi.type == USER_MENU_TYPE_MENU) {
129 bUserMenuItem_Menu *umi_mt = reinterpret_cast<bUserMenuItem_Menu *>(&umi);
130 if (STREQ(mt->idname, umi_mt->mt_idname)) {
131 return umi_mt;
132 }
133 }
134 }
135 return nullptr;
136}
137
139 const char *context_data_path,
140 const char *prop_id,
141 int prop_index)
142{
143 for (bUserMenuItem &umi : *lb) {
144 if (umi.type == USER_MENU_TYPE_PROP) {
145 bUserMenuItem_Prop *umi_pr = reinterpret_cast<bUserMenuItem_Prop *>(&umi);
146 if (STREQ(context_data_path, umi_pr->context_data_path) && STREQ(prop_id, umi_pr->prop_id) &&
147 (prop_index == umi_pr->prop_index))
148 {
149 return umi_pr;
150 }
151 }
152 }
153 return nullptr;
154}
155
156void ED_screen_user_menu_item_add_operator(ListBaseT<bUserMenuItem> *lb,
157 const char *ui_name,
158 const wmOperatorType *ot,
159 const IDProperty *prop,
160 const char *op_prop_enum,
161 wm::OpCallContext opcontext)
162{
163 bUserMenuItem_Op *umi_op = reinterpret_cast<bUserMenuItem_Op *>(
165 umi_op->opcontext = int8_t(opcontext);
166 if (!STREQ(ui_name, ot->name)) {
167 STRNCPY_UTF8(umi_op->item.ui_name, ui_name);
168 }
169 STRNCPY_UTF8(umi_op->op_idname, ot->idname);
170 STRNCPY_UTF8(umi_op->op_prop_enum, op_prop_enum);
171 umi_op->prop = prop ? IDP_CopyProperty(prop) : nullptr;
172}
173
174void ED_screen_user_menu_item_add_menu(ListBaseT<bUserMenuItem> *lb,
175 const char *ui_name,
176 const MenuType *mt)
177{
178 bUserMenuItem_Menu *umi_mt = reinterpret_cast<bUserMenuItem_Menu *>(
180 if (!STREQ(ui_name, mt->label)) {
181 STRNCPY_UTF8(umi_mt->item.ui_name, ui_name);
182 }
183 STRNCPY_UTF8(umi_mt->mt_idname, mt->idname);
184}
185
186void ED_screen_user_menu_item_add_prop(ListBaseT<bUserMenuItem> *lb,
187 const char *ui_name,
188 const char *context_data_path,
189 const char *prop_id,
190 int prop_index)
191{
192 bUserMenuItem_Prop *umi_pr = reinterpret_cast<bUserMenuItem_Prop *>(
194 STRNCPY_UTF8(umi_pr->item.ui_name, ui_name);
195 STRNCPY_UTF8(umi_pr->context_data_path, context_data_path);
196 STRNCPY_UTF8(umi_pr->prop_id, prop_id);
197 umi_pr->prop_index = prop_index;
198}
199
200void ED_screen_user_menu_item_remove(ListBaseT<bUserMenuItem> *lb, bUserMenuItem *umi)
201{
202 BLI_remlink(lb, umi);
204}
205
207
208/* -------------------------------------------------------------------- */
211
213{
215 return ed::asset::list::is_loaded(&all_library_ref);
216}
217
223 bUserMenuItem_Op &umi_op,
224 ui::Layout &row,
225 wmOperatorType *ot,
226 int &r_icon,
227 bool &r_add_operator)
228{
229 if (!umi_op.prop) {
230 return;
231 }
233 opptr.data = bke::idprop::create_group("wmOperatorProperties").release();
236 const bool loading_finished = all_loading_finished();
237 if (!loading_finished) {
238 row.label(IFACE_("Loading Asset Libraries"), ICON_STATUS_INFO);
239 r_add_operator = false;
240 }
241 else {
242 /* Set `check_context_asset` to false because we're setting the context pointer after getting
243 * the asset from the operator properties. */
246 C, opptr, CTX_wm_reports(&C));
247 if (asset) {
248 if (asset->is_online_only()) {
249 r_icon = ICON_INTERNET;
250 }
252 nullptr,
253 RNA_AssetRepresentation,
254 const_cast<asset_system::AssetRepresentation *>(asset));
255 row.context_ptr_set("asset", &asset_ptr);
256 }
257 else {
258 r_add_operator = false;
259 }
260 }
261 }
263}
264
265static void screen_user_menu_draw(const bContext *C, Menu *menu)
266{
267 /* Enable when we have the ability to edit menus. */
268 const bool show_missing = false;
269 char label[512];
270
271 uint um_array_len;
272 bUserMenu **um_array = ED_screen_user_menus_find(C, &um_array_len);
273 bool is_empty = true;
274 for (int um_index = 0; um_index < um_array_len; um_index++) {
275 bUserMenu *um = um_array[um_index];
276 if (um == nullptr) {
277 continue;
278 }
279 for (bUserMenuItem &umi : um->items) {
280 std::optional<StringRefNull> ui_name = umi.ui_name[0] ?
281 std::make_optional<StringRefNull>(umi.ui_name) :
282 std::nullopt;
283 if (umi.type == USER_MENU_TYPE_OPERATOR) {
284 bUserMenuItem_Op *umi_op = reinterpret_cast<bUserMenuItem_Op *>(&umi);
285 if (wmOperatorType *ot = WM_operatortype_find(umi_op->op_idname, false)) {
286 if (ui_name) {
287 ui_name = CTX_IFACE_(ot->translation_context, ui_name->c_str());
288 }
289 if (umi_op->op_prop_enum[0] == '\0') {
290 ui::Layout &row = menu->layout->row(true);
291 int icon = ICON_NONE;
292 bool add_operator = true;
293 handle_operator_asset_reference_props(*C, *umi_op, row, ot, icon, add_operator);
294 if (add_operator) {
295 PointerRNA ptr = row.op(
296 ot, ui_name, icon, wm::OpCallContext(umi_op->opcontext), UI_ITEM_NONE);
297 if (umi_op->prop) {
299 }
300 }
301 }
302 else {
303 /* umi_op->prop could be used to set other properties but it's currently unsupported.
304 */
305 menu->layout->op_menu_enum(C, ot, umi_op->op_prop_enum, ui_name, ICON_NONE);
306 }
307 is_empty = false;
308 }
309 else {
310 if (show_missing) {
311 SNPRINTF_UTF8(label, RPT_("Missing: %s"), umi_op->op_idname);
312 menu->layout->label(label, ICON_NONE);
313 }
314 }
315 }
316 else if (umi.type == USER_MENU_TYPE_MENU) {
317 bUserMenuItem_Menu *umi_mt = reinterpret_cast<bUserMenuItem_Menu *>(&umi);
318 MenuType *mt = WM_menutype_find(umi_mt->mt_idname, false);
319 if (mt != nullptr) {
320 menu->layout->menu(mt, ui_name, ICON_NONE);
321 is_empty = false;
322 }
323 else {
324 if (show_missing) {
325 SNPRINTF_UTF8(label, RPT_("Missing: %s"), umi_mt->mt_idname);
326 menu->layout->label(label, ICON_NONE);
327 }
328 }
329 }
330 else if (umi.type == USER_MENU_TYPE_PROP) {
331 bUserMenuItem_Prop *umi_pr = reinterpret_cast<bUserMenuItem_Prop *>(&umi);
332
333 char *data_path = strchr(umi_pr->context_data_path, '.');
334 if (data_path) {
335 *data_path = '\0';
336 }
338 if (!ptr.has_type()) {
339 PointerRNA ctx_ptr = RNA_pointer_create_discrete(nullptr, RNA_Context, (void *)C);
340 if (!RNA_path_resolve_full(&ctx_ptr, umi_pr->context_data_path, &ptr, nullptr, nullptr))
341 {
342 ptr.type = nullptr;
343 }
344 }
345 if (data_path) {
346 *data_path = '.';
347 data_path += 1;
348 }
349
350 bool ok = false;
351 if (ptr.has_type()) {
352 PropertyRNA *prop = nullptr;
353 PointerRNA prop_ptr = ptr;
354 if ((data_path == nullptr) ||
355 RNA_path_resolve_full(&ptr, data_path, &prop_ptr, nullptr, nullptr))
356 {
357 prop = RNA_struct_find_property(&prop_ptr, umi_pr->prop_id);
358 if (prop) {
359 ok = true;
360 menu->layout->prop(
361 &prop_ptr, prop, umi_pr->prop_index, 0, UI_ITEM_NONE, ui_name, ICON_NONE);
362 is_empty = false;
363 }
364 }
365 }
366 if (!ok) {
367 if (show_missing) {
369 label, RPT_("Missing: %s.%s"), umi_pr->context_data_path, umi_pr->prop_id);
370 menu->layout->label(label, ICON_NONE);
371 }
372 }
373 }
374 else if (umi.type == USER_MENU_TYPE_SEP) {
375 menu->layout->separator();
376 }
377 }
378 }
379 if (um_array) {
380 MEM_delete(um_array);
381 }
382
383 if (is_empty) {
384 menu->layout->label(RPT_("No menu items found"), ICON_NONE);
385 menu->layout->label(RPT_("Right click on buttons to add them to this menu"), ICON_NONE);
386 }
387}
388
399
401
402} // namespace blender
Main runtime representation of an asset.
#define SNPRINTF_UTF8(dst, format,...)
#define STRNCPY_UTF8(dst, src)
#define RPT_(msgid)
#define CTX_IFACE_(context, msgid)
#define IFACE_(msgid)
#define BLT_I18NCONTEXT_DEFAULT_BPYRNA
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define STREQ(a, b)
AssetLibraryReference all_library_reference()
std::unique_ptr< IDProperty, IDPropertyDeleter > create_group(StringRef prop_name, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_GROUP.
bool is_loaded(const AssetLibraryReference *library_reference)
void asset_reading_region_listen_fn(const wmRegionListenerParams *params)
const asset_system::AssetRepresentation * operator_asset_reference_props_get_asset_from_all_library(const bContext &C, PointerRNA &ptr, ReportList *reports)
bool operator_asset_reference_props_is_set(PointerRNA &ptr)
BMesh Iterators.
UserDef U
Definition blender.cc:58
bUserMenu * ED_screen_user_menu_ensure(bContext *C)
const char * CTX_data_mode_string(const bContext *C)
void ED_screen_user_menu_item_add_menu(ListBaseT< bUserMenuItem > *lb, const char *ui_name, const MenuType *mt)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
static void screen_user_menu_draw(const bContext *C, Menu *menu)
unsigned int uint
Definition BKE_text.h:55
bUserMenu * BKE_blender_user_menu_ensure(ListBaseT< bUserMenu > *lb, char space_type, const char *context)
static void handle_operator_asset_reference_props(const bContext &C, bUserMenuItem_Op &umi_op, ui::Layout &row, wmOperatorType *ot, int &r_icon, bool &r_add_operator)
bUserMenuItem * BKE_blender_user_menu_item_add(ListBaseT< bUserMenuItem > *lb, eUserMenu_Type type)
void WM_operator_properties_free(PointerRNA *ptr)
IDProperty * IDP_CopyProperty(const IDProperty *prop) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition idprop.cc:986
MenuType * WM_menutype_find(const StringRef idname, bool quiet)
PointerRNA WM_operator_properties_create_ptr(wmOperatorType *ot)
bUserMenu ** ED_screen_user_menus_find(const bContext *C, uint *r_len)
void ED_screen_user_menu_item_add_prop(ListBaseT< bUserMenuItem > *lb, const char *ui_name, const char *context_data_path, const char *prop_id, int prop_index)
void BKE_blender_user_menu_item_free(bUserMenuItem *umi)
void ED_screen_user_menu_item_add_operator(ListBaseT< bUserMenuItem > *lb, const char *ui_name, const wmOperatorType *ot, const IDProperty *prop, const char *op_prop_enum, wm::OpCallContext opcontext)
bUserMenu * BKE_blender_user_menu_find(ListBaseT< bUserMenu > *lb, char space_type, const char *context)
bUserMenuItem_Menu * ED_screen_user_menu_item_find_menu(ListBaseT< bUserMenuItem > *lb, const MenuType *mt)
void IDP_CopyPropertyContent(IDProperty *dst, const IDProperty *src) ATTR_NONNULL()
Definition idprop.cc:991
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
PointerRNA CTX_data_pointer_get(const bContext *C, const char *member)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
void ED_screen_user_menu_register()
SpaceLink * CTX_wm_space_data(const bContext *C)
wmOperatorType * WM_operatortype_find(const char *idname, bool quiet)
static bool all_loading_finished()
bool WM_menutype_add(MenuType *mt)
void ED_screen_user_menu_item_remove(ListBaseT< bUserMenuItem > *lb, bUserMenuItem *umi)
bUserMenuItem_Prop * ED_screen_user_menu_item_find_prop(ListBaseT< bUserMenuItem > *lb, const char *context_data_path, const char *prop_id, int prop_index)
ReportList * CTX_wm_reports(const bContext *C)
static const char * screen_menu_context_string(const bContext *C, const SpaceLink *sl)
signed char int8_t
Definition BKE_text.h:76
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
bool IDP_EqualsProperties_ex(const IDProperty *prop1, const IDProperty *prop2, bool is_strict) ATTR_WARN_UNUSED_RESULT
Definition idprop.cc:1036
bUserMenuItem_Op * ED_screen_user_menu_item_find_operator(ListBaseT< bUserMenuItem > *lb, const wmOperatorType *ot, IDProperty *prop, const char *op_prop_enum, wm::OpCallContext opcontext)
bool RNA_path_resolve_full(const PointerRNA *ptr, const char *path, PointerRNA *r_ptr, PropertyRNA **r_prop, int *r_index)
Definition rna_path.cc:548
char idname[BKE_ST_MAXNAME]
char translation_context[BKE_ST_MAXNAME]
char label[BKE_ST_MAXNAME]
void(*) draw(const bContext *C, Menu *menu)
void(*) listener(const wmRegionListenerParams *params)
ui::Layout * layout
T * data_as() const
Definition RNA_types.hh:139
bool has_type() const
Definition RNA_types.hh:180
StructRNA * type
Definition RNA_types.hh:63
ListBaseT< bUserMenuItem > items
PointerRNA op_menu_enum(const bContext *C, wmOperatorType *ot, StringRefNull propname, std::optional< StringRefNull > name, int icon)
void label(StringRef name, int icon)
PointerRNA op(wmOperatorType *ot, std::optional< StringRef > name, int icon, wm::OpCallContext context, eUI_Item_Flag flag)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
void menu(MenuType *mt, std::optional< StringRef > name, int icon)
void separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
Layout & row(bool align)
void context_ptr_set(StringRef name, const PointerRNA *ptr)
#define N_(msgid)