Blender V5.3
interface_template_operator_property.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BKE_collection.hh"
10#include "BKE_context.hh"
11#include "BKE_file_handler.hh"
12#include "BKE_idprop.hh"
13#include "BKE_screen.hh"
14
15#include "BLI_listbase.hh"
16#include "BLI_string_utf8.hh"
17
18#include "BLT_translation.hh"
19
21
22#include "ED_undo.hh"
23
24#include "RNA_access.hh"
25#include "RNA_prototypes.hh"
26
27#include "WM_api.hh"
28
30#include "interface_intern.hh"
31
32/* we may want to make this optional, disable for now. */
33// #define USE_OP_RESET_BUT
34
35namespace blender::ui {
36
42
43#ifdef USE_OP_RESET_BUT
44static void layout_operator_buts__reset_cb(bContext * /*C*/, void *op_pt, void * /*arg_dummy2*/)
45{
47}
48#endif
49
51 PropertyRNA *prop,
52 void *user_data)
53{
55 user_data);
56
57 if ((params->flag & TEMPLATE_OP_PROPS_HIDE_ADVANCED) &&
59 {
60 return false;
61 }
62 return params->op->type->poll_property(params->C, params->op, prop);
63}
64
66 const bContext *C,
67 wmOperator *op,
68 Layout &layout,
69 const eButLabelAlign label_align,
70 int layout_flags)
71{
72 Block *block = layout.block();
74
75 if (!op->properties) {
76 op->properties = bke::idprop::create_group("wmOperatorProperties").release();
77 }
78
79 /* poll() on this operator may still fail,
80 * at the moment there is no nice feedback when this happens just fails silently. */
81 if (!WM_operator_repeat_check(C, op)) {
82 block_lock_set(block, true, N_("Operator cannot redo"));
83 return return_info;
84 }
85
86 /* useful for macros where only one of the steps can't be re-done */
87 block_lock_clear(block);
88
89 if (layout_flags & TEMPLATE_OP_PROPS_SHOW_TITLE) {
90 layout.label(WM_operatortype_name(op->type, op->ptr), ICON_NONE);
91 }
92
93 /* menu */
94 if ((op->type->flag & OPTYPE_PRESET) && !(layout_flags & TEMPLATE_OP_PROPS_HIDE_PRESETS)) {
95 /* XXX, no simple way to get WM_MT_operator_presets.bl_label
96 * from python! Label remains the same always! */
97 PointerRNA op_ptr;
98
99 block_set_active_operator(block, op, false);
100
101 Layout &row = layout.row(true);
102 row.menu("WM_MT_operator_presets", std::nullopt, ICON_NONE);
103
104 wmOperatorType *ot = WM_operatortype_find("WM_OT_operator_preset_add", false);
105 op_ptr = op_ptr = row.op(ot, "", ICON_ADD, wm::OpCallContext::InvokeDefault, UI_ITEM_NONE);
106 RNA_string_set(&op_ptr, "operator", op->type->idname);
107
108 op_ptr = row.op(ot, "", ICON_REMOVE, wm::OpCallContext::InvokeDefault, UI_ITEM_NONE);
109 RNA_string_set(&op_ptr, "operator", op->type->idname);
110 RNA_boolean_set(&op_ptr, "remove_active", true);
111 }
112
113 if (op->type->ui) {
114 op->layout = &layout;
115 op->type->ui(const_cast<bContext *>(C), op);
116 op->layout = nullptr;
117
118 /* #UI_LAYOUT_OP_SHOW_EMPTY ignored. return_info is ignored too.
119 * We could allow #wmOperatorType.ui callback to return this, but not needed right now. */
120 }
121 else {
124 user_data.C = C;
125 user_data.op = op;
126 user_data.flag = layout_flags;
127 const bool use_prop_split = (layout_flags & TEMPLATE_OP_PROPS_NO_SPLIT_LAYOUT) == 0;
128
130
131 layout.use_property_split_set(use_prop_split);
132 layout.use_property_decorate_set(false);
133
134 /* main draw call */
135 return_info = uiDefAutoButsRNA(&layout,
136 &ptr,
138 nullptr,
139 op->type->poll_property ? &user_data : nullptr,
140 op->type->prop,
141 label_align,
142 (layout_flags & TEMPLATE_OP_PROPS_COMPACT));
143
144 if ((return_info & PROP_BUTS_NONE_ADDED) && (layout_flags & TEMPLATE_OP_PROPS_SHOW_EMPTY)) {
145 layout.label(IFACE_("No Properties"), ICON_NONE);
146 }
147 }
148
149#ifdef USE_OP_RESET_BUT
150 /* its possible that reset can do nothing if all have PROP_SKIP_SAVE enabled
151 * but this is not so important if this button is drawn in those cases
152 * (which isn't all that likely anyway) - campbell */
153 if (op->properties->len) {
154 Button *but;
155
156 /* Needed to avoid alignment errors with previous buttons */
157 Layout &col = layout.column(false);
158 block = col.block();
159 but = uiDefIconTextBut(block,
161 ICON_FILE_REFRESH,
162 IFACE_("Reset"),
163 0,
164 0,
165 UI_UNIT_X,
166 UI_UNIT_Y,
167 nullptr,
168 0.0,
169 0.0,
170 TIP_("Reset operator defaults"));
171 button_func_set(but, layout_operator_buts__reset_cb, op, nullptr);
172 }
173#endif
174
175 /* set various special settings for buttons */
176
177 const bool is_popup = (block->flag & BLOCK_KEEP_OPEN) != 0;
178
179 for (Button &but : block->buttons()) {
180 /* no undo for buttons for operator redo panels */
181 if (!(layout_flags & TEMPLATE_OP_PROPS_ALLOW_UNDO_PUSH)) {
183 }
184
185 /* Only do this if we're not refreshing an existing UI. */
186 if (block->oldblock == nullptr) {
187 /* only for popups, see #36109. */
188
189 /* if button is operator's default property, and a text-field, enable focus for it
190 * - this is used for allowing operators with popups to rename stuff with fewer clicks
191 */
192 if (is_popup && op->type->prop) {
193 if ((but.rnaprop == op->type->prop) && ELEM(but.type, ButtonType::Text, ButtonType::Num)) {
195 }
196 }
197 }
198 }
199
200 return return_info;
201}
202
204 wmOperator *op,
205 Layout &layout,
206 const eButLabelAlign label_align,
207 int layout_flags,
208 bool *r_has_advanced)
209{
210 if (op->type->flag & OPTYPE_MACRO) {
211 for (wmOperator &macro_op : op->macro) {
213 C, &macro_op, layout, label_align, layout_flags, r_has_advanced);
214 }
215 }
216 else {
217 /* Might want to make label_align adjustable somehow. */
219 C, op, layout, label_align, layout_flags);
220 if (return_info & PROP_BUTS_ANY_FAILED_CHECK) {
221 if (r_has_advanced) {
222 *r_has_advanced = true;
223 }
224 }
225 }
226}
227
230 wmOperator *op,
231 int layout_flags)
232{
233 if (op->type->flag & OPTYPE_MACRO) {
234 for (wmOperator &macro_op : op->macro) {
235 if (!layout_operator_properties_only_booleans(C, wm, &macro_op, layout_flags)) {
236 return false;
237 }
238 }
239 }
240 else {
242 user_data.C = C;
243 user_data.op = op;
244 user_data.flag = layout_flags;
245
247
248 bool all_booleans = true;
249 RNA_STRUCT_BEGIN (&ptr, prop) {
250 if (RNA_property_flag(prop) & PROP_HIDDEN) {
251 continue;
252 }
253 if (op->type->poll_property && !layout_operator_buts_poll_property(&ptr, prop, &user_data)) {
254 continue;
255 }
256 if (RNA_property_type(prop) != PROP_BOOLEAN) {
257 all_booleans = false;
258 break;
259 }
260 }
262 if (all_booleans == false) {
263 return false;
264 }
265 }
266
267 return true;
268}
269
271 const bContext *C, Layout *layout, wmOperator *op, eButLabelAlign label_align, short flag)
272{
274
275 /* If there are only checkbox items, don't use split layout by default. It looks weird if the
276 * check-boxes only use half the width. */
279 }
280
281 template_operator_property_buts_draw_recursive(C, op, *layout, label_align, flag, nullptr);
282}
283
285{
287 Block *block = layout->block();
288
289 if (op == nullptr) {
290 return;
291 }
292
293 /* Disable for now, doesn't fit well in popover. */
294#if 0
295 /* Repeat button with operator name as text. */
296 layout->op("SCREEN_OT_repeat_last",
297 WM_operatortype_name(op->type, op->ptr),
298 ICON_NONE,
300 0);
301#endif
302
303 if (WM_operator_repeat_check(C, op)) {
304 int layout_flags = 0;
305 if (block->panel == nullptr) {
306 layout_flags = TEMPLATE_OP_PROPS_SHOW_TITLE;
307 }
308#if 0
309 bool has_advanced = false;
310#endif
311
314 C, op, *layout, BUT_LABEL_ALIGN_NONE, layout_flags, nullptr /* &has_advanced */);
315 /* Warning! this leaves the handle function for any other users of this block. */
316
317#if 0
318 if (has_advanced) {
319 layout->op( "SCREEN_OT_redo_last", IFACE_("More..."), ICON_NONE);
320 }
321#endif
322 }
323}
324
326{
327 /* Copied from #wm_operator_create.
328 * Create a slimmed down operator suitable only for UI drawing. */
329 wmOperator *op = MEM_new<wmOperator>(ot->rna_ext.srna ? __func__ : ot->idname);
330 STRNCPY_UTF8(op->idname, ot->idname);
331 op->type = ot;
332
333 /* Initialize properties but do not assume ownership of them.
334 * This "minimal" operator owns nothing. */
335 op->ptr = MEM_new<PointerRNA>("wmOperatorPtrRNA");
336 op->properties = static_cast<IDProperty *>(properties->data);
337 *op->ptr = *properties;
338
339 return op;
340}
341
342static void draw_import_controls(bContext *C, Layout &layout, const std::string &label, bool valid)
343{
344 layout.label(label, ICON_NONE);
345 if (valid) {
346 Layout &col = layout.column(false);
347
348 Layout &row = col.row(false);
350 row.popover(C, "WM_PT_operator_presets", "", ICON_PRESET);
351 }
352}
353
355 Layout &layout,
356 const bke::FileHandlerType *fh,
357 PointerRNA &importer_ptr,
358 wmOperator *op)
359{
360 Layout &col = layout.column(false);
361
362 col.separator();
363 col.use_property_decorate_set(false);
364
365 /* Style filepath field as alert when empty, it's required for importing. */
366 char filepath[FILE_MAX];
367 RNA_string_get(&importer_ptr, "filepath", filepath);
368 if (!filepath[0]) {
369 col.red_alert_set(true);
370 }
371
372 /* NOTE: This property is used as an alternative to the `filepath` property of `op->ptr`.
373 * This property is a wrapper to access that property, see the `CollectionExport::filepath`
374 * code comments for details. */
375 const std::optional<std::string> filter_glob = fh->filter_glob_from_extensions();
377 C,
378 &importer_ptr,
379 "filepath",
380 nullptr,
381 filter_glob ? filter_glob->c_str() : nullptr,
382 "",
383 IFACE_("Select a file..."));
384
387}
388
390{
391 Collection *collection = CTX_data_collection(C);
392 CollectionImport *data = collection->importer;
393
394 Layout &col = layout->column(false);
395 if (data == nullptr) {
396 col.menu("COLLECTION_MT_importer_add", IFACE_("Add"), ICON_ADD);
397 return;
398 }
399
400 /* If the collection has already been imported, change to the Reload operator. */
401 const char *op_name = "COLLECTION_OT_importer_import";
402 if (data->runtime->archive_library) {
403 op_name = "COLLECTION_OT_importer_reload";
404 }
405
406 Layout &row = layout->row(true);
407 row.op(op_name, IFACE_("Import to Collection"), ICON_IMPORT);
408 row.menu("COLLECTION_MT_importer_control", "", ICON_DOWNARROW_HLT);
409
410 layout->separator();
411
412 /* Draw the importer. */
414 &collection->id, RNA_CollectionImport, data);
415 PanelLayout panel = layout->panel_prop(C, &importer_ptr, "is_open");
416
417 const bke::FileHandlerType *fh = bke::file_handler_find(data->fh_idname);
418 if (!fh) {
419 std::string label = std::string(IFACE_("Undefined")) + " " + data->fh_idname;
420 draw_import_controls(C, *panel.header, label, false);
421 return;
422 }
423
425 if (!ot) {
426 std::string label = std::string(IFACE_("Undefined")) + " " + fh->import_operator;
427 draw_import_controls(C, *panel.header, label, false);
428 return;
429 }
430
431 /* Assign temporary operator to uiBlock, which takes ownership. */
433 &collection->id, ot->srna, data->import_properties);
434 wmOperator *op = minimal_operator_create(ot, &properties);
435 block_set_active_operator(panel.header->block(), op, true);
436
437 /* Draw panel header and contents. */
438 std::string label(fh->label);
439 draw_import_controls(C, *panel.header, label, true);
440 if (panel.body) {
441 draw_import_properties(C, *panel.body, fh, importer_ptr, op);
442 }
443}
444
446 bContext *C, Layout &layout, const std::string &label, int index, bool valid)
447{
448 layout.label(label, ICON_NONE);
449 if (valid) {
450 Layout &row = layout.row(false);
452 row.popover(C, "WM_PT_operator_presets", "", ICON_PRESET);
453 PointerRNA op_ptr = row.op("COLLECTION_OT_exporter_export", "", ICON_EXPORT);
454 RNA_int_set(&op_ptr, "index", index);
455 }
456}
457
459 Layout &layout,
460 PointerRNA &exporter_ptr,
461 wmOperator *op,
462 const std::string &filename)
463{
464 Layout &col = layout.column(false);
465
466 col.use_property_split_set(true);
467 col.use_property_decorate_set(false);
468
469 /* Note this property is used as an alternative to the `filepath` property of `op->ptr`.
470 * This property is a wrapper to access that property, see the `CollectionExport::filepath`
471 * code comments for details. */
472 PropertyRNA *prop = RNA_struct_find_property(&exporter_ptr, "filepath");
473
474 std::string placeholder = "//" + filename;
475 col.prop(&exporter_ptr,
476 prop,
478 0,
480 std::nullopt,
481 ICON_NONE,
482 placeholder.c_str());
483
485 op,
486 layout,
490}
491
492static void draw_exporter_item(uiList * /*ui_list*/,
493 const bContext * /*C*/,
494 Layout &layout,
495 PointerRNA * /*idataptr*/,
496 PointerRNA *itemptr,
497 int /*icon*/,
498 PointerRNA * /*active_dataptr*/,
499 const char * /*active_propname*/,
500 int /*index*/,
501 int /*flt_flag*/)
502{
503 Layout &row = layout.row(false);
505 row.prop(itemptr, "name", UI_ITEM_NONE, "", ICON_NONE);
506}
507
509{
510 Collection *collection = CTX_data_collection(C);
511 ListBaseT<CollectionExport> *exporters = &collection->exporters;
512 const int index = collection->active_exporter_index;
513
514 /* Register the exporter list type on first use. */
515 static const uiListType *exporter_item_list = []() {
516 uiListType *lt = MEM_new_zeroed<uiListType>("template_collection_exporters");
517 STRNCPY_UTF8(lt->idname, "COLLECTION_UL_exporter_list");
520 return lt;
521 }();
522
523 /* Draw exporter list and controls. */
524 PointerRNA collection_ptr = RNA_id_pointer_create(&collection->id);
525 Layout &row = layout->row(false);
527 C,
528 exporter_item_list->idname,
529 "",
530 &collection_ptr,
531 "exporters",
532 &collection_ptr,
533 "active_exporter_index",
534 nullptr,
535 3,
536 5,
539
540 Layout *col = &row.column(true);
541 col->menu("COLLECTION_MT_exporter_add", "", ICON_ADD);
542 PointerRNA op_ptr = col->op("COLLECTION_OT_exporter_remove", "", ICON_REMOVE);
543 RNA_int_set(&op_ptr, "index", index);
544
545 col->separator();
546 op_ptr = col->op("COLLECTION_OT_exporter_move", "", ICON_TRIA_UP);
547 RNA_enum_set(&op_ptr, "direction", -1);
548 op_ptr = col->op("COLLECTION_OT_exporter_move", "", ICON_TRIA_DOWN);
549 RNA_enum_set(&op_ptr, "direction", 1);
550
551 col = &layout->column(true);
552 col->op("COLLECTION_OT_export_all", std::nullopt, ICON_EXPORT);
553 col->enabled_set(!exporters->is_empty());
554
555 /* Draw the active exporter. */
556 CollectionExport *data = static_cast<CollectionExport *>(BLI_findlink(exporters, index));
557 if (!data) {
558 return;
559 }
560
562 &collection->id, RNA_CollectionExport, data);
563 PanelLayout panel = layout->panel_prop(C, &exporter_ptr, "is_open");
564
566 if (!fh) {
567 std::string label = std::string(IFACE_("Undefined")) + " " + data->fh_idname;
568 draw_export_controls(C, *panel.header, label, index, false);
569 return;
570 }
571
573 if (!ot) {
574 std::string label = std::string(IFACE_("Undefined")) + " " + fh->export_operator;
575 draw_export_controls(C, *panel.header, label, index, false);
576 return;
577 }
578
579 /* Assign temporary operator to Block, which takes ownership. */
581 &collection->id, ot->srna, data->export_properties);
582 wmOperator *op = minimal_operator_create(ot, &properties);
583 block_set_active_operator(panel.header->block(), op, true);
584
585 /* Draw panel header and contents. */
586 std::string label(fh->label);
587 draw_export_controls(C, *panel.header, label, index, true);
588 ListBaseT<LayoutPanelState> *prev_layout_panel_states_storage =
590 layout->block()->panel->runtime->layout_panel_states_storage = &data->layout_panel_states;
591 if (panel.body) {
593 C, *panel.body, exporter_ptr, op, fh->get_default_filename(collection->id.name + 2));
594 }
595 layout->block()->panel->runtime->layout_panel_states_storage = prev_layout_panel_states_storage;
596}
597
598} // namespace blender::ui
#define FILE_MAX
#define STRNCPY_UTF8(dst, src)
#define TIP_(msgid)
#define IFACE_(msgid)
Object groups, one object can be in many groups at once.
#define RNA_STRUCT_BEGIN(sptr, prop)
#define RNA_STRUCT_END
#define C
Definition RandGen.cpp:29
#define UI_UNIT_Y
#define UI_UNIT_X
#define UI_ITEM_NONE
#define RNA_NO_INDEX
#define ELEM(...)
std::unique_ptr< IDProperty, IDPropertyDeleter > create_group(StringRef prop_name, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_GROUP.
FileHandlerType * file_handler_find(StringRef idname)
std::string filename(const std::string_view &str, size_t pos)
Button * uiDefIconTextBut(Block *block, ButtonTypeWithPointerType but_and_ptr_type, int icon, StringRef str, int x, int y, short width, short height, void *poin, std::optional< StringRef > tip)
void block_lock_set(Block *block, bool val, const char *lockstr)
static void draw_import_controls(bContext *C, Layout &layout, const std::string &label, bool valid)
void template_filepath(Layout *layout, const bContext *C, PointerRNA *ptr, const StringRefNull propname, const char *pathselect_op, const char *filter_glob, const std::optional< StringRef > name, const std::optional< StringRef > placeholder, bool split_name=false)
void button_func_set(Button *but, std::function< void(bContext &)> func)
static void template_operator_property_buts_draw_recursive(const bContext *C, wmOperator *op, Layout &layout, const eButLabelAlign label_align, int layout_flags, bool *r_has_advanced)
@ TEMPLATE_OP_PROPS_ALLOW_UNDO_PUSH
@ TEMPLATE_OP_PROPS_HIDE_ADVANCED
@ TEMPLATE_OP_PROPS_NO_SPLIT_LAYOUT
void block_lock_clear(Block *block)
static void draw_export_controls(bContext *C, Layout &layout, const std::string &label, int index, bool valid)
static bool layout_operator_properties_only_booleans(const bContext *C, wmWindowManager *wm, wmOperator *op, int layout_flags)
void template_collection_importer(Layout *layout, bContext *C)
void template_uilist(Layout *layout, const bContext *C, const char *listtype_name, const char *list_id, PointerRNA *dataptr, StringRefNull propname, PointerRNA *active_dataptr, StringRefNull active_propname, const char *item_dyntip_propname, int rows, int maxrows, int layout_type, enum TemplateListFlags flags)
static wmOperator * minimal_operator_create(wmOperatorType *ot, PointerRNA *properties)
void button_focus_on_enter_event(wmWindow *win, Button *but)
AutoPropButsReturn uiDefAutoButsRNA(Layout *layout, PointerRNA *ptr, bool(*check_prop)(PointerRNA *ptr, PropertyRNA *prop, void *user_data), void *user_data, PropertyRNA *prop_activate_init, eButLabelAlign label_align, bool compact)
void uiTemplateOperatorPropertyButs(const bContext *C, Layout *layout, wmOperator *op, eButLabelAlign label_align, short flag)
static void draw_import_properties(bContext *C, Layout &layout, const bke::FileHandlerType *fh, PointerRNA &importer_ptr, wmOperator *op)
void template_collection_exporters(Layout *layout, bContext *C)
void template_operator_redo_properties(Layout *layout, const bContext *C)
void button_flag_disable(Button *but, int64_t flag)
void block_func_handle_set(Block *block, BlockHandleFunc func, void *arg)
void block_set_active_operator(Block *block, wmOperator *op, const bool free)
static void draw_export_properties(bContext *C, Layout &layout, PointerRNA &exporter_ptr, wmOperator *op, const std::string &filename)
static AutoPropButsReturn template_operator_property_buts_draw_single(const bContext *C, wmOperator *op, Layout &layout, const eButLabelAlign label_align, int layout_flags)
static void draw_exporter_item(uiList *, const bContext *, Layout &layout, PointerRNA *, PointerRNA *itemptr, int, PointerRNA *, const char *, int, int)
static bool layout_operator_buts_poll_property(PointerRNA *, PropertyRNA *prop, void *user_data)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
std::string WM_operatortype_name(wmOperatorType *ot, PointerRNA *properties)
void WM_operator_properties_reset(wmOperator *op)
PointerRNA RNA_id_pointer_create(ID *id)
void RNA_string_set(PointerRNA *ptr, const char *name, const char *value)
void RNA_int_set(PointerRNA *ptr, const char *name, int value)
wmWindow * CTX_wm_window(const bContext *C)
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
void ED_undo_operator_repeat_cb_evt(bContext *C, void *arg_op, int arg_unused)
Definition ed_undo.cc:961
PropertyType RNA_property_type(PropertyRNA *prop)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
int RNA_property_tags(PropertyRNA *prop)
@ PROP_BOOLEAN
Definition RNA_types.hh:210
BMesh const char void * data
wmWindowManager * CTX_wm_manager(const bContext *C)
int RNA_property_flag(PropertyRNA *prop)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
@ OP_PROP_TAG_ADVANCED
Definition WM_types.hh:277
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
wmOperatorType * WM_operatortype_find(const char *idname, bool quiet)
bool WM_uilisttype_add(uiListType *ult)
@ PROP_HIDDEN
Definition RNA_types.hh:408
wmOperator * WM_operator_last_redo(const bContext *C)
bool WM_operator_repeat_check(const bContext *, wmOperator *op)
@ OPTYPE_PRESET
Definition WM_types.hh:203
@ OPTYPE_MACRO
Definition WM_types.hh:193
std::string RNA_string_get(PointerRNA *ptr, const char *name)
Collection * CTX_data_collection(const bContext *C)
ListBaseT< CollectionExport > exporters
CollectionImport * importer
char name[258]
Definition DNA_ID.h:433
ListBaseT< LayoutPanelState > * layout_panel_states_storage
struct Panel_Runtime * runtime
std::string get_default_filename(StringRefNull name)
char export_operator[OP_MAX_TYPENAME]
char import_operator[OP_MAX_TYPENAME]
std::optional< std::string > filter_glob_from_extensions() const
char idname[BKE_ST_MAXNAME]
uiListDrawItemFunc draw_item
std::ranges::transform_view< std::ranges::ref_view< const Vector< std::unique_ptr< Button > > >, Button &(*)(const std::unique_ptr< Button > &)> buttons() const
void enabled_set(bool enabled)
void use_property_decorate_set(bool is_decorate)
void use_property_split_set(bool is_sep)
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 red_alert_set(bool red_alert)
Layout & column(bool align)
void separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
Layout & row(bool align)
void popover(const bContext *C, PanelType *pt, std::optional< StringRef > name_opt, int icon)
void emboss_set(EmbossType emboss)
bool(*) poll_property(const bContext *C, wmOperator *op, const PropertyRNA *prop) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1171
void(*) ui(bContext *C, wmOperator *op)
Definition WM_types.hh:1176
ListBaseT< wmOperator > macro
struct wmOperatorType * type
#define N_(msgid)