Blender V5.3
wm_gizmo_group.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2014 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
13
14#include <cstdlib>
15#include <cstring>
16
17#include "MEM_guardedalloc.h"
18
19#include "BLI_listbase.hh"
20#include "BLI_rect.hh"
21#include "BLI_string.hh"
22#include "BLI_vector.hh"
23
24#include "BKE_context.hh"
25#include "BKE_main.hh"
26#include "BKE_screen.hh"
27#include "BKE_workspace.hh"
28
29#include "RNA_access.hh"
30
31#include "WM_api.hh"
32#include "WM_keymap.hh"
33#include "WM_types.hh"
34#include "wm_event_system.hh"
35
36#include "ED_screen.hh"
37#include "ED_undo.hh"
38
39/* Own includes. */
40#include "wm_gizmo_intern.hh"
41#include "wm_gizmo_wmapi.hh"
42
43#ifdef WITH_PYTHON
44# include "BPY_extern.hh"
45#endif
46
47namespace blender {
48
49/* -------------------------------------------------------------------- */
52
54{
55 wmGizmoGroup *gzgroup = MEM_new_zeroed<wmGizmoGroup>("gizmo-group");
56
57 gzgroup->type = gzgt;
58 gzgroup->type->users += 1;
59
60 /* Keep back-link. */
61 gzgroup->parent_gzmap = gzmap;
62
63 BLI_addtail(&gzmap->groups, gzgroup);
64
65 return gzgroup;
66}
67
69{
70 return static_cast<wmGizmoGroup *>(
71 BLI_findptr(&gzmap->groups, gzgt, offsetof(wmGizmoGroup, type)));
72}
73
75{
76 wmGizmoMap *gzmap = gzgroup->parent_gzmap;
77
78 /* Similar to WM_gizmo_unlink, but only to keep gzmap state correct,
79 * we don't want to run callbacks. */
80 if (gzmap->gzmap_context.highlight && gzmap->gzmap_context.highlight->parent_gzgroup == gzgroup)
81 {
82 wm_gizmomap_highlight_set(gzmap, C, nullptr, 0);
83 }
84 if (gzmap->gzmap_context.modal && gzmap->gzmap_context.modal->parent_gzgroup == gzgroup) {
85 wm_gizmomap_modal_set(gzmap, C, gzmap->gzmap_context.modal, nullptr, false);
86 }
87
88 for (wmGizmo *gz = gzgroup->gizmos.first(), *gz_next; gz; gz = gz_next) {
89 gz_next = gz->next;
90 if (gzmap->gzmap_context.select.len) {
91 WM_gizmo_select_unlink(gzmap, gz);
92 }
93 WM_gizmo_free(gz);
94 }
95 gzgroup->gizmos.clear_no_delete();
96
97#ifdef WITH_PYTHON
98 if (gzgroup->py_instance) {
99 /* Do this first in case there are any `__del__` functions or
100 * similar that use properties. */
102 }
103#endif
104
105 if (gzgroup->customdata_free) {
106 gzgroup->customdata_free(gzgroup->customdata);
107 }
108 else {
109 MEM_SAFE_DELETE_VOID(gzgroup->customdata);
110 }
111
112 BLI_remlink(&gzmap->groups, gzgroup);
113
114 if (gzgroup->tag_remove == false) {
115 gzgroup->type->users -= 1;
116 }
117
118 MEM_delete(gzgroup);
119}
120
122{
123 if (gzgroup->tag_remove == false) {
124 gzgroup->tag_remove = true;
125 gzgroup->type->users -= 1;
126 BLI_assert(gzgroup->type->users >= 0);
128 }
129}
130
132{
133 BLI_assert(BLI_findindex(&gzgroup->gizmos, gz) == -1);
134 BLI_addtail(&gzgroup->gizmos, gz);
135 gz->parent_gzgroup = gzgroup;
136}
137
138int WM_gizmo_cmp_temp_fl(const void *gz_a_ptr, const void *gz_b_ptr)
139{
140 const wmGizmo *gz_a = static_cast<const wmGizmo *>(gz_a_ptr);
141 const wmGizmo *gz_b = static_cast<const wmGizmo *>(gz_b_ptr);
142 if (gz_a->temp.f < gz_b->temp.f) {
143 return -1;
144 }
145 if (gz_a->temp.f > gz_b->temp.f) {
146 return 1;
147 }
148 return 0;
149}
150
151int WM_gizmo_cmp_temp_fl_reverse(const void *gz_a_ptr, const void *gz_b_ptr)
152{
153 const wmGizmo *gz_a = static_cast<const wmGizmo *>(gz_a_ptr);
154 const wmGizmo *gz_b = static_cast<const wmGizmo *>(gz_b_ptr);
155 if (gz_a->temp.f < gz_b->temp.f) {
156 return 1;
157 }
158 if (gz_a->temp.f > gz_b->temp.f) {
159 return -1;
160 }
161 return 0;
162}
163
165 const wmGizmoGroup *gzgroup,
166 const wmGizmo *gz,
167 const int event_modifier,
168 int *r_gzgroup_keymap_uses_modifier)
169{
170 if (gz->keymap) {
171 wmKeyMap *keymap = WM_keymap_active(wm, gz->keymap);
172 if (!WM_keymap_uses_event_modifier(keymap, event_modifier)) {
173 return false;
174 }
175 }
176 else if (gzgroup->type->keymap) {
177 if (*r_gzgroup_keymap_uses_modifier == -1) {
178 wmKeyMap *keymap = WM_keymap_active(wm, gzgroup->type->keymap);
179 *r_gzgroup_keymap_uses_modifier = WM_keymap_uses_event_modifier(keymap, event_modifier);
180 }
181 if (*r_gzgroup_keymap_uses_modifier == 0) {
182 return false;
183 }
184 }
185 return true;
186}
187
189 const wmGizmoGroup *gzgroup,
190 bContext *C,
191 const int event_modifier,
192 const int mval[2],
193 int *r_part)
194{
195 int gzgroup_keymap_uses_modifier = -1;
196
197 for (wmGizmo &gz : gzgroup->gizmos) {
198 if (gz.type->test_select && (gz.flag & (WM_GIZMO_HIDDEN | WM_GIZMO_HIDDEN_SELECT)) == 0) {
199
201 wm, gzgroup, &gz, event_modifier, &gzgroup_keymap_uses_modifier))
202 {
203 continue;
204 }
205
206 if ((*r_part = gz.type->test_select(C, &gz, mval)) != -1) {
207 return &gz;
208 }
209 }
210 }
211
212 return nullptr;
213}
214
216 wmGizmoGroup *gzgroup,
217 const int event_modifier,
218 Vector<wmGizmo *, 128> *r_visible_gizmos)
219{
220 int gzgroup_keymap_uses_modifier = -1;
221 for (wmGizmo &gz : gzgroup->gizmos.items_reversed()) {
222 if ((gz.flag & (WM_GIZMO_HIDDEN | WM_GIZMO_HIDDEN_SELECT)) == 0) {
223 if (((gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D) &&
224 (gz.type->draw_select || gz.type->test_select)) ||
225 ((gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D) == 0 && gz.type->test_select))
226 {
227
229 wm, gzgroup, &gz, event_modifier, &gzgroup_keymap_uses_modifier))
230 {
231 continue;
232 }
233
234 r_visible_gizmos->append(&gz);
235 }
236 }
237 }
238}
239
241{
242 /* Prepare for first draw. */
243 if ((gzgroup->init_flag & WM_GIZMOGROUP_INIT_SETUP) == 0) [[unlikely]] {
244
245 gzgroup->type->setup(C, gzgroup);
246
247 /* Not ideal, initialize keymap here, needed for RNA runtime generated gizmos. */
248 wmGizmoGroupType *gzgt = gzgroup->type;
249 if (gzgt->keymap == nullptr) {
251 wm_gizmogrouptype_setup_keymap(gzgt, wm->runtime->defaultconf);
252 BLI_assert(gzgt->keymap != nullptr);
253 }
255 }
256
257 /* Refresh may be called multiple times,
258 * this just ensures its called at least once before we draw. */
259 if ((gzgroup->init_flag & WM_GIZMOGROUP_INIT_REFRESH) == 0) [[unlikely]] {
260 /* Clear the flag before calling refresh so the callback
261 * can postpone the refresh by clearing this flag. */
263 WM_gizmo_group_refresh(C, gzgroup);
264 }
265}
266
268 Main *bmain,
269 const wmGizmoGroupType *gzgt,
270 const bToolRef *tref)
271{
273 for (bScreen *screen = bmain->screens.first(); screen;
274 screen = static_cast<bScreen *>(screen->id.next))
275 {
276 for (ScrArea &area : screen->areabase) {
277 if (area.runtime.tool == tref) {
278 for (ARegion &region : area.regionbase) {
279 wmGizmoMap *gzmap = region.runtime->gizmo_map;
280 if (gzmap && gzmap->type == gzmap_type) {
281 wmGizmoGroup *gzgroup, *gzgroup_next;
282 for (gzgroup = gzmap->groups.first(); gzgroup; gzgroup = gzgroup_next) {
283 gzgroup_next = gzgroup->next;
284 if (gzgroup->type == gzgt) {
285 BLI_assert(gzgroup->parent_gzmap == gzmap);
286 wm_gizmogroup_free(C, gzgroup);
288 }
289 }
290 }
291 }
292 }
293 }
294 }
295}
296
298 const eWM_GizmoFlagMapDrawStep drawstep)
299{
300 switch (drawstep) {
302 return (gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D) == 0;
304 return (gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D);
305 default:
307 return false;
308 }
309}
310
312{
313 if (gzgroup->type->flag & WM_GIZMOGROUPTYPE_SELECT) {
314 for (const wmGizmo &gz : gzgroup->gizmos) {
315 if (gz.state & WM_GIZMO_STATE_SELECT) {
316 return true;
317 }
318 }
319 }
320 return false;
321}
322
324
325/* -------------------------------------------------------------------- */
330
332{
333 ARegion *region = CTX_wm_region(C);
334 wmGizmoMap *gzmap = region->runtime->gizmo_map;
335 wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select;
336 wmGizmo *highlight = gzmap->gzmap_context.highlight;
337
338 bool extend = RNA_boolean_get(op->ptr, "extend");
339 bool deselect = RNA_boolean_get(op->ptr, "deselect");
340 bool toggle = RNA_boolean_get(op->ptr, "toggle");
341
342 /* Deselect all first. */
343 if (extend == false && deselect == false && toggle == false) {
345 BLI_assert(msel->items == nullptr && msel->len == 0);
346 UNUSED_VARS_NDEBUG(msel);
347 }
348
349 if (highlight) {
350 const bool is_selected = (highlight->state & WM_GIZMO_STATE_SELECT);
351 bool redraw = false;
352
353 if (toggle) {
354 /* Toggle: deselect if already selected, else select. */
355 deselect = is_selected;
356 }
357
358 if (deselect) {
359 if (is_selected && WM_gizmo_select_set(gzmap, highlight, false)) {
360 redraw = true;
361 }
362 }
363 else if (wm_gizmo_select_and_highlight(C, gzmap, highlight)) {
364 redraw = true;
365 }
366
367 if (redraw) {
369 }
370
371 return OPERATOR_FINISHED;
372 }
373
376}
377
379{
380 /* Identifiers. */
381 ot->name = "Gizmo Select";
382 ot->description = "Select the currently highlighted gizmo";
383 ot->idname = "GIZMOGROUP_OT_gizmo_select";
384
385 /* API callbacks. */
388
389 ot->flag = OPTYPE_UNDO;
390
392}
393
398
399 int init_event; /* Initial event type. */
400 int flag; /* Tweak flags. */
401};
402
403static bool gizmo_tweak_start(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event)
404{
405 /* Activate highlighted gizmo. */
406 wm_gizmomap_modal_set(gzmap, C, gz, event, true);
407
408 return (gz->state & WM_GIZMO_STATE_MODAL);
409}
410
412 bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event, bool *r_is_modal)
413{
415 if (r_is_modal) {
416 *r_is_modal = false;
417 }
418 if (gzop && gzop->type) {
419
420 /* Undo/Redo. */
421 if (gzop->is_redo) {
424
425/* We may want to enable this, for now the gizmo can manage its own properties. */
426#if 0
427 IDP_MergeGroup(gzop->ptr.data, op->properties, false);
428#endif
429
431 ED_undo_pop_op(C, op);
432 }
433
434 /* XXX temporary workaround for modal gizmo operator
435 * conflicting with modal operator attached to gizmo. */
436 if (gzop->type->modal) {
437 /* Activate highlighted gizmo. */
438 wm_gizmomap_modal_set(gzmap, C, gz, event, true);
439 if (r_is_modal) {
440 *r_is_modal = true;
441 }
442 }
443 else {
445 gz->parent_gzgroup->type->invoke_prepare(C, gz->parent_gzgroup, gz, event);
446 }
447 /* Allow for 'button' gizmos, single click to run an action. */
448 WM_gizmo_operator_invoke(C, gz, gzop, event);
449 }
450 return true;
451 }
452 return false;
453}
454
455static void gizmo_tweak_finish(bContext *C, wmOperator *op, const bool cancel, bool clear_modal)
456{
457 GizmoTweakData *mtweak = static_cast<GizmoTweakData *>(op->customdata);
458 if (mtweak->gz_modal->type->exit) {
459 mtweak->gz_modal->type->exit(C, mtweak->gz_modal, cancel);
460 }
461 if (clear_modal) {
462 /* The gizmo may have been removed. */
463 if ((BLI_findindex(&mtweak->gzmap->groups, mtweak->gzgroup) != -1) &&
464 (BLI_findindex(&mtweak->gzgroup->gizmos, mtweak->gz_modal) != -1))
465 {
466 wm_gizmomap_modal_set(mtweak->gzmap, C, mtweak->gz_modal, nullptr, false);
467 }
468 }
469 if (cancel == false) {
470 if (mtweak->gz_modal->flag & WM_GIZMO_NEEDS_UNDO) {
472 }
473 }
474 MEM_delete(mtweak);
475}
476
478{
479 GizmoTweakData *mtweak = static_cast<GizmoTweakData *>(op->customdata);
480 wmGizmo *gz = mtweak->gz_modal;
482 bool clear_modal = true;
483
484 if (gz == nullptr) {
487 }
488
489 if (retval == OPERATOR_FINISHED) {
490 /* Pass. */
491 }
492 else if (event->type == mtweak->init_event && event->val == KM_RELEASE) {
493 retval = OPERATOR_FINISHED;
494 }
495 else if (event->type == EVT_MODAL_MAP) {
496 switch (event->val) {
498 retval = OPERATOR_CANCELLED;
499 break;
501 retval = OPERATOR_FINISHED;
502 break;
504 mtweak->flag |= WM_GIZMO_TWEAK_PRECISE;
505 break;
507 mtweak->flag &= ~WM_GIZMO_TWEAK_PRECISE;
508 break;
509
511 mtweak->flag |= WM_GIZMO_TWEAK_SNAP;
512 break;
514 mtweak->flag &= ~WM_GIZMO_TWEAK_SNAP;
515 break;
516 }
517 }
518
519 if (retval != OPERATOR_PASS_THROUGH) {
520 gizmo_tweak_finish(C, op, retval != OPERATOR_FINISHED, clear_modal);
521 return retval;
522 }
523
524 /* Handle gizmo. */
525 wmGizmoFnModal modal_fn = gz->custom_modal ? gz->custom_modal : gz->type->modal;
526 if (modal_fn) {
527 /* Ugly hack to ensure Python won't get 'EVT_MODAL_MAP' which isn't supported, see #73727.
528 * note that we could move away from wrapping modal gizmos in a modal operator,
529 * since it's causing the need for code like this. */
530 wmEvent *evil_event = const_cast<wmEvent *>(event);
531 short event_modal_val = 0;
532
533 if (event->type == EVT_MODAL_MAP) {
534 event_modal_val = evil_event->val;
535 evil_event->type = evil_event->prev_type;
536 evil_event->val = evil_event->prev_val;
537 }
538
539 const wmOperatorStatus modal_retval = modal_fn(C, gz, event, eWM_GizmoFlagTweak(mtweak->flag));
540 OPERATOR_RETVAL_CHECK(modal_retval);
541
542 if (event_modal_val != 0) {
543 evil_event->type = EVT_MODAL_MAP;
544 evil_event->val = event_modal_val;
545 }
546
547 if ((modal_retval & OPERATOR_RUNNING_MODAL) == 0) {
548 gizmo_tweak_finish(C, op, (modal_retval & OPERATOR_CANCELLED) != 0, true);
549 return OPERATOR_FINISHED;
550 }
551
552 /* Ugly hack to send gizmo events. */
553 evil_event->type = EVT_GIZMO_UPDATE;
554 }
555
556 /* Always return PASS_THROUGH so modal handlers
557 * with gizmos attached can update. */
560}
561
563{
564 ARegion *region = CTX_wm_region(C);
565 wmGizmoMap *gzmap = region->runtime->gizmo_map;
566 wmGizmo *gz = gzmap->gzmap_context.highlight;
567
568 /* Needed for single click actions which don't enter modal state. */
570
571 if (!gz) {
572 /* #wm_handlers_do_intern shouldn't let this happen. */
573 BLI_assert_msg(false, "the gizmo should never be null, this is a bug!");
575 }
576
578 /* The event-system should prevent this from happening, see: #137146.
579 * May be caused by the context changing without tagging #wmGizmoMap::tag_highlight_pending,
580 * typically via #WM_gizmomap_tag_refresh. */
581 BLI_assert_msg(false, "the gizmo-group's poll should always succeed, this is a bug!");
583 }
584
585 const int highlight_part_init = gz->highlight_part;
586
587 if (gz->drag_part != -1) {
588 if (WM_event_is_mouse_drag(event)) {
589 gz->highlight_part = gz->drag_part;
590 }
591 }
592
593 if (gizmo_tweak_start_and_finish(C, gzmap, gz, event, nullptr)) {
594 return OPERATOR_FINISHED;
595 }
596
597 if (!gizmo_tweak_start(C, gzmap, gz, event)) {
598 /* Failed to start. */
599 gz->highlight_part = highlight_part_init;
601 }
602
604
606 mtweak->gz_modal = gzmap->gzmap_context.highlight;
607 mtweak->gzgroup = mtweak->gz_modal->parent_gzgroup;
608 mtweak->gzmap = gzmap;
609 mtweak->flag = 0;
610
611 op->customdata = mtweak;
613 for (const wmKeyMapItem &kmi : keymap->items) {
614 if (kmi.flag & KMI_INACTIVE) {
615 continue;
616 }
617
618 if (kmi.propvalue == TWEAK_MODAL_SNAP_ON &&
620 {
621 mtweak->flag |= WM_GIZMO_TWEAK_SNAP;
622 }
623 else if (kmi.propvalue == TWEAK_MODAL_PRECISION_ON &&
625 {
626 mtweak->flag |= WM_GIZMO_TWEAK_PRECISE;
627 }
628 }
629
631
633}
634
636{
637 /* Identifiers. */
638 ot->name = "Gizmo Tweak";
639 ot->description = "Tweak the active gizmo";
640 ot->idname = "GIZMOGROUP_OT_gizmo_tweak";
641
642 /* API callbacks. */
646
647/* TODO(@ideasman42): This causes problems tweaking settings for operators,
648 * need to find a way to support this. May want to use #WM_GIZMO_NEEDS_UNDO instead. */
649#if 0
650 ot->flag = OPTYPE_UNDO;
651#endif
653}
654
656{
657 wmKeyMap *keymap;
658 char name[KMAP_MAX_NAME];
659
660 static const EnumPropertyItem modal_items[] = {
661 {TWEAK_MODAL_CANCEL, "CANCEL", 0, "Cancel", ""},
662 {TWEAK_MODAL_CONFIRM, "CONFIRM", 0, "Confirm", ""},
663 {TWEAK_MODAL_PRECISION_ON, "PRECISION_ON", 0, "Enable Precision", ""},
664 {TWEAK_MODAL_PRECISION_OFF, "PRECISION_OFF", 0, "Disable Precision", ""},
665 {TWEAK_MODAL_SNAP_ON, "SNAP_ON", 0, "Enable Snap", ""},
666 {TWEAK_MODAL_SNAP_OFF, "SNAP_OFF", 0, "Disable Snap", ""},
667 {0, nullptr, 0, nullptr, nullptr},
668 };
669
670 STRNCPY(name, "Generic Gizmo Tweak Modal Map");
671 keymap = WM_modalkeymap_find(keyconf, name);
672
673 /* This function is called for each space-type, only needs to add map once. */
674 if (keymap && keymap->modal_items) {
675 return nullptr;
676 }
677
678 keymap = WM_modalkeymap_ensure(keyconf, name, modal_items);
679
680 /* Items for modal map. */
681 {
682 KeyMapItem_Params params{};
683 params.type = EVT_ESCKEY;
684 params.value = KM_PRESS;
685 params.modifier = KM_ANY;
686 params.direction = KM_ANY;
688 }
689 {
690 KeyMapItem_Params params{};
691 params.type = RIGHTMOUSE;
692 params.value = KM_PRESS;
693 params.modifier = KM_ANY;
694 params.direction = KM_ANY;
696 }
697 {
698 KeyMapItem_Params params{};
699 params.type = EVT_RETKEY;
700 params.value = KM_PRESS;
701 params.modifier = KM_ANY;
702 params.direction = KM_ANY;
704 }
705 {
706 KeyMapItem_Params params{};
707 params.type = EVT_PADENTER;
708 params.value = KM_PRESS;
709 params.modifier = KM_ANY;
710 params.direction = KM_ANY;
712 }
713 {
714 KeyMapItem_Params params{};
715 params.type = EVT_RIGHTSHIFTKEY;
716 params.value = KM_PRESS;
717 params.modifier = KM_ANY;
718 params.direction = KM_ANY;
720 }
721 {
722 KeyMapItem_Params params{};
723 params.type = EVT_RIGHTSHIFTKEY;
724 params.value = KM_RELEASE;
725 params.modifier = KM_ANY;
726 params.direction = KM_ANY;
728 }
729 {
730 KeyMapItem_Params params{};
731 params.type = EVT_LEFTSHIFTKEY;
732 params.value = KM_PRESS;
733 params.modifier = KM_ANY;
734 params.direction = KM_ANY;
736 }
737 {
738 KeyMapItem_Params params{};
739 params.type = EVT_LEFTSHIFTKEY;
740 params.value = KM_RELEASE;
741 params.modifier = KM_ANY;
742 params.direction = KM_ANY;
744 }
745 {
746 KeyMapItem_Params params{};
747 params.type = EVT_RIGHTCTRLKEY;
748 params.value = KM_PRESS;
749 params.modifier = KM_ANY;
750 params.direction = KM_ANY;
752 }
753 {
754 KeyMapItem_Params params{};
755 params.type = EVT_RIGHTCTRLKEY;
756 params.value = KM_RELEASE;
757 params.modifier = KM_ANY;
758 params.direction = KM_ANY;
760 }
761 {
762 KeyMapItem_Params params{};
763 params.type = EVT_LEFTCTRLKEY;
764 params.value = KM_PRESS;
765 params.modifier = KM_ANY;
766 params.direction = KM_ANY;
768 }
769 {
770 KeyMapItem_Params params{};
771 params.type = EVT_LEFTCTRLKEY;
772 params.value = KM_RELEASE;
773 params.modifier = KM_ANY;
774 params.direction = KM_ANY;
776 }
777
778 WM_modalkeymap_assign(keymap, "GIZMOGROUP_OT_gizmo_tweak");
779
780 return keymap;
781}
782 /* #wmGizmoGroup. */
784
785/* -------------------------------------------------------------------- */
788
793
799
805
815 const char *name,
816 const wmGizmoMapType_Params *params)
817{
818 /* Use area and region id since we might have multiple gizmos
819 * with the same name in different areas/regions. */
820 wmKeyMap *km = WM_keymap_ensure(kc, name, params->spaceid, params->regionid);
821 const bool do_init = km->items.is_empty();
822
823/* FIXME(@ideasman42): Currently hard coded. */
824#if 0
825 const int select_mouse = (U.flag & USER_LMOUSESELECT) ? LEFTMOUSE : RIGHTMOUSE;
826 const int select_tweak = (U.flag & USER_LMOUSESELECT) ? EVT_TWEAK_L : EVT_TWEAK_R;
827 const int action_mouse = (U.flag & USER_LMOUSESELECT) ? RIGHTMOUSE : LEFTMOUSE;
828#else
829 const int select_mouse = RIGHTMOUSE, select_mouse_val = KM_PRESS;
830 const int select_tweak = RIGHTMOUSE, select_tweak_val = KM_PRESS_DRAG;
831 const int action_mouse = LEFTMOUSE, action_mouse_val = KM_PRESS;
832#endif
833
834 if (do_init) {
835 {
836 KeyMapItem_Params params{};
837 params.type = action_mouse;
838 params.value = action_mouse_val;
839 params.modifier = KM_ANY;
840 params.direction = KM_ANY;
841 WM_keymap_add_item(km, "GIZMOGROUP_OT_gizmo_tweak", &params);
842 }
843 {
844 KeyMapItem_Params params{};
845 params.type = select_tweak;
846 params.value = select_tweak_val;
847 params.modifier = 0;
848 params.direction = KM_ANY;
849 WM_keymap_add_item(km, "GIZMOGROUP_OT_gizmo_tweak", &params);
850 }
851 }
852
853 if (do_init) {
854 {
855 KeyMapItem_Params params{};
856 params.type = select_mouse;
857 params.value = select_mouse_val;
858 params.modifier = 0;
859 params.direction = KM_ANY;
860 wmKeyMapItem *kmi = WM_keymap_add_item(km, "GIZMOGROUP_OT_gizmo_select", &params);
861 RNA_boolean_set(kmi->ptr, "extend", false);
862 RNA_boolean_set(kmi->ptr, "deselect", false);
863 RNA_boolean_set(kmi->ptr, "toggle", false);
864 }
865 {
866 KeyMapItem_Params params{};
867 params.type = select_mouse;
868 params.value = select_mouse_val;
869 params.modifier = KM_SHIFT;
870 params.direction = KM_ANY;
871 wmKeyMapItem *kmi = WM_keymap_add_item(km, "GIZMOGROUP_OT_gizmo_select", &params);
872 RNA_boolean_set(kmi->ptr, "extend", false);
873 RNA_boolean_set(kmi->ptr, "deselect", false);
874 RNA_boolean_set(kmi->ptr, "toggle", true);
875 }
876 }
877
878 return km;
879}
880
882 wmKeyConfig *kc)
883{
884 wmGizmoMapType_Params params{};
885 params.spaceid = SPACE_EMPTY;
886 params.regionid = RGN_TYPE_WINDOW;
887 return WM_gizmogroup_keymap_template_select_ex(kc, "Generic Gizmo Select", &params);
888}
889
891
892/* -------------------------------------------------------------------- */
897
899{
900 const char *idname = "Generic Gizmo";
901 return WM_keymap_ensure(kc, idname, SPACE_EMPTY, RGN_TYPE_WINDOW);
902}
907
909{
910 const char *idname = "Generic Gizmo Select";
911 return WM_keymap_ensure(kc, idname, SPACE_EMPTY, RGN_TYPE_WINDOW);
912}
917
919{
920 const char *idname = "Generic Gizmo Drag";
921 return WM_keymap_ensure(kc, idname, SPACE_EMPTY, RGN_TYPE_WINDOW);
922}
927
929{
930 const char *idname = "Generic Gizmo Click Drag";
931 return WM_keymap_ensure(kc, idname, SPACE_EMPTY, RGN_TYPE_WINDOW);
932}
937
939{
940 const char *idname = "Generic Gizmo Maybe Drag";
941 return WM_keymap_ensure(kc, idname, SPACE_EMPTY, RGN_TYPE_WINDOW);
942}
947
949
950/* -------------------------------------------------------------------- */
953
955 const wmGizmoGroupType *gzgt)
956{
957 /* Could use hash lookups as operator types do, for now simple search. */
958 for (wmGizmoGroupTypeRef &gzgt_ref : gzmap_type->grouptype_refs) {
959 if (gzgt_ref.type == gzgt) {
960 return &gzgt_ref;
961 }
962 }
963 return nullptr;
964}
965
967{
968 /* Could use hash lookups as operator types do, for now simple search. */
969 for (wmGizmoGroupTypeRef &gzgt_ref : gzmap_type->grouptype_refs) {
970 if (idname == gzgt_ref.type->idname) {
971 return &gzgt_ref;
972 }
973 }
974 return nullptr;
975}
976
978{
979 wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
980 BLI_assert(gzgt != nullptr);
981 return WM_gizmomaptype_group_link_ptr(gzmap_type, gzgt);
982}
983
985 wmGizmoGroupType *gzgt)
986{
987 wmGizmoGroupTypeRef *gzgt_ref = MEM_new_zeroed<wmGizmoGroupTypeRef>("gizmo-group-ref");
988 gzgt_ref->type = gzgt;
989 BLI_addtail(&gzmap_type->grouptype_refs, gzgt_ref);
990 return gzgt_ref;
991}
992
994{
995 /* Initialize key-map.
996 * On startup there's an extra call to initialize keymaps for 'permanent' gizmo-groups. */
997 wm_gizmogrouptype_setup_keymap(gzgt, (bmain->wm.first())->runtime->defaultconf);
998}
999
1001 wmGizmoMapType *gzmap_type,
1002 wmGizmoGroupType *gzgt)
1003{
1004 /* Tools add themselves. */
1005 if (gzgt->flag & WM_GIZMOGROUPTYPE_TOOL_INIT) {
1006 return;
1007 }
1008
1009 /* Now create a gizmo for all existing areas. */
1010 for (bScreen *screen = bmain->screens.first(); screen;
1011 screen = static_cast<bScreen *>(screen->id.next))
1012 {
1013 for (ScrArea &area : screen->areabase) {
1014 for (SpaceLink &sl : area.spacedata) {
1015 ListBaseT<ARegion> *lb = (&sl == area.spacedata.first_) ? &area.regionbase :
1016 &sl.regionbase;
1017 for (ARegion &region : *lb) {
1018 wmGizmoMap *gzmap = region.runtime->gizmo_map;
1019 if (gzmap && gzmap->type == gzmap_type) {
1020 WM_gizmomaptype_group_init_runtime_with_region(gzmap_type, gzgt, &region);
1021 }
1022 }
1023 }
1024 }
1025 }
1026}
1027
1029 wmGizmoGroupType *gzgt,
1030 ARegion *region)
1031{
1032 wmGizmoMap *gzmap = region->runtime->gizmo_map;
1033 BLI_assert(gzmap && gzmap->type == gzmap_type);
1034 UNUSED_VARS_NDEBUG(gzmap_type);
1035
1036 wmGizmoGroup *gzgroup = wm_gizmogroup_new_from_type(gzmap, gzgt);
1037
1038 /* Don't allow duplicates when switching modes for example. See: #66229. */
1039 for (wmGizmoGroup &gzgroup_iter : gzmap->groups) {
1040 if (gzgroup_iter.type == gzgt) {
1041 if (&gzgroup_iter != gzgroup) {
1042 WM_gizmo_group_tag_remove(&gzgroup_iter);
1043 }
1044 }
1045 }
1046
1047 wm_gizmomap_highlight_set(gzmap, nullptr, nullptr, 0);
1048
1050
1051 return gzgroup;
1052}
1053
1055{
1056 MEM_delete(gzgt_ref);
1057}
1058
1060 Main *bmain,
1061 wmGizmoMapType *gzmap_type,
1062 const wmGizmoGroupType *gzgt)
1063{
1064 /* Free instances. */
1065 for (bScreen *screen = bmain->screens.first(); screen;
1066 screen = static_cast<bScreen *>(screen->id.next))
1067 {
1068 for (ScrArea &area : screen->areabase) {
1069 for (SpaceLink &sl : area.spacedata) {
1070 ListBaseT<ARegion> *lb = (&sl == area.spacedata.first_) ? &area.regionbase :
1071 &sl.regionbase;
1072 for (ARegion &region : *lb) {
1073 wmGizmoMap *gzmap = region.runtime->gizmo_map;
1074 if (gzmap && gzmap->type == gzmap_type) {
1075 wmGizmoGroup *gzgroup, *gzgroup_next;
1076 for (gzgroup = gzmap->groups.first(); gzgroup; gzgroup = gzgroup_next) {
1077 gzgroup_next = gzgroup->next;
1078 if (gzgroup->type == gzgt) {
1079 BLI_assert(gzgroup->parent_gzmap == gzmap);
1080 wm_gizmogroup_free(C, gzgroup);
1082 }
1083 }
1084 }
1085 }
1086 }
1087 }
1088 }
1089
1090 /* Free types. */
1091 wmGizmoGroupTypeRef *gzgt_ref = WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt);
1092 if (gzgt_ref) {
1093 BLI_remlink(&gzmap_type->grouptype_refs, gzgt_ref);
1095 }
1096
1097/* TODO(@ideasman42): Gizmos may share key-maps, for now don't
1098 * remove however we could flag them as temporary/owned by the gizmo. */
1099#if 0
1100 /* NOTE: we may want to keep this key-map for editing. */
1101 WM_keymap_remove(gzgt->keyconf, gzgt->keymap);
1102#endif
1103
1104 BLI_assert(WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt) == nullptr);
1105}
1106
1108{
1109 /* Use flag since setup_keymap may return nullptr,
1110 * in that case we better not keep calling it. */
1112 gzgt->keymap = gzgt->setup_keymap(gzgt, keyconf);
1113 gzgt->keyconf = keyconf;
1115 }
1116}
1117 /* #wmGizmoGroupType. */
1119
1120/* -------------------------------------------------------------------- */
1133
1135{
1136 WM_gizmomaptype_group_link_ptr(gzmap_type, gzgt);
1137
1139}
1146{
1147 wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1148 BLI_assert(gzgt != nullptr);
1150}
1151
1153{
1154 wmGizmoGroupTypeRef *gzgt_ref = WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt);
1155 if (gzgt_ref == nullptr) {
1156 WM_gizmo_group_type_add_ptr_ex(gzgt, gzmap_type);
1157 return true;
1158 }
1159 return false;
1160}
1162{
1164 return WM_gizmo_group_type_ensure_ptr_ex(gzgt, gzmap_type);
1165}
1167{
1168 wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1169 BLI_assert(gzgt != nullptr);
1170 return WM_gizmo_group_type_ensure_ptr(gzgt);
1171}
1172
1174 wmGizmoGroupType *gzgt,
1175 wmGizmoMapType *gzmap_type)
1176{
1177 WM_gizmomaptype_group_unlink(nullptr, bmain, gzmap_type, gzgt);
1178}
1180{
1182 WM_gizmo_group_type_remove_ptr_ex(bmain, gzgt, gzmap_type);
1183}
1185{
1186 wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1187 BLI_assert(gzgt != nullptr);
1188 WM_gizmo_group_type_remove_ptr(bmain, gzgt);
1189}
1190
1192 wmGizmoGroupType *gzgt,
1193 wmGizmoMapType *gzmap_type)
1194{
1195 wmGizmoGroupTypeRef *gzgt_ref = WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt);
1196 BLI_assert(gzgt_ref != nullptr);
1197 UNUSED_VARS_NDEBUG(gzgt_ref);
1198 WM_gizmomaptype_group_unlink(nullptr, bmain, gzmap_type, gzgt);
1199 WM_gizmo_group_type_add_ptr_ex(gzgt, gzmap_type);
1200}
1202{
1204 WM_gizmo_group_type_reinit_ptr_ex(bmain, gzgt, gzmap_type);
1205}
1207{
1208 wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1209 BLI_assert(gzgt != nullptr);
1210 WM_gizmo_group_type_reinit_ptr(bmain, gzgt);
1211}
1212
1213/* Delayed versions. */
1214
1219
1225
1227{
1228 wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1229 BLI_assert(gzgt != nullptr);
1231}
1232
1234 wmGizmoMapType *gzmap_type,
1235 ScrArea *area)
1236{
1237 for (ARegion &region : area->regionbase) {
1238 wmGizmoMap *gzmap = region.runtime->gizmo_map;
1239 if (gzmap && gzmap->type == gzmap_type) {
1240 for (wmGizmoGroup &gzgroup : gzmap->groups) {
1241 if (gzgroup.type == gzgt) {
1242 WM_gizmo_group_tag_remove(&gzgroup);
1243 }
1244 }
1245 }
1246 }
1247}
1248
1250
1251/* -------------------------------------------------------------------- */
1254
1256{
1257 /* If we're tagged, only use compatible. */
1258 if (gzgt->owner_id[0] != '\0') {
1259 const WorkSpace *workspace = CTX_wm_workspace(C);
1260 if (BKE_workspace_owner_id_check(workspace, gzgt->owner_id) == false) {
1261 return false;
1262 }
1263 }
1264 /* Check for poll function, if gizmo-group belongs to an operator,
1265 * also check if the operator is running. */
1266 return (!gzgt->poll || gzgt->poll(C, const_cast<wmGizmoGroupType *>(gzgt)));
1267}
1268
1270{
1271 const wmGizmoGroupType *gzgt = gzgroup->type;
1273 wmGizmoMap *gzmap = gzgroup->parent_gzmap;
1274 wmGizmo *gz = nullptr;
1275 /* Without the check for refresh, any highlighted gizmo will prevent hiding
1276 * when selecting with RMB when the cursor happens to be over a gizmo. */
1277 if ((gzgroup->init_flag & WM_GIZMOGROUP_INIT_REFRESH) == 0) {
1278 gz = wm_gizmomap_highlight_get(gzmap);
1279 }
1280 if (!gz || gz->parent_gzgroup != gzgroup) {
1281 wmWindow *win = CTX_wm_window(C);
1282 ARegion *region = CTX_wm_region(C);
1283 BLI_assert(region->runtime->gizmo_map == gzmap);
1284 /* Check if the tweak event originated from this region. */
1285 if ((win->runtime->eventstate != nullptr) && (win->event_queue_check_drag) &&
1287 {
1288 /* We need to run refresh again. */
1291 gzgroup->hide.delay_refresh_for_tweak = true;
1292 return;
1293 }
1294 }
1295 gzgroup->hide.delay_refresh_for_tweak = false;
1296 }
1297
1298 if (gzgroup->hide.any) {
1299 return;
1300 }
1301
1302 if (gzgt->refresh) {
1303 gzgt->refresh(C, gzgroup);
1304 }
1305}
1306
1308
1309} // namespace blender
#define OPERATOR_RETVAL_CHECK(ret)
#define KMAP_MAX_NAME
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define BLI_assert_msg(a, msg)
void append(const T &value)
#define offsetof(t, d)
BMesh Iterators.
void WM_gizmo_free(wmGizmo *gz)
Definition wm_gizmo.cc:129
void * BLI_findptr(const ListBase *listbase, const void *ptr, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:710
void * MEM_new_uninitialized(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
UserDef U
Definition blender.cc:58
wmKeyMap * WM_keymap_active(const wmWindowManager *wm, wmKeyMap *keymap)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
char * STRNCPY(char(&dst)[N], const char *src)
void WM_gizmo_group_type_add(const StringRef idname)
void WM_gizmomaptype_group_init_runtime_keymap(const Main *bmain, wmGizmoGroupType *gzgt)
wmKeyMap * WM_gizmo_keymap_generic_select(wmWindowManager *wm)
wmGizmoGroupTypeRef * WM_gizmomaptype_group_link(wmGizmoMapType *gzmap_type, const StringRef idname)
bool WM_gizmo_group_type_ensure_ptr(wmGizmoGroupType *gzgt)
void WM_gizmoconfig_update_tag_group_remove(wmGizmoMap *gzmap)
wmKeyMap * WM_modalkeymap_find(wmKeyConfig *keyconf, const char *idname)
Definition wm_keymap.cc:999
wmKeyMapItem * WM_modalkeymap_add_item(wmKeyMap *km, const KeyMapItem_Params *params, int value)
void WM_gizmo_group_type_unlink_delayed_ptr_ex(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
WorkSpace * CTX_wm_workspace(const bContext *C)
void WM_keymap_remove(wmKeyConfig *keyconf, wmKeyMap *keymap)
Definition wm_keymap.cc:477
static wmKeyMap * WM_gizmogroup_keymap_template_select_ex(wmKeyConfig *kc, const char *name, const wmGizmoMapType_Params *params)
void WM_gizmo_group_unlink_delayed_ptr_from_space(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type, ScrArea *area)
static bool wm_gizmo_keymap_uses_event_modifier(wmWindowManager *wm, const wmGizmoGroup *gzgroup, const wmGizmo *gz, const int event_modifier, int *r_gzgroup_keymap_uses_modifier)
wmKeyMap * WM_gizmo_keymap_generic_press_drag_with_keyconfig(wmKeyConfig *kc)
int WM_gizmo_cmp_temp_fl_reverse(const void *gz_a_ptr, const void *gz_b_ptr)
bool BKE_workspace_owner_id_check(const WorkSpace *workspace, const char *owner_id) ATTR_NONNULL()
Definition workspace.cc:607
bool wm_gizmogroup_is_any_selected(const wmGizmoGroup *gzgroup)
@ TWEAK_MODAL_PRECISION_OFF
@ TWEAK_MODAL_PRECISION_ON
void wm_gizmogroup_gizmo_register(wmGizmoGroup *gzgroup, wmGizmo *gz)
wmGizmoGroupTypeRef * WM_gizmomaptype_group_find(wmGizmoMapType *gzmap_type, const StringRef idname)
wmKeyMap * WM_gizmogroup_setup_keymap_generic_drag(const wmGizmoGroupType *, wmKeyConfig *kc)
void WM_gizmo_group_type_unlink_delayed_ptr(wmGizmoGroupType *gzgt)
wmOperatorStatus WM_gizmo_operator_invoke(bContext *C, wmGizmo *gz, wmGizmoOpElem *gzop, const wmEvent *event)
Definition wm_gizmo.cc:223
bool ED_operator_region_gizmo_active(bContext *C)
void WM_gizmo_group_type_add_ptr(wmGizmoGroupType *gzgt)
wmKeyMap * wm_gizmogroup_tweak_modal_keymap(wmKeyConfig *keyconf)
bool wm_gizmomap_deselect_all(wmGizmoMap *gzmap)
wmKeyMap * WM_gizmo_keymap_generic_with_keyconfig(wmKeyConfig *kc)
wmWindow * CTX_wm_window(const bContext *C)
void WM_gizmo_group_type_add_ptr_ex(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
wmGizmoGroupTypeRef * WM_gizmomaptype_group_link_ptr(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt)
static void gizmo_tweak_finish(bContext *C, wmOperator *op, const bool cancel, bool clear_modal)
wmGizmoGroupType * WM_gizmogrouptype_find(const StringRef idname, bool quiet)
wmGizmoGroup * wm_gizmogroup_find_by_type(const wmGizmoMap *gzmap, const wmGizmoGroupType *gzgt)
void WM_tooltip_clear(bContext *C, wmWindow *win)
Definition wm_tooltip.cc:84
void ED_region_tag_redraw_editor_overlays(ARegion *region)
Definition area.cc:745
wmKeyMapItem * WM_keymap_add_item(wmKeyMap *keymap, const char *idname, const KeyMapItem_Params *params)
Definition wm_keymap.cc:563
void WM_gizmo_group_refresh(const bContext *C, wmGizmoGroup *gzgroup)
void IDP_MergeGroup(IDProperty *dest, const IDProperty *src, bool do_overwrite) ATTR_NONNULL()
Definition idprop.cc:783
bool wm_gizmo_select_and_highlight(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz)
Definition wm_gizmo.cc:406
wmGizmoGroup * wm_gizmogroup_new_from_type(wmGizmoMap *gzmap, wmGizmoGroupType *gzgt)
void WM_gizmo_group_type_reinit(Main *bmain, const StringRef idname)
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void WM_gizmomaptype_group_init_runtime(const Main *bmain, wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt)
wmKeyMap * WM_gizmo_keymap_generic_maybe_drag(wmWindowManager *wm)
wmGizmoGroupTypeRef * WM_gizmomaptype_group_find_ptr(wmGizmoMapType *gzmap_type, const wmGizmoGroupType *gzgt)
void WM_gizmo_group_type_remove_ptr_ex(Main *bmain, wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
void wm_gizmogroup_intersectable_gizmos_to_list(wmWindowManager *wm, wmGizmoGroup *gzgroup, const int event_modifier, Vector< wmGizmo *, 128 > *r_visible_gizmos)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void ED_undo_pop_op(bContext *C, wmOperator *op)
Definition ed_undo.cc:568
void wm_gizmogrouptype_setup_keymap(wmGizmoGroupType *gzgt, wmKeyConfig *keyconf)
eWM_GizmoFlagTweak
Gizmo tweak flag. Bit-flag passed to gizmo while tweaking.
@ WM_GIZMO_TWEAK_PRECISE
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
void WM_gizmo_group_tag_remove(wmGizmoGroup *gzgroup)
void WM_gizmomaptype_group_free(wmGizmoGroupTypeRef *gzgt_ref)
wmWindowManager * CTX_wm_manager(const bContext *C)
void WM_gizmoconfig_update_tag_group_type_init(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt)
void ED_undo_push(bContext *C, const char *str, UndoEncodeHints hints=UndoEncodeHints(0))
Definition ed_undo.cc:103
bool WM_event_is_mouse_drag(const wmEvent *event)
static wmOperatorStatus gizmo_tweak_modal(bContext *C, wmOperator *op, const wmEvent *event)
wmKeyMap * WM_gizmogroup_setup_keymap_generic(const wmGizmoGroupType *, wmKeyConfig *kc)
void WM_operator_properties_mouse_select(wmOperatorType *ot)
void WM_operator_free_all_after(wmWindowManager *wm, wmOperator *op)
Definition wm.cc:312
bool wm_gizmomap_highlight_set(wmGizmoMap *gzmap, const bContext *C, wmGizmo *gz, int part)
void WM_gizmogroup_ensure_init(const bContext *C, wmGizmoGroup *gzgroup)
static bool gizmo_tweak_start_and_finish(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event, bool *r_is_modal)
wmKeyMap * WM_keymap_ensure(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
Definition wm_keymap.cc:935
wmGizmo * wm_gizmogroup_find_intersected_gizmo(wmWindowManager *wm, const wmGizmoGroup *gzgroup, bContext *C, const int event_modifier, const int mval[2], int *r_part)
static wmOperatorStatus gizmo_select_invoke(bContext *C, wmOperator *op, const wmEvent *)
void WM_gizmo_group_type_remove_ptr(Main *bmain, wmGizmoGroupType *gzgt)
void wm_gizmogroup_free(bContext *C, wmGizmoGroup *gzgroup)
void WM_gizmomap_tag_refresh_drawstep(wmGizmoMap *gzmap, const eWM_GizmoFlagMapDrawStep drawstep)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void GIZMOGROUP_OT_gizmo_select(wmOperatorType *ot)
wmKeyMap * WM_gizmo_keymap_generic_press_drag(wmWindowManager *wm)
static wmOperatorStatus gizmo_tweak_invoke(bContext *C, wmOperator *op, const wmEvent *event)
@ WM_GIZMOMAPTYPE_KEYMAP_INIT
eWM_GizmoFlagMapDrawStep WM_gizmomap_drawstep_from_gizmo_group(const wmGizmoGroup *gzgroup)
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
bool WM_event_modifier_flag_match_kmi_press(const wmEventModifierFlag event_modifier, const wmKeyMapItem *kmi)
bool wm_gizmogroup_is_visible_in_drawstep(const wmGizmoGroup *gzgroup, const eWM_GizmoFlagMapDrawStep drawstep)
void WM_gizmo_group_type_reinit_ptr_ex(Main *bmain, wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
@ WM_GIZMOGROUP_INIT_REFRESH
@ WM_GIZMOGROUP_INIT_SETUP
@ WM_GIZMOGROUPTYPE_DELAY_REFRESH_FOR_TWEAK
@ WM_GIZMOGROUPTYPE_TOOL_INIT
@ WM_GIZMOGROUPTYPE_SELECT
@ WM_GIZMO_NEEDS_UNDO
@ WM_GIZMO_HIDDEN_SELECT
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
bool WM_gizmo_group_type_ensure(const StringRef idname)
wmKeyMap * WM_gizmo_keymap_generic_maybe_drag_with_keyconfig(wmKeyConfig *kc)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
@ WM_GIZMO_STATE_MODAL
@ WM_GIZMO_STATE_SELECT
bool WM_gizmo_select_set(wmGizmoMap *gzmap, wmGizmo *gz, bool select)
Definition wm_gizmo.cc:396
void WM_gizmo_group_type_remove(Main *bmain, const StringRef idname)
void WM_gizmo_group_remove_by_tool(bContext *C, Main *bmain, const wmGizmoGroupType *gzgt, const bToolRef *tref)
wmKeyMap * WM_gizmo_keymap_generic_drag(wmWindowManager *wm)
bool WM_gizmo_group_type_ensure_ptr_ex(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
wmGizmoMapType * WM_gizmomaptype_find(const wmGizmoMapType_Params *gzmap_params)
wmKeyMap * WM_gizmo_keymap_generic_drag_with_keyconfig(wmKeyConfig *kc)
wmGizmoMapType * WM_gizmomaptype_ensure(const wmGizmoMapType_Params *gzmap_params)
void WM_gizmomaptype_group_unlink(bContext *C, Main *bmain, wmGizmoMapType *gzmap_type, const wmGizmoGroupType *gzgt)
wmOperator * WM_operator_last_redo(const bContext *C)
@ KM_PRESS_DRAG
Definition WM_types.hh:332
@ KM_RELEASE
Definition WM_types.hh:325
void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
bool WM_gizmo_group_type_poll(const bContext *C, const wmGizmoGroupType *gzgt)
void GIZMOGROUP_OT_gizmo_tweak(wmOperatorType *ot)
void WM_gizmo_group_type_unlink_delayed(const StringRef idname)
bool BLI_rcti_isect_pt_v(const struct rcti *rect, const int xy[2])
wmKeyMap * WM_gizmogroup_setup_keymap_generic_maybe_drag(const wmGizmoGroupType *, wmKeyConfig *kc)
wmKeyMap * WM_modalkeymap_ensure(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items)
Definition wm_keymap.cc:972
@ OPTYPE_UNDO
Definition WM_types.hh:190
@ OPTYPE_BLOCKING
Definition WM_types.hh:192
@ OPTYPE_GRAB_CURSOR_XY
Definition WM_types.hh:196
wmOperatorStatus(*)(bContext *, wmGizmo *, const wmEvent *, eWM_GizmoFlagTweak) wmGizmoFnModal
wmKeyMap * WM_gizmo_keymap_generic(wmWindowManager *wm)
wmKeyMap * WM_gizmo_keymap_generic_select_with_keyconfig(wmKeyConfig *kc)
wmGizmoOpElem * WM_gizmo_operator_get(wmGizmo *gz, int part_index)
Definition wm_gizmo.cc:191
wmGizmo * wm_gizmomap_highlight_get(wmGizmoMap *gzmap)
bool WM_keymap_uses_event_modifier(const wmKeyMap *keymap, const int event_modifier)
void WM_gizmo_group_type_reinit_ptr(Main *bmain, wmGizmoGroupType *gzgt)
int WM_userdef_event_type_from_keymap_type(int kmitype)
void wm_gizmomap_modal_set(wmGizmoMap *gzmap, bContext *C, wmGizmo *gz, const wmEvent *event, bool enable)
bool WM_gizmo_select_unlink(wmGizmoMap *gzmap, wmGizmo *gz)
Definition wm_gizmo.cc:391
wmKeyMap * WM_gizmogroup_setup_keymap_generic_select(const wmGizmoGroupType *, wmKeyConfig *kc)
void WM_gizmoconfig_update_tag_group_type_remove(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt)
ARegion * CTX_wm_region(const bContext *C)
wmGizmoGroup * WM_gizmomaptype_group_init_runtime_with_region(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt, ARegion *region)
static bool gizmo_tweak_start(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event)
int WM_gizmo_cmp_temp_fl(const void *gz_a_ptr, const void *gz_b_ptr)
@ WM_GIZMOMAP_DRAWSTEP_3D
@ WM_GIZMOMAP_DRAWSTEP_2D
bke::ARegionRuntime * runtime
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
ListBaseT< bScreen > screens
Definition BKE_main.hh:400
ListBaseT< ARegion > regionbase
ScrArea_Runtime runtime
ListBaseT< SpaceLink > spacedata
int prev_press_xy[2]
Definition WM_types.hh:890
wmEventType type
Definition WM_types.hh:817
wmEventType prev_type
Definition WM_types.hh:872
wmEventModifierFlag modifier
Definition WM_types.hh:834
wmGizmoGroupFnRefresh refresh
eWM_GizmoFlagMapTypeUpdateFlag type_update_flag
wmGizmoGroupFnInvokePrepare invoke_prepare
wmGizmoGroupFnSetupKeymap setup_keymap
wmGizmoMapType_Params gzmap_params
eWM_GizmoFlagGroupTypeFlag flag
eWM_GizmoFlagGroupInitFlag init_flag
wmGizmoGroupType * type
ListBaseT< wmGizmo > gizmos
void(*) customdata_free(void *)
union blender::wmGizmoGroup::@230200225053276264314243222225366004150335145357 hide
ListBaseT< wmGizmoGroupTypeRef > grouptype_refs
struct blender::wmGizmoMap::@077047172235271304035100110332311133341144335100 gzmap_context
ListBaseT< wmGizmoGroup > groups
wmGizmoMapType * type
wmGizmoFnTestSelect test_select
const wmGizmoType * type
wmGizmoGroup * parent_gzgroup
eWM_GizmoFlag flag
wmGizmoFnModal custom_modal
eWM_GizmoFlagState state
union blender::wmGizmo::@207216221077365030243271316333035277144006330157 temp
ListBaseT< wmKeyMapItem > items
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
struct wmOperatorType * type
bke::WindowRuntime * runtime
#define USER_LMOUSESELECT