15#include <fmt/format.h>
110#define USE_GIZMO_MOUSE_PRIORITY_HACK
114 "These structs must match exactly!");
128#define WM_HANDLER_CONTINUE ((eHandlerActionFlag)0)
135 PointerRNA *properties,
138 const bool poll_only,
139 const wmEvent *event);
147 wmEvent *event_state,
148 uint64_t *event_state_prev_press_time_ms_p,
149 const bool is_keyboard,
150 const bool check_double_click);
187 wmEvent *
event = MEM_new<wmEvent>(__func__);
189 *
event = *event_to_add;
219 uint64_t eventstate_prev_press_time_ms = 0;
223 &eventstate_prev_press_time_ms,
238 ListBaseT<wmDrag> *lb =
static_cast<ListBaseT<wmDrag> *
>(
event->customdata);
249 event->customdata =
nullptr;
250 event->customdata_free =
false;
259 printf(
"%s: 'is_repeat=true' for non-keyboard event, this should not happen.\n", __func__);
263 printf(
"%s: 'val != NOTHING' for a cursor motion event, this should not happen.\n", __func__);
281 wmEvent *event_copy = MEM_dupalloc(event);
293 event->next =
event->prev =
nullptr;
305 if (event !=
nullptr) {
345 (
b->category |
b->data |
b->subtype |
b->action)) &&
374 wm->runtime->notifier_queue_set.lookup_key_or_add_cb(¬e_test, [&]() {
375 wmNotifier *note = MEM_new<wmNotifier>(
"wm_event_add_notifier_intern");
417 for (
wmNotifier ¬e :
wm->runtime->notifier_queue.items_mutable()) {
418 if (note.reference == reference) {
419 wm->runtime->notifier_queue_set.remove_contained(¬e);
425 if (
wm->runtime->notifier_current == ¬e) {
439 if (
wm->runtime->message_bus) {
461 if (
wmMsgBus *mbus =
wm->runtime->message_bus) {
462 mappings.
iter([&](
ID *old_id,
ID *new_id) {
463 if (new_id !=
nullptr) {
479 memset((
reinterpret_cast<char *
>(note)) +
sizeof(
Link), 0,
sizeof(*note) -
sizeof(
Link));
494 if (
wm->runtime->is_interface_locked) {
514 if (sequencer_scene && sequencer_scene != scene) {
517 if (is_after_open_file) {
535 if (is_after_open_file) {
569 if (
wm ==
nullptr) [[unlikely]] {
616 bool do_anim =
false;
617 bool clear_info_stats =
false;
622 for (
const wmNotifier *note =
wm->runtime->notifier_queue.first(), *note_next =
nullptr; note;
626 note_next = note->next;
631 wm->runtime->notifier_current = note;
633 if (note->category ==
NC_WM) {
641 else if (note->data ==
ND_UNDO) {
650 if (note->window == &win) {
659 printf(
"%s: Workspace set %p\n", __func__, note->reference);
668 printf(
"%s: Workspace delete %p\n", __func__, workspace);
680 printf(
"%s: screen set %p\n", __func__, note->reference);
689 printf(
"%s: screen delete %p\n", __func__, note->reference);
695 if (note->window == &win ||
696 (note->window ==
nullptr &&
ELEM(note->reference,
nullptr, scene)))
705 clear_info_stats =
true;
708 wm->runtime->notifier_current =
nullptr;
710 note_next = note->next;
717 if (clear_info_stats) {
729 if (
G.is_rendering ==
false) {
750 wm->runtime->notifier_queue_set.remove_contained(note);
757 if (note->category ==
NC_SCREEN && note->reference && note->reference != screen &&
762 else if (note->category ==
NC_SCENE && note->reference &&
772 printf(
"notifier win %d screen %s cat %x\n",
782 region_params.
window = &win;
783 region_params.
area =
nullptr;
784 region_params.
region = ®ion;
785 region_params.
scene = scene;
792 if ((note->category ==
NC_SPACE) && note->reference) {
795 if (!
ELEM(note->reference, area->spacedata.first_, screen, scene)) {
800 area_params.
window = &win;
801 area_params.
area = area;
803 area_params.
scene = scene;
806 for (
ARegion ®ion : area->regionbase) {
808 region_params.
window = &win;
809 region_params.
area = area;
810 region_params.
region = ®ion;
811 region_params.
scene = scene;
837 if (
wm->runtime->winactive) {
877 "Return value for events that should always pass should never be BREAK.");
892 const bool always_pass)
897 static bool do_wheel_ui =
true;
910 if (do_wheel_ui ==
false) {
932 if (handler->
context.region_popup) {
968 bool reactivate_button)
1005 if (win ==
nullptr) {
1006 win =
wm->runtime->winactive;
1007 if (win ==
nullptr) {
1008 win =
wm->windows.first();
1031#ifdef WITH_INPUT_NDOF
1032void WM_ndof_deadzone_set(
float deadzone)
1035 ghost_system->setNDOFDeadZone(deadzone);
1075 format =
RPT_(format);
1077 va_start(args, format);
1096 if (
wm->runtime->undo_stack) {
1097 return intptr_t(
wm->runtime->undo_stack->step_active);
1104 if (
wm->runtime->operators.last()) {
1105 return intptr_t(
wm->runtime->operators.last());
1140 bool msg_free =
false;
1144 RPT_(
"Invalid context: \"%s\", %s"),
1146 msg ?
RPT_(msg) :
RPT_(
"poll failed"));
1162 if (ot->
macro.first() !=
nullptr) {
1210 const bool caller_owns_reports)
1212 if (
G.background == 0 && caller_owns_reports ==
false) {
1219 if (win_prev ==
nullptr) {
1234 if (caller_owns_reports ==
false) {
1242 if (
G.background == 0) {
1283 const bool has_undo_step,
1284 const bool has_register)
1303 if (
wm->op_undo_depth == 0) {
1316 else if (has_undo_step) {
1321 if (!(has_register || do_register)) {
1352 if (hud_status != NOP) {
1353 if (hud_status ==
SET) {
1359 else if (hud_status == CLEAR) {
1381 if (op ==
nullptr || op->
type ==
nullptr) {
1394 wm->op_undo_depth++;
1401 wm->op_undo_depth--;
1417 C, op, repeat, store &&
wm->op_undo_depth == 0, has_undo_step, has_register);
1419 else if (repeat == 0) {
1436 if (op ==
nullptr || op->
type ==
nullptr || op->
type->
exec ==
nullptr) {
1464 op->
flag |= op_flag;
1466 op->
flag &= ~op_flag;
1472 op->
flag |= op_flag;
1474 op->
flag &= ~op_flag;
1486 if (otm && otm->
exec ==
nullptr) {
1500 if (op->
prev ==
nullptr && op->
next ==
nullptr) {
1502 op_prev =
wm->runtime->operators.last();
1507 return (op_prev && (op->
type == op_prev->
type));
1524 op->
ptr = MEM_new<PointerRNA>(
"wmOperatorPtrRNA");
1525 if (properties && properties->
data) {
1538 op->
reports = MEM_new<ReportList>(
"wmOperatorReportList");
1543 if (ot->
macro.first()) {
1548 if (motherop ==
nullptr) {
1559 if (otmacro ==
nullptr) {
1572 opm->
opm = motherop;
1574 otmacro = otmacro->
next;
1585 opm->
opm = motherop;
1608 if (screen ==
nullptr) [[unlikely]] {
1612 for (
ARegion ®ion : area->regionbase) {
1627 event->mval[0] =
event->xy[0] - region->
winrct.
xmin;
1628 event->mval[1] =
event->xy[1] - region->
winrct.
ymin;
1632 event->mval[0] = -1;
1633 event->mval[1] = -1;
1645 const bool poll_only,
1646 bool use_last_properties)
1672 const bool is_nested_call = (
wm->op_undo_depth != 0);
1674 if (event !=
nullptr) {
1679 if (!is_nested_call && use_last_properties) {
1685 "Handle event %d win %p op %s",
1686 event ? event->
type : 0,
1697 wm->op_undo_depth++;
1704 wm->op_undo_depth--;
1709 wm->op_undo_depth++;
1716 wm->op_undo_depth--;
1737 const bool store = !is_nested_call && use_last_properties;
1748 const rcti *wrap_region =
nullptr;
1780 wrap_region = ®ion->
winrct;
1783 wrap_region = &area->
totrct;
1814 const bool poll_only,
1825 if (event ==
nullptr) {
1834 if (window ==
nullptr) {
1895 if (!(region && region->
regiontype == type) && area) {
1966 const char *opstring,
1990 const char *opstring,
1997 &
G_MAIN->wm.first()->id, ot->
srna, properties);
2021 if (!is_undo &&
wm) {
2022 wm->op_undo_depth++;
2028 wm->op_undo_depth--;
2060 if (opwait->
area !=
nullptr) {
2073 enum { CONTINUE = 0, EXECUTE, CANCEL }
state = CONTINUE;
2076 switch (event->
type) {
2109 if (
state != CONTINUE) {
2113 if (
state == EXECUTE) {
2149 depends_on_cursor =
true;
2154 if (!depends_on_cursor) {
2166 std::string header_text = fmt::format(
2167 fmt::runtime(
IFACE_(
"Input pending {}")),
2169 if (area !=
nullptr) {
2184 opwait->
area = area;
2189 if (properties->
data !=
nullptr) {
2218 MEM_delete(handler);
2238 *r_region =
nullptr;
2240 if (screen ==
nullptr || handler->
op ==
nullptr) {
2244 if (handler->
context.area ==
nullptr) {
2251 if (area_iter == handler->
context.area) {
2257#ifdef WITH_XR_OPENXR
2260 if (xr_context !=
nullptr) {
2262 if (handler->
context.area == xr_offscreen_area) {
2263 area = xr_offscreen_area;
2268 if (area ==
nullptr) {
2271 if (handler->
op ==
nullptr) {
2273 "internal error: handler (%s) has invalid area",
2285 handler->
context.region = region;
2292 if ((region ==
nullptr) && handler->
context.region) {
2294 region = handler->
context.region;
2346 wm->op_undo_depth++;
2352 wm->op_undo_depth--;
2380 if (handler->
context.region) {
2383 if (handler->
context.region_popup) {
2393 region_popup_prev =
nullptr;
2422#ifdef WITH_INPUT_IME
2450 if (winevent->
type != kmitype) {
2457 if (winevent->
val != kmi->
val) {
2565 const wmEvent *event_match =
nullptr;
2569 event_match = event;
2572 event_no_dbl_click = *event;
2575 event_match = &event_no_dbl_click;
2579 if (event_match !=
nullptr) {
2580 event_backup->
prev_type =
event->prev_type;
2581 event_backup->
prev_val =
event->prev_val;
2583 event->prev_type = event_match->
type;
2584 event->prev_val = event_match->
val;
2617 event->type =
event->prev_type;
2618 event->val =
event->prev_val;
2620 event->prev_type = event_backup->
prev_type;
2621 event->prev_val = event_backup->
prev_val;
2640 if (handler_iter_op->
op !=
nullptr) {
2642 last_priority_handler = &handler_iter;
2657 if (last_priority_handler) {
2670 ListBaseT<wmEventHandler> *handlers,
2674 const char *kmi_idname)
2690 else if (ot->
modal) {
2708 wm->op_undo_depth++;
2712 retval = ot->
modal(
C, op, event);
2716 wm->op_undo_depth--;
2748 handler->
op =
nullptr;
2752 handler->
op =
nullptr;
2789 bool use_last_properties =
true;
2805 const bool is_tool = (keymap_tool !=
nullptr);
2806 const bool use_tool_properties = is_tool;
2808 if (use_tool_properties) {
2810 keymap_tool, &tool_properties, properties, ot);
2811 properties = &tool_properties;
2812 use_last_properties =
false;
2815 retval =
wm_operator_invoke(
C, ot, event, properties,
nullptr,
false, use_last_properties);
2817 if (use_tool_properties) {
2828 if (gzgt !=
nullptr) {
2831 if (region !=
nullptr) {
2835 gzmap_type, gzgt, region);
2872 if (sfile->
op == file_operator) {
2873 sfile->
op =
nullptr;
2887 ListBaseT<wmEventHandler> *handlers,
2899 U.filebrowser_display_type;
2916 sfile->
op = handler->
op;
2938 handler->
context.win =
nullptr;
2953 if (file_area->
full) {
2978 wm->runtime->winactive = root_win;
2980 else if (file_area->
full) {
2991 if (!temp_win && ctx_area->
full) {
3014 wm->op_undo_depth++;
3022 wm->op_undo_depth--;
3046 if (win_prev ==
nullptr) {
3074 wm->op_undo_depth++;
3080 wm->op_undo_depth--;
3099 ListBaseT<wmEventHandler> *handlers,
3126 return "handled (and pass on)";
3128 return "un-handled";
3142 std::optional<std::string> kmi_props;
3154 return fmt::format(
"{}({})", kmi->
idname, kmi_props.value_or(
""));
3158 if (do_debug_handler) \
3165 ListBaseT<wmEventHandler> *handlers,
3169 const bool do_debug_handler)
3173 if (keymap ==
nullptr) {
3178 PRINT(
"%s: checking '%s' ...", __func__, keymap->
idname);
3192 "Keymap '%s', %s, %s, event: %s",
3200 if (keymap_post.
post_fn !=
nullptr) {
3220 ListBaseT<wmEventHandler> *handlers,
3225 const bool do_debug_handler,
3226 bool *r_keymap_poll)
3229 bool keymap_poll =
false;
3231 PRINT(
"%s: checking '%s' ...", __func__, keymap->
idname);
3238 PRINT(
"%s: item matched '%s'\n", __func__, kmi.
idname);
3250 printf(
"%s: handled - and pass on! '%s'\n", __func__, kmi.
idname);
3256 printf(
"%s: handled - and pass on! '%s'\n", __func__, kmi.
idname);
3260 PRINT(
"%s: un-handled '%s'\n", __func__, kmi.
idname);
3269 if (r_keymap_poll) {
3270 *r_keymap_poll = keymap_poll;
3280 const bool always_pass,
3281 ListBaseT<wmEventHandler> *handlers,
3282 const bool do_debug_handler)
3312 const bool restore_highlight_unless_activated = is_event_drag;
3331 if (restore_highlight_unless_activated ==
false) {
3340 struct PrevGizmoData {
3345 PrevGizmoData prev{};
3357 bool handle_highlight =
false;
3358 bool handle_keymap =
false;
3361 if ((prev.gz_modal ==
nullptr) &&
3362 ((event->
type ==
MOUSEMOVE) || is_event_modifier || is_event_drag))
3364 handle_highlight =
true;
3365 if (is_event_modifier || is_event_drag) {
3366 handle_keymap =
true;
3370 handle_keymap =
true;
3375 if (restore_highlight_unless_activated) {
3376 if ((handle_highlight ==
true) && (handle_keymap ==
false)) {
3381 if (prev.gz_modal ==
nullptr) {
3383 handle_highlight =
true;
3387 if (handle_highlight) {
3392 if (gz || prev.gz) {
3393 if ((prev.gz != gz) || (prev.part != part)) {
3399 if (gz !=
nullptr) {
3412 if (handle_keymap) {
3415 bool keymap_poll =
false;
3419 C, event, handlers, handler, gzgroup, keymap, do_debug_handler, &keymap_poll);
3421#ifdef USE_GIZMO_MOUSE_PRIORITY_HACK
3422 if (((action &
WM_HANDLER_BREAK) == 0) && !is_event_handle_all && keymap_poll) {
3425 wmEvent event_test_click = *event;
3428 wmEvent event_test_press_drag = *event;
3440 is_event_handle_all =
true;
3462 C, event, handlers, handler, &gzgroup, keymap, do_debug_handler,
nullptr);
3472 if (handle_highlight) {
3473 if (restore_highlight_unless_activated) {
3476 if (!(gz_modal && (gz_modal != prev.gz_modal))) {
3482 if (is_event_handle_all) {
3504 ListBaseT<wmEventHandler> *handlers)
3506 const bool do_debug_handler =
3514 if (handlers ==
nullptr) {
3525 for (
wmEventHandler *handler_base = handlers->first(), *handler_base_next;
3526 handler_base && handlers->first();
3527 handler_base = handler_base_next)
3529 handler_base_next = handler_base->next;
3535 else if (handler_base->poll ==
nullptr ||
3554 for (
int km_index = 0; km_index < km_result.
keymaps_len; km_index++) {
3557 C, event, handlers, handler, keymap, do_debug_handler);
3562 action |= action_iter;
3576 if (!
wm->runtime->is_interface_locked) {
3582 if (!
wm->runtime->is_interface_locked && event->
type ==
EVT_DROP) {
3586 ListBaseT<wmDrag> *lb =
static_cast<ListBaseT<wmDrag> *
>(
event->customdata);
3587 for (
wmDrag &drag : lb->items_mutable()) {
3593 if (asset_data->asset->is_online_only()) {
3596 "Asset '%s' is still downloading",
3597 asset_data->asset->get_name().c_str());
3602 if (drop.
poll(
C, &drag, event)) {
3607 ListBaseT<wmDrag> single_lb = {
nullptr};
3609 event->customdata = &single_lb;
3614 C, drop.
ot, drop.
ptr,
nullptr, opcontext,
false, event) :
3628 if (!is_file_read) {
3633 if (!is_file_read) {
3657 C,
wm, handler, event, always_pass, handlers, do_debug_handler);
3662 if (!
wm->runtime->is_interface_locked) {
3718 ListBaseT<wmEventHandler> *handlers)
3724 if (win ==
nullptr) {
3746 const short prev_val =
event->val;
3749 const wmEventType prev_keymodifier =
event->keymodifier;
3752 event->type =
event->prev_press_type;
3753 event->modifier =
event->prev_press_modifier;
3754 event->keymodifier =
event->prev_press_keymodifier;
3755 event->direction = direction;
3761 event->direction = 0;
3762 event->keymodifier = prev_keymodifier;
3763 event->modifier = prev_modifier;
3764 event->val = prev_val;
3765 event->type = prev_type;
3823 "Canceling CLICK_DRAG (key-release exceeds drag threshold)");
3862 "Canceling CLICK_DRAG (button event was handled: value=%d)",
3924 if (screen && area) {
3938 if (pc.poll ==
nullptr || pc.poll(
C)) {
3955 if (
wm->runtime->paintcursors.first()) {
3989 if (
wm->runtime->drags.is_empty()) {
4012 event->customdata = &
wm->runtime->drags;
4013 event->customdata_free =
true;
4067#ifdef WITH_XR_OPENXR
4075static bool wm_event_xr_handler_matches_actiondata(
const wmEventHandler_Op *op_handler,
4076 const wmXrActionData *actiondata)
4078 if (op_handler->op ==
nullptr) {
4082 const bool handler_op_type_match = (op_handler->op->type == actiondata->ot);
4084 actiondata->op_properties);
4086 return (handler_op_type_match && handler_op_properties_match);
4104 ListBaseT<wmEventHandler> *modalhandlers = &win->runtime->modalhandlers;
4108 wmXrActionData *actiondata =
static_cast<wmXrActionData *
>(
event->customdata);
4114 const bool ctx_xr_main_scene_match = (xr_ctx_scene_uid == main_ctx_scene_uid);
4124 if (handler_base.poll !=
nullptr && !handler_base.poll(win, xr_area, xr_region, event)) {
4130 if (wm_event_xr_handler_matches_actiondata(op_handler, actiondata)) {
4132 xr_context, modalhandlers, &handler_base, event,
nullptr,
nullptr);
4144 if (actiondata->ot->modal && event->val ==
KM_RELEASE) {
4149 properties.
type = actiondata->ot->srna;
4150 properties.data = actiondata->op_properties;
4151 if (actiondata->ot->invoke) {
4157 actiondata->op_properties ? &properties :
nullptr,
4165 wm, actiondata->ot, actiondata->op_properties ? &properties :
nullptr,
nullptr);
4178 if (ctx_xr_main_scene_match) {
4202 if (!
wm->runtime->drags.is_empty()) {
4209 C, event,
static_cast<ListBaseT<wmEventHandler> *
>(®ion->
runtime->
handlers));
4237 if (!region_hovered) {
4250 wm->runtime->break_events_handling =
false;
4262 if (
wm->runtime->break_events_handling) {
4273 if (screen ==
nullptr) {
4281 if (
wm->runtime->break_events_handling) {
4314 else if (is_consecutive) {
4327 printf(
"\n%s: Handling event\n", __func__);
4343#ifdef WITH_XR_OPENXR
4345 wm_event_handle_xrevent(
wm, &win, event,
C);
4411#ifdef WITH_INPUT_NDOF
4449 C, event,
static_cast<ListBaseT<wmEventHandler> *
>(&area->handlers));
4539 event.val = eventval;
4541 event.customdata = ophandle;
4569 for (
wmWindow *ctx_win_or_parent = ctx_win; ctx_win_or_parent;
4570 ctx_win_or_parent = ctx_win_or_parent->
parent)
4575 return ctx_win_or_parent;
4578 if (file_area->
full) {
4579 return ctx_win_or_parent;
4586 return wm->windows.first();
4602 ARegion *root_region =
nullptr;
4615 const char *prefix =
"fileselect_add";
4617 const char *prop_id;
4619 prop_id =
"filepath";
4626 "%s: \"%s\" expected a string with a 'FILE_PATH' subtype.",
4631 prop_id =
"directory";
4638 "%s: \"%s\" expected a string with a 'DIR_PATH' subtype.",
4644 prop_id =
"filename";
4651 "%s: \"%s\" expected a string with a 'FILE_NAME' subtype.",
4662 if (ctx_win != root_win) {
4696 if (!root_area && ctx_win == root_win) {
4708 handler->
context.win = root_win;
4709 handler->
context.area = root_area;
4710 handler->
context.region = root_region;
4722 if (ctx_win != root_win) {
4743 if (cdata &&
STREQ(cdata->
id,
id)) {
4755 const size_t id_size = strlen(
id) + 1;
4759 memcpy((cdata + 1),
id, id_size);
4766 if (cdata ==
nullptr) {
4785static void WM_event_set_handler_flag(wmEventHandler *handler,
const int flag)
4787 handler->flag = flag;
4802 handler->
op = op->
opm;
4804 handler->
op->
opm = op;
4811 handler->
context.region = region;
4834 const bool postpone)
4839 if ((handler->
op == op) || (op->
opm && (handler->
op == op->
opm))) {
4871 handler->
context.area = new_area;
4887 handler->
context.region = new_region;
4901 if (handler->
context.region_popup == old_region) {
4902 handler->
context.region_popup = new_region;
4920 if (handler->
keymap == keymap) {
4929 handler->
keymap = keymap;
4951 const bool with_gizmos)
4953 memset(km_result, 0x0,
sizeof(*km_result));
4956 int keymap_id_list_len = 0;
4962 BLI_assert_msg(win !=
nullptr,
"The window should always be set for tool interactions!");
4963 const Scene *scene = win ? win->
scene :
nullptr;
4969 if (tref_rt && tref_rt->
keymap[0]) {
4970 keymap_id_list[keymap_id_list_len++] = tref_rt->
keymap;
4973 bool is_gizmo_visible =
false;
4974 bool is_gizmo_highlight =
false;
4979 bool add_keymap =
false;
4986 if (with_gizmos && (tref_rt->
gizmo_group[0] !=
'\0')) {
4993 if (gzgroup !=
nullptr) {
4998 if (gzgroup !=
nullptr) {
5001 is_gizmo_visible =
true;
5004 is_gizmo_highlight =
true;
5016 if (is_gizmo_visible && !is_gizmo_highlight) {
5017 if (keymap_id_list_len == 2) {
5018 std::swap(keymap_id_list[0], keymap_id_list[1]);
5022 for (
int i = 0; i < keymap_id_list_len; i++) {
5023 const char *keymap_id = keymap_id_list[i];
5029 if (km ==
nullptr) {
5093 handler->
keymap = keymap;
5148 if (markers->is_empty()) {
5172 if (markers && !markers->is_empty()) {
5183 if (handler ==
nullptr) {
5202 if (handler->
keymap == keymap) {
5222 ListBaseT<wmEventHandler> *handlers,
5239 handler->
context.area =
nullptr;
5240 handler->
context.region =
nullptr;
5241 handler->
context.region_popup =
nullptr;
5256 const bool postpone)
5279 ListBaseT<wmEventHandler> *handlers,
5296 ListBaseT<wmDropBox> *dropboxes)
5325 if (handler->
context.area == area) {
5340 if (handler->
op && handler->
op->
type == ot) {
5348static void WM_event_remove_handler(ListBaseT<wmEventHandler> *handlers, wmEventHandler *handler)
5366#ifdef WITH_INPUT_NDOF
5372# define CASE_NDOF_BUTTON(button) \
5373 case GHOST_NDOF_BUTTON_##button: \
5374 return NDOF_BUTTON_##button
5376# define CASE_NDOF_BUTTON_IGNORE(button) \
5377 case GHOST_NDOF_BUTTON_##button: \
5381 CASE_NDOF_BUTTON(MENU);
5382 CASE_NDOF_BUTTON(FIT);
5383 CASE_NDOF_BUTTON(TOP);
5384 CASE_NDOF_BUTTON(LEFT);
5385 CASE_NDOF_BUTTON(RIGHT);
5386 CASE_NDOF_BUTTON(
FRONT);
5387 CASE_NDOF_BUTTON(BOTTOM);
5388 CASE_NDOF_BUTTON(
BACK);
5389 CASE_NDOF_BUTTON(ROLL_CW);
5390 CASE_NDOF_BUTTON(ROLL_CCW);
5391 CASE_NDOF_BUTTON(ISO1);
5392 CASE_NDOF_BUTTON(ISO2);
5393 CASE_NDOF_BUTTON(1);
5394 CASE_NDOF_BUTTON(2);
5395 CASE_NDOF_BUTTON(3);
5396 CASE_NDOF_BUTTON(4);
5397 CASE_NDOF_BUTTON(5);
5398 CASE_NDOF_BUTTON(6);
5399 CASE_NDOF_BUTTON(7);
5400 CASE_NDOF_BUTTON(8);
5401 CASE_NDOF_BUTTON(9);
5402 CASE_NDOF_BUTTON(10);
5403 CASE_NDOF_BUTTON(11);
5404 CASE_NDOF_BUTTON(12);
5405 CASE_NDOF_BUTTON(ROTATE);
5406 CASE_NDOF_BUTTON(PANZOOM);
5407 CASE_NDOF_BUTTON(DOMINANT);
5408 CASE_NDOF_BUTTON(PLUS);
5409 CASE_NDOF_BUTTON(MINUS);
5410 CASE_NDOF_BUTTON(SPIN_CW);
5411 CASE_NDOF_BUTTON(SPIN_CCW);
5412 CASE_NDOF_BUTTON(TILT_CW);
5413 CASE_NDOF_BUTTON(TILT_CCW);
5414 CASE_NDOF_BUTTON(V1);
5415 CASE_NDOF_BUTTON(V2);
5416 CASE_NDOF_BUTTON(V3);
5417 CASE_NDOF_BUTTON(SAVE_V1);
5418 CASE_NDOF_BUTTON(SAVE_V2);
5419 CASE_NDOF_BUTTON(SAVE_V3);
5424 CASE_NDOF_BUTTON_IGNORE(ESC);
5425 CASE_NDOF_BUTTON_IGNORE(ENTER);
5426 CASE_NDOF_BUTTON_IGNORE(DELETE);
5427 CASE_NDOF_BUTTON_IGNORE(TAB);
5428 CASE_NDOF_BUTTON_IGNORE(SPACE);
5429 CASE_NDOF_BUTTON_IGNORE(ALT);
5430 CASE_NDOF_BUTTON_IGNORE(SHIFT);
5431 CASE_NDOF_BUTTON_IGNORE(CTRL);
5433 CASE_NDOF_BUTTON_IGNORE(KBP_F1);
5434 CASE_NDOF_BUTTON_IGNORE(KBP_F2);
5435 CASE_NDOF_BUTTON_IGNORE(KBP_F3);
5436 CASE_NDOF_BUTTON_IGNORE(KBP_F4);
5437 CASE_NDOF_BUTTON_IGNORE(KBP_F5);
5438 CASE_NDOF_BUTTON_IGNORE(KBP_F6);
5439 CASE_NDOF_BUTTON_IGNORE(KBP_F7);
5440 CASE_NDOF_BUTTON_IGNORE(KBP_F8);
5441 CASE_NDOF_BUTTON_IGNORE(KBP_F9);
5442 CASE_NDOF_BUTTON_IGNORE(KBP_F10);
5443 CASE_NDOF_BUTTON_IGNORE(KBP_F11);
5444 CASE_NDOF_BUTTON_IGNORE(KBP_F12);
5446 CASE_NDOF_BUTTON_IGNORE(NP_F1);
5447 CASE_NDOF_BUTTON_IGNORE(NP_F2);
5448 CASE_NDOF_BUTTON_IGNORE(NP_F3);
5449 CASE_NDOF_BUTTON_IGNORE(NP_F4);
5452 CASE_NDOF_BUTTON_IGNORE(
NONE);
5453 CASE_NDOF_BUTTON_IGNORE(INVALID);
5454 CASE_NDOF_BUTTON_IGNORE(USER);
5457# undef CASE_NDOF_BUTTON
5458# undef CASE_NDOF_BUTTON_IGNORE
5610#if defined(__GNUC__) || defined(__clang__)
5637#define CASE_BUTTON(ghost_button, type) \
5638 case ghost_button: \
5682 event->modifier &= ~mod_test;
5694 event->modifier &= ~mod_test;
5706 switch (event->
type) {
5784#ifdef WITH_INPUT_NDOF
5786static void attach_ndof_data(wmEvent *event,
const GHOST_TEventNDOFMotionData *ghost)
5788 wmNDOFMotionData *
data = MEM_new<wmNDOFMotionData>(
"Custom-data NDOF");
5790 const float ts =
U.ndof_translation_sensitivity;
5791 const float rs =
U.ndof_rotation_sensitivity;
5796 data->time_delta = ghost->dt;
5801 event->customdata =
data;
5802 event->customdata_free =
true;
5812 if (!supports_window_position) {
5816 if (
wm->windows.first() ==
wm->windows.last()) {
5825 if (event_xy[0] < 0 || event_xy[1] < 0 || event_xy[0] > win_size[0] ||
5826 event_xy[1] > win_size[1] + 30)
5838 if (win_other && win_other != win) {
5848 const uint64_t event_prev_press_time_ms)
5857 if ((event_time_ms - event_prev_press_time_ms) <
uint64_t(
U.dbl_click_time)) {
5871 event->prev_val = event_state->
prev_val = event_state->
val;
5872 event->prev_type = event_state->
prev_type = event_state->
type;
5877 uint64_t *r_event_state_prev_press_time_ms)
5884 *r_event_state_prev_press_time_ms = event_time_ms;
5900 if (event_last ==
nullptr) {
5918 tevent = *event_last;
5926 memset(&tevent, 0x0,
sizeof(tevent));
5945 if (event_last && event_last->
type == event->
type) {
5946 deltax += event_last->
xy[0] - event_last->
prev_xy[0];
5947 deltay += event_last->
xy[1] - event_last->
prev_xy[1];
5954 event_new->
prev_xy[0] = event_new->
xy[0] - deltax;
5955 event_new->
prev_xy[1] = event_new->
xy[1] - deltay;
5969 uint64_t *event_state_prev_press_time_ms_p,
5970 const bool is_keyboard,
5971 const bool check_double_click)
5982 event_state->
val =
event->val;
5983 event_state->
type =
event->type;
5988 event_state->
modifier =
event->modifier;
5990 event_state->
flag = (
event->flag & event_state_flag_mask);
5995 if (check_double_click &&
6011 uint64_t *event_state_prev_press_time_ms_p,
6015 const bool check_double_click =
true;
6019 event_state_prev_press_time_ms_p,
6021 check_double_click);
6074 const void *customdata,
6095 event = *event_state;
6109 event.prev_type =
event.type;
6110 event.prev_val =
event.val;
6114 if ((
wm->runtime->winactive != win) &&
6115 (
wm->runtime->winactive &&
wm->runtime->winactive->runtime->eventstate))
6117 event.modifier =
wm->runtime->winactive->runtime->eventstate->modifier;
6118 event.keymodifier =
wm->runtime->winactive->runtime->eventstate->keymodifier;
6126 if ((event_state->
type || event_state->
val) &&
6130 "Non-keyboard/mouse button found in 'win->runtime->eventstate->type = %d'",
6137 "Non-keyboard/mouse button found in 'win->runtime->eventstate->prev_type = %d'",
6159 event_state->
tablet.
tilt =
event.tablet.tilt;
6169 event_other.
modifier =
event.modifier;
6197 delta[0] = -delta[0];
6198 delta[1] = -delta[1];
6222#if !defined(WIN32) && !defined(__APPLE__)
6224 char trackpad_scroll_direction =
U.trackpad_scroll_direction;
6261 event_state_prev_press_time_ms_p,
6270 event_other.
modifier =
event.modifier;
6279 event_other.
type =
event.type;
6280 event_other.
val =
event.val;
6281 event_other.
tablet =
event.tablet;
6314 "ghost on your platform is misbehaving, utf8 events on key up!");
6316 event.utf8_buf[0] =
'\0';
6322 event.utf8_buf[0] =
'\0';
6335 "ghost detected non-ASCII single byte character '%u', converting to utf8 "
6336 "('%.*s', length=%d)",
6344 if (utf8_buf_len == -1) {
6346 "ghost detected an invalid unicode character '%d'",
6348 event.utf8_buf[0] =
'\0';
6354 if (utf8_buf_len > 0) {
6356 event.utf8_buf[i] = 0xff;
6382 switch (event.
type) {
6440 event_state_prev_press_time_ms_p,
6467 if (wheelData->
value > 0) {
6469 click_step = wheelData->
value;
6473 click_step = -wheelData->
value;
6477 if (wheelData->
value > 0) {
6479 click_step = wheelData->
value;
6483 click_step = -wheelData->
value;
6491 click_step = std::min(click_step, 32);
6496 for (
int i = 0; i < click_step; i++) {
6503#ifdef WITH_INPUT_NDOF
6504 case GHOST_kEventNDOFMotion: {
6507 attach_ndof_data(&event,
static_cast<const GHOST_TEventNDOFMotionData *
>(customdata));
6514 case GHOST_kEventNDOFButton: {
6515 const GHOST_TEventNDOFButtonData *
e =
static_cast<const GHOST_TEventNDOFButtonData *
>(
6519 switch (
e->action) {
6523 case GHOST_kRelease:
6531 event.customdata =
nullptr;
6536 event_state_prev_press_time_ms_p,
6556#ifdef WITH_INPUT_IME
6566 const wmIMEData *ghost_event_data =
static_cast<const wmIMEData *
>(customdata);
6567 win->
runtime->
ime_data = MEM_new<wmIMEData>(__func__, *ghost_event_data);
6580 const wmIMEData *ghost_event_data =
static_cast<const wmIMEData *
>(customdata);
6581 win->
runtime->
ime_data = MEM_new<wmIMEData>(__func__, *ghost_event_data);
6601#ifdef WITH_XR_OPENXR
6602void wm_event_add_xrevent(wmWindow *win, wmXrActionData *actiondata,
short val)
6611 event.customdata = actiondata;
6612 event.customdata_free =
true;
6632 if (
wm->runtime->is_interface_locked) {
6650 wm->runtime->is_interface_locked = (lock_flags != 0);
6676 memset(km_result, 0x0,
sizeof(*km_result));
6679 if (keymap !=
nullptr) {
6701 ListBaseT<wmEventHandler> *handlers,
6709 else if (handler_base.poll ==
nullptr ||
6716 for (
int km_index = 0; km_index < km_result.
keymaps_len; km_index++) {
6720 if (kmi !=
nullptr) {
6742 if (event_modifier == 0) {
6748 switch (kmi->
type) {
6751 return event_modifier &
KM_CTRL;
6759 return event_modifier &
KM_ALT;
6809 state->modifier =
event->modifier;
6810 state->space_type = space_type;
6811 state->region_type = region_type;
6821 const char *msg = cd->
text[button_index][type_index];
6834 ScrArea *area_statusbar =
nullptr;
6837 area_statusbar = &area;
6841 return area_statusbar;
6848 if (area !=
nullptr) {
6867 if (area_statusbar ==
nullptr) {
6891 if (region ==
nullptr) {
6902 if (area ==
nullptr) {
6937 *bmain, scene, view_layer, area, area->
spacetype);
6967 for (
int button_index = 0; button_index < 3; button_index++) {
6968 cd->
text[button_index][0][0] =
'\0';
6969 cd->
text[button_index][1][0] =
'\0';
6976 ListBaseT<wmEventHandler> *handlers[] = {
6983 for (
int data_index = 0; data_index <
ARRAY_SIZE(event_data); data_index++) {
6984 const int button_index = event_data[data_index].button_index;
6985 const int type_index = event_data[data_index].type_index;
6986 if (cd->
text[button_index][type_index][0] != 0) {
6990 test_event.
type = event_data[data_index].event_type;
6991 test_event.
val = event_data[data_index].event_value;
6995 for (
int handler_index = 0; handler_index <
ARRAY_SIZE(handlers); handler_index++) {
6997 C,
wm, win, handlers[handler_index], &test_event);
7007 STR_ELEM(kmi->
idname,
"WM_OT_call_menu",
"WM_OT_call_menu_pie",
"WM_OT_call_panel"))
7009 name =
IFACE_(
"Options");
7022 STRNCPY(cd->
text[button_index][type_index], name.c_str());
7026 if (memcmp(&cd_prev.
text, &cd->
text,
sizeof(cd_prev.
text)) != 0) {
7047 if (handler->
op !=
nullptr) {
7052 keymap = keymap_test;
7059 if (keymap ==
nullptr || keymap->
modal_items ==
nullptr) {
7066 if (!items[i].identifier[0]) {
7075 const int num_items_used = template_status_bar_modal_item(&row, op, keymap, items + i);
7076 if (num_items_used > 0) {
7078 i += num_items_used - 1;
7084 row.
label(fmt::format(
"{}: {}", *
str, items[i].name), ICON_NONE);
Main runtime representation of an asset.
CustomData interface, see also DNA_customdata_types.h.
#define STRNCPY_UTF8(dst, src)
#define CTX_IFACE_(context, msgid)
#define CTX_RPT_(context, msgid)
#define CLOG_ERROR(clg_ref,...)
#define CLOG_DEBUG(clg_ref,...)
#define CLOG_WARN(clg_ref,...)
#define CLOG_AT_LEVEL(clg_ref, verbose_level,...)
#define CLOG_INFO(clg_ref,...)
These structs are the foundation for all linked lists in the library system.
#define RGN_TYPE_IS_HEADER_ANY(regiontype)
#define OPERATOR_RETVAL_CHECK(ret)
#define ED_screen_areas_iter(win, screen, area_name)
@ GHOST_kEventWheelAxisVertical
@ GHOST_kTrackpadEventMagnify
@ GHOST_kTrackpadEventSmartMagnify
@ GHOST_kTrackpadEventRotate
@ GHOST_kTrackpadEventScroll
@ GHOST_kEventImeComposition
@ GHOST_kEventWindowDeactivate
@ GHOST_kEventImeCompositionStart
@ GHOST_kEventImeCompositionEnd
@ GHOST_kKeyNumpadAsterisk
#define GHOST_kNumEventTypes
@ GHOST_kButtonMaskButton4
@ GHOST_kButtonMaskButton7
@ GHOST_kButtonMaskButton6
@ GHOST_kButtonMaskButton5
@ GHOST_kButtonMaskMiddle
Read Blender memory allocation and freeing.
#define PRF_scope_with_name(ui_name, category)
#define PRF_scope(category)
#define PRF_scope_set_dynamic_name(fmt,...)
#define RNA_STRUCT_BEGIN(sptr, prop)
#define UI_MARKER_MARGIN_Y
#define ND_ASSET_LIST_READING
#define ND_PROJECT_CHANGED
#define WM_UI_HANDLER_CONTINUE
#define WM_OP_CONTEXT_HAS_AREA(type)
#define ND_WORKSPACE_DELETE
#define ND_SPACE_INFO_REPORT
#define WM_EVENT_CURSOR_MOTION_THRESHOLD
#define NOTE_CATEGORY_TAG_CLEARED
#define ND_NODE_ASSET_DATA
#define WM_UI_HANDLER_BREAK
#define BLI_assert_unreachable()
#define BLI_STATIC_ASSERT(a, msg)
#define UNUSED_VARS_NDEBUG(...)
#define SET_FLAG_FROM_TEST(value, test, flag)
#define BLI_assert_msg(a, msg)
unsigned long long int uint64_t
#define PRINT(format,...)
static GHOST_ISystem * getSystem()
void iter(FunctionRef< void(ID *old_id, ID *new_id)> func) const
constexpr bool is_empty() const
#define SET(a, b, c, d, k, s, Ti)
ENUM_OPERATORS(Layer::Flags)
std::unique_ptr< IDProperty, IDPropertyDeleter > create_group(StringRef prop_name, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_GROUP.
void storage_id_remap(ID *id_old, ID *id_new)
void register_node_group_operators(const bContext &C)
BLI_INLINE Texture * wrap(MTLTexture *texture)
void ED_area_type_hud_clear(wmWindowManager *wm, ScrArea *area_keep)
Block * region_block_find_mouse_over(const ARegion *region, const int xy[2], bool only_clip)
void popup_handlers_remove_all(bContext *C, ListBaseT< wmEventHandler > *handlers)
bool popup_region_from_operator(const bScreen *screen, const ARegion *region)
void popup_menu_reports(bContext *C, ReportList *reports) ATTR_NONNULL()
void ED_area_type_hud_ensure(bContext *C, ScrArea *area)
void CustomData_MeshMasks_update(CustomData_MeshMasks *mask_dst, const CustomData_MeshMasks *mask_src)
void WM_main_add_notifier(uint type, void *reference)
void WM_event_set_keymap_handler_post_callback(wmEventHandler_Keymap *handler, void(keymap_tag)(wmKeyMap *keymap, wmKeyMapItem *kmi, void *user_data), void *user_data)
void ED_workspace_do_listen(bContext *C, const wmNotifier *note)
void * MEM_new_uninitialized(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
bool WM_event_match(const wmEvent *winevent, const wmKeyMapItem *kmi)
wmKeyMap * WM_keymap_active(const wmWindowManager *wm, wmKeyMap *keymap)
bool WM_event_consecutive_gesture_test(const wmEvent *event)
bool wm_gizmomap_highlight_pending(const wmGizmoMap *gzmap)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
ARegion * BKE_area_find_region_active_win(const ScrArea *area)
void wm_stereo3d_mouse_offset_apply(wmWindow *win, int r_mouse_xy[2])
static void wm_event_prev_click_set(uint64_t event_time_ms, wmEvent *event_state, uint64_t *r_event_state_prev_press_time_ms)
void WM_global_reportf(eReportType type, const char *format,...)
static std::string keymap_handler_log_kmi_op_str(bContext *C, const wmKeyMapItem *kmi)
wmKeyMap * WM_keymap_list_find_spaceid_or_empty(ListBaseT< wmKeyMap > *lb, const char *idname, int spaceid, int regionid)
unsigned __int64 uint64_t
PointerRNA RNA_property_pointer_get(PointerRNA *ptr, PropertyRNA *prop)
ScrArea * CTX_wm_area(const bContext *C)
void IDP_ReplaceGroupInGroup(IDProperty *dest, const IDProperty *src) ATTR_NONNULL()
static eHandlerActionFlag wm_handlers_do_gizmo_handler(bContext *C, wmWindowManager *wm, wmEventHandler_Gizmo *handler, wmEvent *event, const bool always_pass, ListBaseT< wmEventHandler > *handlers, const bool do_debug_handler)
void WM_report_banner_show(wmWindowManager *wm, wmWindow *win)
MINLINE void copy_v2_v2_int(int r[2], const int a[2])
char * STRNCPY(char(&dst)[N], const char *src)
void WM_operator_free(wmOperator *op)
void WM_msg_id_update(wmMsgBus *mbus, ID *id_src, ID *id_dst)
void ED_screen_set_active_region(bContext *C, wmWindow *win, const int xy[2])
const ListBaseT< wmGizmoGroup > * WM_gizmomap_group_list(wmGizmoMap *gzmap)
void WM_main_remove_notifier_reference(const void *reference)
void WM_event_add_notifier_ex(wmWindowManager *wm, const wmWindow *win, uint type, void *reference)
static void wm_event_free_and_remove_from_queue_if_valid(wmEvent *event)
void ED_preview_restart_work(const bContext *C)
Scene * CTX_data_sequencer_scene(const bContext *C)
size_t BLI_str_utf8_from_unicode(unsigned int c, char *dst, size_t dst_maxncpy) ATTR_NONNULL(2)
static bool wm_action_not_handled(const eHandlerActionFlag action)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
wmDragAsset * WM_drag_get_asset_data(const wmDrag *drag, int idcode)
static void wm_event_free_last_handled(wmWindow *win, wmEvent *event)
void wm_drags_exit(wmWindowManager *wm, wmWindow *win)
bool WM_keymap_poll(bContext *C, wmKeyMap *keymap)
void wm_event_free(wmEvent *event)
ListBaseT< TimeMarker > * ED_scene_markers_get_from_area(const Main &bmain, Scene *scene, ViewLayer *view_layer, const ScrArea *area)
std::string WM_operatortype_name(wmOperatorType *ot, PointerRNA *properties)
void WM_operator_properties_sanitize(PointerRNA *ptr, const bool no_context)
void * BLI_poptail(ListBase *listbase) ATTR_NONNULL(1)
void ED_region_do_listen(wmRegionListenerParams *params)
static ScrArea * area_event_inside(bContext *C, const int xy[2])
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BKE_reports_free(ReportList *reports)
void BKE_report_print_level_set(ReportList *reports, eReportType level)
bool WM_operator_poll_or_report_error(bContext *C, wmOperatorType *ot, ReportList *reports)
@ RGN_TYPE_ASSET_SHELF_HEADER
wmEventHandler_UI * WM_event_add_ui_handler(const bContext *C, ListBaseT< wmEventHandler > *handlers, wmUIHandlerFunc handle_fn, wmUIHandlerRemoveFunc remove_fn, void *user_data, const eWM_EventHandlerFlag flag)
wmOperator * WM_operator_find_modal_by_type(wmWindow *win, const wmOperatorType *ot)
ScrArea * WM_window_status_area_find(wmWindow *win, bScreen *screen)
wmKeyMapItem * WM_event_match_keymap_item(bContext *C, wmKeyMap *keymap, const wmEvent *event)
bool WM_window_modal_keymap_status_draw(bContext *C, wmWindow *win, ui::Layout &layout)
void wm_drop_end(bContext *C, wmDrag *, wmDropBox *)
void WM_operator_properties_free(PointerRNA *ptr)
static void wm_event_handler_ui_cancel(bContext *C)
int WM_toolsystem_mode_from_spacetype(const Main &bmain, const Scene *scene, ViewLayer *view_layer, ScrArea *area, int space_type)
void BKE_spacedata_draw_locks(ARegionDrawLockFlags lock_flags)
bool wm_gizmogroup_is_any_selected(const wmGizmoGroup *gzgroup)
bool ED_undo_is_state_valid(bContext *C)
static bool wm_event_pie_filter(wmWindow *win, const wmEvent *event)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
static bool wm_notifier_is_clear(const wmNotifier *note)
const char * RNA_property_identifier(const PropertyRNA *prop)
static eHandlerActionFlag wm_handler_ui_call(bContext *C, wmEventHandler_UI *handler, const wmEvent *event, const bool always_pass)
static wmOperatorStatus wm_operator_exec_notest(bContext *C, wmOperator *op)
static wmOperatorStatus wm_operator_exec(bContext *C, wmOperator *op, const bool repeat, const bool store)
void RNA_string_set(PointerRNA *ptr, const char *name, const char *value)
IDProperty * IDP_CopyProperty(const IDProperty *prop) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BKE_reports_init(ReportList *reports, int flag)
static bool wm_event_inside_rect(const wmEvent *event, const rcti *rect)
static bool wm_operator_check_locked_interface(bContext *C, wmOperatorType *ot)
bool WM_region_use_viewport(ScrArea *area, ARegion *region)
wmEventHandler_Keymap * WM_event_add_keymap_handler_dynamic(ListBaseT< wmEventHandler > *handlers, wmEventHandler_KeymapDynamicFn keymap_fn, void *user_data)
wmOperatorStatus WM_operator_call(bContext *C, wmOperator *op)
void CTX_wm_window_set(bContext *C, wmWindow *win)
static wmEvent * wm_event_add_mousemove_to_head(wmWindow *win)
WorkSpaceLayout * WM_window_get_active_layout(const wmWindow *win)
wmWindow * WM_window_find_under_cursor(wmWindow *win, const int event_xy[2], int r_event_xy_other[2])
static wmEventType wm_event_type_from_ghost_button(const GHOST_TButton button, const wmEventType fallback)
void ED_area_prevspace(bContext *C, ScrArea *area)
void WM_cursor_modal_set(wmWindow *win, int val)
AZone * ED_area_azones_update(ScrArea *area, const int mouse_xy[2])
bool ED_markers_region_visible(const ScrArea *area, const ARegion *region)
void WM_keyconfig_update(wmWindowManager *wm)
bContext * WM_xr_session_context_get(const wmXrData *xr)
@ OP_IS_MODAL_CURSOR_REGION
@ OP_IS_MODAL_GRAB_CURSOR
void wm_drop_prepare(bContext *C, wmDrag *drag, wmDropBox *drop)
static void wm_event_get_keymap_from_toolsystem_ex(wmWindowManager *wm, wmWindow *win, wmEventHandler_Keymap *handler, wmEventHandler_KeymapResult *km_result, const bool with_gizmos)
static eHandlerActionFlag wm_handler_operator_call(bContext *C, ListBaseT< wmEventHandler > *handlers, wmEventHandler *handler_base, wmEvent *event, PointerRNA *properties, const char *kmi_idname)
static void wm_event_cursor_store(CursorKeymapInfo_State *state, const wmEvent *event, short space_type, short region_type, const bToolRef *tref)
PointerRNA WM_operator_properties_create_ptr(wmOperatorType *ot)
bToolRef * WM_toolsystem_ref_find(WorkSpace *workspace, const bToolKey *tkey)
static wmOperator * wm_operator_create(wmWindowManager *wm, wmOperatorType *ot, PointerRNA *properties, ReportList *reports)
static bool wm_event_is_same_key_press(const wmEvent &event_a, const wmEvent &event_b)
static wmWindow * wm_event_cursor_other_windows(wmWindowManager *wm, wmWindow *win, wmEvent *event)
CLG_LogRef * WM_LOG_EVENTS
void WM_event_consecutive_data_set(wmWindow *win, const char *id, void *custom_data)
wmOperatorStatus WM_operator_call_notest(bContext *C, wmOperator *op)
int(*)(bContext *C, const wmEvent *event, void *userdata) wmUIHandlerFunc
MINLINE int len_manhattan_v2v2_int(const int a[2], const int b[2]) ATTR_WARN_UNUSED_RESULT
void WM_event_print(const wmEvent *event)
wmWindow * CTX_wm_window(const bContext *C)
void WM_window_set_active_workspace(bContext *C, wmWindow *win, WorkSpace *workspace)
void BKE_reports_move_to_reports(ReportList *reports_dst, ReportList *reports_src)
static void wm_paintcursor_tag(bContext *C, wmWindowManager *wm, ARegion *region)
void BKE_reports_clear(ReportList *reports)
constexpr wmTabletData wm_event_tablet_data_default()
wmGizmoGroupType * WM_gizmogrouptype_find(const StringRef idname, bool quiet)
void DEG_make_active(Depsgraph *depsgraph)
void wm_test_autorun_warning(bContext *C)
static void wm_paintcursor_test(bContext *C, const wmEvent *event)
void wm_event_do_notifiers(bContext *C)
void WM_tooltip_clear(bContext *C, wmWindow *win)
static wmEvent * wm_event_add_trackpad(wmWindow *win, const wmEvent *event, int deltax, int deltay)
void ED_undo_push_op(bContext *C, wmOperator *op)
static eHandlerActionFlag wm_handlers_do_intern(bContext *C, wmWindow *win, wmEvent *event, ListBaseT< wmEventHandler > *handlers)
void WM_gizmomap_tag_refresh(wmGizmoMap *gzmap)
void WM_report_banners_cancel(Main *bmain)
@ TOOLREF_FLAG_FALLBACK_KEYMAP
void WM_msgbus_handle(wmMsgBus *mbus, bContext *C)
void(*)(bContext *C, void *userdata) wmUIHandlerRemoveFunc
ViewLayer * WM_window_get_active_view_layer(const wmWindow *win)
void ED_region_tag_redraw(ARegion *region)
bool WM_gizmomap_tag_delay_refresh_for_tweak_check(wmGizmoMap *gzmap)
static void wm_event_state_update_and_click_set_ex(wmEvent *event, uint64_t event_time_ms, wmEvent *event_state, uint64_t *event_state_prev_press_time_ms_p, const bool is_keyboard, const bool check_double_click)
std::string WM_operator_pystring(bContext *C, wmOperator *op, const bool all_args, const bool macro_args)
void WM_event_free_ui_handler_all(bContext *C, ListBaseT< wmEventHandler > *handlers, wmUIHandlerFunc handle_fn, wmUIHandlerRemoveFunc remove_fn)
void MEM_delete_void(void *vmemh)
constexpr std::enable_if_t< blenlib_internal::IsBoundedArray< T >::value, size_t > BOUNDED_ARRAY_TYPE_SIZE() noexcept
void WM_tooltip_timer_init(bContext *C, wmWindow *win, ScrArea *area, ARegion *region, wmTooltipInitFn init)
ScrArea * ED_fileselect_handler_area_find(const wmWindow *win, const wmOperator *file_operator)
static wmWindow * wm_event_find_fileselect_root_window_from_context(const bContext *C)
ViewLayer * CTX_data_view_layer(const bContext *C)
static eHandlerActionFlag wm_handlers_do_keymap_with_gizmo_handler(bContext *C, wmEvent *event, ListBaseT< wmEventHandler > *handlers, wmEventHandler_Gizmo *handler, wmGizmoGroup *gzgroup, wmKeyMap *keymap, const bool do_debug_handler, bool *r_keymap_poll)
bool(*)(const wmWindow *win, const ScrArea *area, const ARegion *region, const wmEvent *event) EventHandlerPoll
void * WM_event_consecutive_data_get(wmWindow *win, const char *id)
void DEG_tag_on_visible_update(Main *bmain, bool do_time)
bool wm_gizmomap_highlight_handled(wmGizmoMap *gzmap)
@ EVT_FILESELECT_FULL_OPEN
@ EVT_FILESELECT_EXTERNAL_CANCEL
void wm_event_free_all(wmWindow *win)
void wm_cursor_position_from_ghost_screen_coords(wmWindow *win, int *x, int *y)
void * BLI_pophead(ListBase *listbase) ATTR_NONNULL(1)
void wm_window_make_drawable(wmWindowManager *wm, wmWindow *win)
void wm_tablet_data_from_ghost(const GHOST_TabletData *tablet_data, wmTabletData *wmtab)
const bContextStore * CTX_store_get(const bContext *C)
bool WM_operator_name_poll(bContext *C, const char *opstring)
wmOperatorStatus WM_operator_call_py(bContext *C, wmOperatorType *ot, wm::OpCallContext context, PointerRNA *properties, ReportList *reports, const bool is_undo)
void ED_undo_grouped_push_op(bContext *C, wmOperator *op)
void WM_locked_interface_set(wmWindowManager *wm, bool lock)
PropertyType RNA_property_type(PropertyRNA *prop)
static bool notifier_refreshes_node_group_operators(const wmNotifier ¬e)
void WM_event_modal_handler_area_replace(wmWindow *win, const ScrArea *old_area, ScrArea *new_area)
wmOperatorStatus WM_operator_call_ex(bContext *C, wmOperator *op, const bool store)
int WM_event_drag_direction(const wmEvent *event)
wmGizmo * wm_gizmomap_highlight_find(wmGizmoMap *gzmap, bContext *C, const wmEvent *event, int *r_part)
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void WM_locked_interface_set_with_flags(wmWindowManager *wm, short lock_flags)
@ WM_EVENT_FORCE_DRAG_THRESHOLD
@ WM_EVENT_IS_CONSECUTIVE
void WM_event_remove_handlers(bContext *C, ListBaseT< wmEventHandler > *handlers)
void CTX_wm_operator_poll_msg_set(bContext *C, const char *msg)
BLI_INLINE void wm_event_handler_return_value_check(const bContext *C, const wmEvent *event, const eHandlerActionFlag action)
wmEventHandler_Dropbox * WM_event_add_dropbox_handler(ListBaseT< wmEventHandler > *handlers, ListBaseT< wmDropBox > *dropboxes)
bool wm_cursor_position_get(wmWindow *win, int *r_x, int *r_y)
VecBase< int32_t, 2 > int2
Scene * WM_window_get_active_scene(const wmWindow *win)
VecBase< float, 2 > float2
bool ED_workspace_delete(WorkSpace *workspace, Main *bmain, bContext *C, wmWindowManager *wm) ATTR_NONNULL()
const char * WM_window_cursor_keymap_status_get(const wmWindow *win, int button_index, int type_index)
bool WM_operator_depends_on_cursor(bContext &C, wmOperatorType &ot, PointerRNA *properties)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void wm_event_add_ghostevent(wmWindowManager *wm, wmWindow *win, const int type, const void *customdata, const uint64_t event_time_ms)
bool WM_event_drag_test(const wmEvent *event, const int prev_xy[2])
void ED_fileselect_params_to_userdef(SpaceFile *sfile)
static void wm_operator_reports(bContext *C, wmOperator *op, const wmOperatorStatus retval, const bool caller_owns_reports)
void WM_cursor_grab_enable(wmWindow *win, const eWM_CursorWrapAxis wrap, const rcti *wrap_region, const bool hide)
static eHandlerActionFlag wm_handlers_do_keymap_with_keymap_handler(bContext *C, wmEvent *event, ListBaseT< wmEventHandler > *handlers, wmEventHandler_Keymap *handler, wmKeyMap *keymap, const bool do_debug_handler)
void wm_surfaces_do_depsgraph(bContext *C)
void WM_tooltip_init(bContext *C, wmWindow *win)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void WM_main_remap_editor_id_reference(const bke::id::IDRemapper &mappings)
wmKeyMapItem * WM_event_match_keymap_item_from_handlers(bContext *C, wmWindowManager *wm, wmWindow *win, ListBaseT< wmEventHandler > *handlers, const wmEvent *event)
void BKE_report(ReportList *reports, eReportType type, const char *message)
@ WM_HANDLER_ACCEPT_DBL_CLICK
BMesh const char void * data
void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink) ATTR_NONNULL(1)
std::string RNA_pointer_as_string_keywords(bContext *C, PointerRNA *ptr, const bool as_function, const bool all_args, const bool nested_args, const int max_prop_length)
static bool event_or_prev_in_rect(const wmEvent *event, const rcti *rect)
void WM_event_remove_keymap_handler(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap)
static void wm_event_timers_execute(bContext *C)
wmEventHandler_Keymap * WM_event_add_keymap_handler_v2d_mask(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap)
void ED_spacedata_id_remap(ScrArea *area, SpaceLink *sl, const bke::id::IDRemapper &mappings)
wmWindowManager * CTX_wm_manager(const bContext *C)
void WM_event_tablet_data_default_set(wmTabletData *tablet_data)
wmOperatorStatus WM_operator_repeat(bContext *C, wmOperator *op)
static void wm_region_tag_draw_on_gizmo_delay_refresh_for_tweak(wmWindow *win)
static void wm_handler_operator_insert(wmWindow *win, wmEventHandler_Op *handler)
BLI_INLINE bool wm_eventmatch(const wmEvent *winevent, const wmKeyMapItem *kmi)
static ARegion * region_event_inside(bContext *C, const int xy[2])
float wm_pressure_curve(float raw_pressure)
void wm_window_close_request(bContext *C, wmWindowManager *wm, wmWindow *win)
static wmEvent * wm_event_add_intern(wmWindow *win, const wmEvent *event_to_add)
void WM_menu_name_call(bContext *C, const char *menu_name, wm::OpCallContext context)
void wm_event_do_depsgraph(bContext *C, bool is_after_open_file)
void ED_area_exit(bContext *C, ScrArea *area)
static void ui_handler_wait_for_input_remove(bContext *C, void *userdata)
void BLI_rcti_translate(struct rcti *rect, int x, int y)
int RNA_property_flag(PropertyRNA *prop)
void WM_window_cursor_keymap_status_free(wmWindow *win)
static void wm_handler_op_context_get_if_valid(bContext *C, wmEventHandler_Op *handler, const wmEvent *event, ScrArea **r_area, ARegion **r_region)
void WM_gizmoconfig_update(Main *bmain)
void WM_window_cursor_keymap_status_refresh(bContext *C, wmWindow *win)
void WM_cursor_modal_restore(wmWindow *win)
static bool wm_event_always_pass(const wmEvent *event)
void BKE_scene_graph_update_tagged(Depsgraph *depsgraph, Main *bmain)
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
bool wm_gizmomap_highlight_set(wmGizmoMap *gzmap, const bContext *C, wmGizmo *gz, int part)
WorkSpace * WM_window_get_active_workspace(const wmWindow *win)
void WM_gizmogroup_ensure_init(const bContext *C, wmGizmoGroup *gzgroup)
static const char * keymap_handler_log_action_str(const eHandlerActionFlag action)
bool WM_operator_last_properties_init(wmOperator *op)
static void wm_region_mouse_co(bContext *C, wmEvent *event)
bContext * WM_xr_session_context_ensure(wmXrData *xr, const wmWindowManager *wm)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
int WM_userdef_event_map(int kmitype)
static eHandlerActionFlag wm_event_drag_and_drop_test(wmWindowManager *wm, wmWindow *win, wmEvent *event)
void WM_global_report(eReportType type, const char *message)
bool WM_event_handler_region_v2d_mask_no_marker_poll(const wmWindow *win, const ScrArea *area, const ARegion *region, const wmEvent *event)
eUserpref_TrackpadScrollDir
@ USER_TRACKPAD_SCROLL_DIR_TRADITIONAL
@ USER_TRACKPAD_SCROLL_DIR_NATURAL
void WM_window_status_area_tag_redraw(wmWindow *win)
void ED_area_status_text(ScrArea *area, const char *str)
const char * CTX_wm_operator_poll_msg_get(bContext *C, bool *r_free)
void ED_area_do_refresh(bContext *C, ScrArea *area)
void WM_event_ui_handler_region_popup_replace(wmWindow *win, const ARegion *old_region, ARegion *new_region)
void WM_event_get_keymap_from_toolsystem_with_gizmos(wmWindowManager *wm, wmWindow *win, wmEventHandler_Keymap *handler, wmEventHandler_KeymapResult *km_result)
bool WM_operator_poll_context(bContext *C, wmOperatorType *ot, wm::OpCallContext context)
wmOperatorStatus WM_operator_name_call(bContext *C, const char *opstring, wm::OpCallContext context, PointerRNA *properties, const wmEvent *event)
static void wm_event_custom_free(wmEvent *event)
const char int BLI_str_utf8_size_or_error(const char *p) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
@ WM_HANDLER_TYPE_DROPBOX
void WM_cursor_grab_disable(wmWindow *win, const int mouse_ungrab_xy[2])
wmEventHandler_Keymap * WM_event_add_keymap_handler(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap)
wmEventHandler_Op * WM_event_add_modal_handler_ex(wmWindow *win, ScrArea *area, ARegion *region, wmOperator *op)
ScrArea * ED_screen_temp_space_open(bContext *C, const char *title, eSpace_Type space_type, int display_type, bool dialog) ATTR_NONNULL(1)
void CTX_wm_region_popup_set(bContext *C, ARegion *region_popup)
static wmOperatorStatus wm_operator_invoke(bContext *C, wmOperatorType *ot, const wmEvent *event, PointerRNA *properties, ReportList *reports, const bool poll_only, bool use_last_properties)
char * IDP_reprN(const IDProperty *prop, uint *r_len)
CLG_LogRef * WM_LOG_OPERATORS
static intptr_t wm_operator_undo_active_id(const wmWindowManager *wm)
void WM_event_fileselect_event(wmWindowManager *wm, void *ophandle, const int eventval)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void WM_operator_region_active_win_set(bContext *C)
wmGizmo * wm_gizmomap_modal_get(wmGizmoMap *gzmap)
bool WM_event_modifier_flag_match_kmi_press(const wmEventModifierFlag event_modifier, const wmKeyMapItem *kmi)
bool WM_event_handler_region_marker_poll(const wmWindow *win, const ScrArea *area, const ARegion *region, const wmEvent *event)
static void wm_event_modalkeymap_end(wmEvent *event, const wmEvent_ModalMapStore *event_backup)
static bool wm_event_is_ignorable_key_press(const wmWindow *win, const wmEvent &event)
@ SCE_WORKSPACE_TOOL_FALLBACK
wm::OpCallContext wm_drop_operator_context_get(const wmDropBox *)
wmEventHandler_Keymap * WM_event_add_keymap_handler_poll(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap, EventHandlerPoll poll)
static eHandlerActionFlag wm_event_do_handlers_area_regions(bContext *C, wmEvent *event, ScrArea *area)
void WM_event_remove_modal_handler(ListBaseT< wmEventHandler > *handlers, const wmOperator *op, const bool postpone)
std::optional< std::string > WM_keymap_item_to_string(const wmKeyMapItem *kmi, const bool compact)
@ WM_GIZMOGROUPTYPE_TOOL_FALLBACK_KEYMAP
@ WM_GIZMOGROUPTYPE_TOOL_INIT
void AS_asset_library_remap_ids(const bke::id::IDRemapper &mappings)
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
@ WM_GIZMO_OPERATOR_TOOL_INIT
@ WM_GIZMO_EVENT_HANDLE_ALL
@ WM_CAPABILITY_TRACKPAD_PHYSICAL_DIRECTION
@ WM_CAPABILITY_WINDOW_POSITION
void wm_gizmomap_handler_context_gizmo(bContext *, wmEventHandler_Gizmo *)
wmEvent * WM_event_add(wmWindow *win, const wmEvent *event_to_add)
void wm_test_foreign_file_warning(bContext *C)
ARegion * BKE_area_find_region_type(const ScrArea *area, int region_type)
PropertySubType RNA_property_subtype(PropertyRNA *prop)
wmOperatorStatus WM_operator_name_call_with_properties(bContext *C, const char *opstring, wm::OpCallContext context, IDProperty *properties, const wmEvent *event)
wmOperatorType * WM_operatortype_find(const char *idname, bool quiet)
void WM_toolsystem_ref_properties_init_for_keymap(bToolRef *tref, PointerRNA *dst_ptr, PointerRNA *src_ptr, wmOperatorType *ot)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void(*)(wmWindowManager *wm, wmWindow *win, wmEventHandler_Keymap *handler, wmEventHandler_KeymapResult *km_result) wmEventHandler_KeymapDynamicFn
void WM_msg_id_remove(wmMsgBus *mbus, const ID *id)
void ED_update_for_newframe(Main *bmain, Depsgraph *depsgraph)
static void wm_operator_finished(bContext *C, wmOperator *op, const bool repeat, const bool store, const bool has_undo_step, const bool has_register)
void ED_fileselect_set_params_from_userdef(SpaceFile *sfile)
static void wm_event_free_last(wmWindow *win)
ARegion * ED_area_find_region_xy_visual(const ScrArea *area, int regiontype, const int event_xy[2])
void WM_event_handling_break(const bContext &C)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
wmOperatorStatus WM_operator_type_call_ptr_with_reports(bContext *C, wmOperatorType *ot, wm::OpCallContext context, PointerRNA *properties, ReportList *reports, const wmEvent *event)
@ USER_TEMP_SPACE_DISPLAY_WINDOW
static void wm_event_modalkeymap_begin(const bContext *C, wmOperator *op, wmEvent *event, wmEvent_ModalMapStore *event_backup)
void ED_screen_full_prevspace(bContext *C, ScrArea *area)
static void wm_event_add_notifier_intern(wmWindowManager *wm, const wmWindow *win, uint type, void *reference)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void ED_info_stats_clear(wmWindowManager *wm, ViewLayer *view_layer)
Main * CTX_data_main(const bContext *C)
void WM_reports_from_reports_move(wmWindowManager *wm, ReportList *reports)
static std::optional< std::string > keymap_handler_log_kmi_event_str(const wmKeyMapItem *kmi)
bToolRef * WM_toolsystem_ref_from_context(const bContext *C)
void WM_event_consecutive_data_free(wmWindow *win)
static bool wm_event_is_double_click(const wmEvent *event, const uint64_t event_time_ms, const uint64_t event_prev_press_time_ms)
void IDP_FreeProperty(IDProperty *prop)
void wm_test_gpu_backend_fallback(bContext *C)
int2 WM_window_native_pixel_size(const wmWindow *win)
void RE_FreeUnusedGPUResources()
eWM_CapabilitiesFlag WM_capabilities_flag()
bScreen * BKE_workspace_layout_screen_get(const WorkSpaceLayout *layout) GETTER_ATTRS
void WM_window_title_refresh(wmWindowManager *wm, wmWindow *win)
void WM_event_remove_ui_handler(ListBaseT< wmEventHandler > *handlers, wmUIHandlerFunc handle_fn, wmUIHandlerRemoveFunc remove_fn, void *user_data, const bool postpone)
wmEventHandler_Keymap * WM_event_add_keymap_handler_priority(ListBaseT< wmEventHandler > *handlers, wmKeyMap *keymap, int)
bool WM_gizmo_group_type_ensure_ptr_ex(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
wmOperatorStatus WM_operator_name_call_ptr(bContext *C, wmOperatorType *ot, wm::OpCallContext context, PointerRNA *properties, const wmEvent *event)
ARegion * CTX_wm_region_popup(const bContext *C)
wmGizmoMapType * WM_gizmomaptype_ensure(const wmGizmoMapType_Params *gzmap_params)
void DEG_graph_relations_update(Depsgraph *graph)
wmOperator * WM_operator_last_redo(const bContext *C)
wmGizmoGroup * WM_gizmomap_group_find(wmGizmoMap *gzmap, const char *idname)
void wm_operator_register(bContext *C, wmOperator *op)
bool WM_operator_repeat_check(const bContext *, wmOperator *op)
void WM_event_remove_handlers_by_area(ListBaseT< wmEventHandler > *handlers, const ScrArea *area)
static void wm_event_state_update_and_click_set(wmEvent *event, uint64_t event_time_ms, wmEvent *event_state, uint64_t *event_state_prev_press_time_ms_p, const GHOST_TEventType type)
static eHandlerActionFlag wm_event_do_region_handlers(bContext *C, wmEvent *event, ARegion *region)
static void wm_event_custom_clear(wmEvent *event)
static wmEventType wm_event_type_from_ghost_key(GHOST_TKey key)
bool ED_screen_change(bContext *C, bScreen *screen)
Change the active screen.
bool BLI_remlink_safe(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
bool WM_event_consecutive_gesture_test_break(const wmWindow *win, const wmEvent *event)
bool WM_operator_is_repeat(const bContext *C, const wmOperator *op)
static bool screen_temp_region_exists(const ARegion *region)
Scene * CTX_data_scene(const bContext *C)
std::optional< bool > wm_drag_asset_path_exists(const wmDrag *drag)
bScreen * CTX_wm_screen(const bContext *C)
void CTX_wm_region_set(bContext *C, ARegion *region)
void CTX_data_main_set(bContext *C, Main *bmain)
void WM_event_modal_handler_region_replace(wmWindow *win, const ARegion *old_region, ARegion *new_region)
bool BLI_rcti_isect_pt_v(const struct rcti *rect, const int xy[2])
void WM_event_timer_remove(wmWindowManager *wm, wmWindow *, wmTimer *timer)
Depsgraph * BKE_scene_ensure_depsgraph(Main *bmain, Scene *scene, ViewLayer *view_layer)
static bool wm_operator_register_check(wmWindowManager *wm, wmOperatorType *ot)
bool WM_operator_ui_poll(wmOperatorType *ot, PointerRNA *ptr)
char char * BLI_vsprintfN(const char *__restrict format, va_list args) ATTR_NONNULL(1) ATTR_MALLOC ATTR_PRINTF_FORMAT(1
void WM_event_get_keymaps_from_handler(wmWindowManager *wm, wmWindow *win, wmEventHandler_Keymap *handler, wmEventHandler_KeymapResult *km_result)
static wmKeyMapItem * wm_eventmatch_modal_keymap_items(const wmKeyMap *keymap, wmOperator *op, const wmEvent *event)
static eHandlerActionFlag wm_handler_fileselect_call(bContext *C, ListBaseT< wmEventHandler > *handlers, wmEventHandler_Op *handler, const wmEvent *event)
void wm_event_do_refresh_wm_and_depsgraph(bContext *C)
void wm_drags_handle_events(bContext *C, const wmEvent *event)
ARegion * WM_gizmomap_tooltip_init(bContext *C, ARegion *region, int *, double *, bool *r_exit_on_event)
wmTimer * WM_event_timer_add(wmWindowManager *wm, wmWindow *win, const wmEventType event_type, const double time_step)
void wm_gizmomaps_handled_modal_update(bContext *C, wmEvent *event, wmEventHandler_Op *handler)
bool WM_event_handler_region_v2d_mask_poll(const wmWindow *, const ScrArea *, const ARegion *region, const wmEvent *event)
wmGizmo * wm_gizmomap_highlight_get(wmGizmoMap *gzmap)
void CTX_store_set(bContext *C, const bContextStore *store)
wmEvent * WM_event_add_simulate(wmWindow *win, const wmEvent *event_to_add)
static intptr_t wm_operator_register_active_id(const wmWindowManager *wm)
ScrArea * ED_fileselect_handler_area_find_any_with_op(const wmWindow *win)
ReportList * CTX_wm_reports(const bContext *C)
std::optional< std::string > WM_modalkeymap_operator_items_to_string(wmOperatorType *ot, const int propvalue, const bool compact)
void WM_event_add_mousemove(wmWindow *win)
static void wm_handler_op_context(bContext *C, wmEventHandler_Op *handler, const wmEvent *event)
ViewLayer * BKE_view_layer_default_render(const Scene *scene)
static void wm_notifier_clear(wmNotifier *note)
bool WM_operator_poll(bContext *C, wmOperatorType *ot)
static void wm_eventemulation(wmEvent *event, bool test_only)
bool WM_operator_last_properties_store(wmOperator *op)
bScreen * WM_window_get_active_screen(const wmWindow *win)
static wmEvent * wm_event_add_mousemove(wmWindow *win, const wmEvent *event)
void ED_view3d_screen_datamask(const Main &bmain, const Scene *scene, ViewLayer *view_layer, const bScreen *screen, CustomData_MeshMasks *r_cddata_masks)
void ED_screen_do_listen(bContext *C, const wmNotifier *note)
bool wm_cursor_arrow_move(wmWindow *win, const wmEvent *event)
void CTX_wm_operator_poll_msg_clear(bContext *C)
void CTX_wm_gizmo_group_set(bContext *C, wmGizmoGroup *gzgroup)
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
ARegion * CTX_wm_region(const bContext *C)
void WM_drag_free_list(ListBaseT< wmDrag > *lb)
void WM_event_get_keymap_from_toolsystem(wmWindowManager *wm, wmWindow *win, wmEventHandler_Keymap *handler, wmEventHandler_KeymapResult *km_result)
void ED_workspace_status_text(bContext *C, const char *str)
static void wm_event_prev_values_set(wmEvent *event, wmEvent *event_state)
bool IDP_EqualsProperties(const IDProperty *prop1, const IDProperty *prop2) ATTR_WARN_UNUSED_RESULT
wmGizmoGroup * WM_gizmomaptype_group_init_runtime_with_region(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt, ARegion *region)
static eHandlerActionFlag wm_handlers_do(bContext *C, wmEvent *event, ListBaseT< wmEventHandler > *handlers)
void DEG_graph_tag_on_visible_update(Depsgraph *depsgraph, bool do_time)
bool WM_gizmomap_is_any_selected(const wmGizmoMap *gzmap)
void BKE_reports_log(ReportList *reports, eReportType level, CLG_LogRef *log)
static int ui_handler_wait_for_input(bContext *C, const wmEvent *event, void *userdata)
wmOperatorStatus WM_operator_repeat_last(bContext *C, wmOperator *op)
bool ED_workspace_layout_delete(WorkSpace *workspace, WorkSpaceLayout *layout_old, bContext *C) ATTR_NONNULL()
static void wm_operator_free_for_fileselect(wmOperator *file_operator)
void CTX_data_scene_set(bContext *C, Scene *scene)
void wm_event_do_handlers(bContext *C)
void wm_event_init_from_window(wmWindow *win, wmEvent *event)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void WM_event_remove_modal_handler_all(const wmOperator *op, const bool postpone)
static eHandlerActionFlag wm_handler_fileselect_do(bContext *C, ListBaseT< wmEventHandler > *handlers, wmEventHandler_Op *handler, int val)
void WM_paint_cursor_tag_redraw(wmWindow *win, ARegion *)
void WM_event_add_fileselect(bContext *C, wmOperator *op)
bool WM_window_is_temp_screen(const wmWindow *win)
@ AREA_FLAG_ACTIONZONES_UPDATE
void wm_event_free_handler(wmEventHandler *handler)
void ED_area_tag_redraw(ScrArea *area)
static wmOperatorStatus wm_operator_call_internal(bContext *C, wmOperatorType *ot, PointerRNA *properties, ReportList *reports, const wm::OpCallContext context, const bool poll_only, const wmEvent *event)
void wm_event_handler_ui_cancel_ex(bContext *C, wmWindow *win, ARegion *region, bool reactivate_button)
void ED_area_do_listen(wmSpaceTypeListenerParams *params)
void CTX_wm_area_set(bContext *C, ScrArea *area)
ARegion * BKE_area_find_region_xy(const ScrArea *area, int regiontype, const int xy[2]) ATTR_NONNULL(3)
void WM_operator_name_call_ptr_with_depends_on_cursor(bContext *C, wmOperatorType *ot, wm::OpCallContext opcontext, PointerRNA *properties, const wmEvent *event, const StringRef drawstr)
GHOST_TTrackpadEventSubTypes subtype
GHOST_TEventWheelAxis axis
bool clip_gizmo_events_by_ui
bke::ARegionRuntime * runtime
eRegion_Alignment alignment
CursorKeymapInfo_State state
ListBaseT< wmWindowManager > wm
ListBaseT< bScreen > screens
struct CustomData_MeshMasks customdata_mask
struct CustomData_MeshMasks customdata_mask_modal
struct ToolSettings * toolsettings
ListBaseT< ScrArea > areabase
ListBaseT< struct wmEventHandler > handlers
ListBaseT< ARegion > regionbase
ListBaseT< SpaceLink > spacedata
struct Scene * sequencer_scene
struct ARegion * active_region
ListBaseT< struct ScrArea > areabase
ListBaseT< ARegion > regionbase
struct wmTooltipState * tool_tip
ListBaseT< wmEventHandler > handlers
struct ARegionType * type
bool break_events_handling
ListBaseT< wmEventHandler > handlers
ListBaseT< wmEvent > event_queue
bool ime_data_is_composing
uint64_t eventstate_prev_press_time_ms
ListBaseT< wmEventHandler > modalhandlers
void * cursor_keymap_status
wmEvent * event_last_handled
bool operator()(const wmNotifier *a, const wmNotifier *b) const
uint64_t operator()(const wmNotifier *note) const
void label(StringRef name, int icon)
bool(*) poll(bContext *C, wmDrag *drag, const wmEvent *event)
void(*) cancel(Main *bmain, wmDrag *drag, wmDropBox *drop)
ListBaseT< wmDropBox > * dropboxes
struct wmGizmoMap * gizmo_map
wmEventHandler_KeymapDynamicFn keymap_fn
void(*) post_fn(wmKeyMap *keymap, wmKeyMapItem *kmi, void *user_data)
wmEventHandler_KeymapDynamic dynamic
wmEventHandler_KeymapPost post
struct blender::wmEventHandler_Op::@170112141227310273104305047374063031143165303304 context
bool is_fileselect_keep_popup
wmUIHandlerRemoveFunc remove_fn
wmUIHandlerFunc handle_fn
struct blender::wmEventHandler_UI::@165375040344237356134256072003335247104031320105 context
eWM_EventHandlerFlag flag
eWM_EventHandlerType type
wmEventType prev_press_type
wmEventModifierFlag prev_press_modifier
wmEventType prev_press_keymodifier
wmEventModifierFlag modifier
wmGizmoMapType_Params gzmap_params
eWM_GizmoFlagGroupTypeFlag flag
wmGizmoGroup * parent_gzgroup
bool(*) poll_modal_item(const struct wmOperator *op, int value)
ListBaseT< wmKeyMapItem > items
wm::OpCallContext opcontext
struct wmOperatorTypeMacro * next
struct IDProperty * properties
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
bool(*) check(bContext *C, wmOperator *op)
void(*) cancel(bContext *C, wmOperator *op)
ListBaseT< wmOperatorTypeMacro > macro
const char * translation_context
bool(*) pyop_poll(bContext *C, wmOperatorType *ot) ATTR_WARN_UNUSED_RESULT
bool(*) ui_poll(wmOperatorType *ot, PointerRNA *ptr)
void(*) ui(bContext *C, wmOperator *op)
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
ListBaseT< wmOperator > macro
struct ReportList * reports
struct wmOperatorType * type
const wmNotifier * notifier
const wmNotifier * notifier
bke::WindowManagerRuntime * runtime
bke::WindowRuntime * runtime
char event_queue_check_drag
struct wmEvent_ConsecutiveData * event_queue_consecutive_gesture_data
short event_queue_consecutive_gesture_type
DNA_DEPRECATED struct bScreen * screen
short pie_event_type_lock
char event_queue_check_drag_handled
int event_queue_consecutive_gesture_xy[2]
char event_queue_check_click
#define CASE_BUTTON(ghost_button, type)
#define WM_HANDLER_CONTINUE
#define ISMOUSE_BUTTON(event_type)
#define ISKEYBOARD_OR_BUTTON(event_type)
#define ISMOUSE_MOTION(event_type)
#define ISMOUSE_WHEEL(event_type)
#define ISKEYMODIFIER(event_type)
#define ISTIMER(event_type)
#define ISMOUSE_GESTURE(event_type)
#define ISKEYBOARD(event_type)
#define IS_EVENT_IME_ANY(event_type)
#define ISMOUSE(event_type)