Blender  V3.3
wm_gizmo_group.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2014 Blender Foundation. All rights reserved. */
3 
13 #include <stdlib.h>
14 #include <string.h>
15 
16 #include "MEM_guardedalloc.h"
17 
18 #include "BLI_buffer.h"
19 #include "BLI_listbase.h"
20 #include "BLI_rect.h"
21 #include "BLI_string.h"
22 
23 #include "BKE_context.h"
24 #include "BKE_main.h"
25 #include "BKE_report.h"
26 #include "BKE_workspace.h"
27 
28 #include "RNA_access.h"
29 #include "RNA_define.h"
30 
31 #include "WM_api.h"
32 #include "WM_types.h"
33 #include "wm_event_system.h"
34 
35 #include "ED_screen.h"
36 #include "ED_undo.h"
37 
38 /* own includes */
39 #include "wm_gizmo_intern.h"
40 #include "wm_gizmo_wmapi.h"
41 
42 #ifdef WITH_PYTHON
43 # include "BPY_extern.h"
44 #endif
45 
46 /* -------------------------------------------------------------------- */
51 {
52  wmGizmoGroup *gzgroup = MEM_callocN(sizeof(*gzgroup), "gizmo-group");
53 
54  gzgroup->type = gzgt;
55  gzgroup->type->users += 1;
56 
57  /* keep back-link */
58  gzgroup->parent_gzmap = gzmap;
59 
60  BLI_addtail(&gzmap->groups, gzgroup);
61 
62  return gzgroup;
63 }
64 
66 {
67  return BLI_findptr(&gzmap->groups, gzgt, offsetof(wmGizmoGroup, type));
68 }
69 
71 {
72  wmGizmoMap *gzmap = gzgroup->parent_gzmap;
73 
74  /* Similar to WM_gizmo_unlink, but only to keep gzmap state correct,
75  * we don't want to run callbacks. */
76  if (gzmap->gzmap_context.highlight &&
77  gzmap->gzmap_context.highlight->parent_gzgroup == gzgroup) {
78  wm_gizmomap_highlight_set(gzmap, C, NULL, 0);
79  }
80  if (gzmap->gzmap_context.modal && gzmap->gzmap_context.modal->parent_gzgroup == gzgroup) {
81  wm_gizmomap_modal_set(gzmap, C, gzmap->gzmap_context.modal, NULL, false);
82  }
83 
84  for (wmGizmo *gz = gzgroup->gizmos.first, *gz_next; gz; gz = gz_next) {
85  gz_next = gz->next;
86  if (gzmap->gzmap_context.select.len) {
87  WM_gizmo_select_unlink(gzmap, gz);
88  }
89  WM_gizmo_free(gz);
90  }
91  BLI_listbase_clear(&gzgroup->gizmos);
92 
93 #ifdef WITH_PYTHON
94  if (gzgroup->py_instance) {
95  /* do this first in case there are any __del__ functions or
96  * similar that use properties */
98  }
99 #endif
100 
101  if (gzgroup->reports && (gzgroup->reports->flag & RPT_FREE)) {
102  BKE_reports_clear(gzgroup->reports);
103  MEM_freeN(gzgroup->reports);
104  }
105 
106  if (gzgroup->customdata_free) {
107  gzgroup->customdata_free(gzgroup->customdata);
108  }
109  else {
110  MEM_SAFE_FREE(gzgroup->customdata);
111  }
112 
113  BLI_remlink(&gzmap->groups, gzgroup);
114 
115  if (gzgroup->tag_remove == false) {
116  gzgroup->type->users -= 1;
117  }
118 
119  MEM_freeN(gzgroup);
120 }
121 
123 {
124  if (gzgroup->tag_remove == false) {
125  gzgroup->tag_remove = true;
126  gzgroup->type->users -= 1;
127  BLI_assert(gzgroup->type->users >= 0);
129  }
130 }
131 
133 {
134  BLI_assert(BLI_findindex(&gzgroup->gizmos, gz) == -1);
135  BLI_addtail(&gzgroup->gizmos, gz);
136  gz->parent_gzgroup = gzgroup;
137 }
138 
139 int WM_gizmo_cmp_temp_fl(const void *gz_a_ptr, const void *gz_b_ptr)
140 {
141  const wmGizmo *gz_a = gz_a_ptr;
142  const wmGizmo *gz_b = gz_b_ptr;
143  if (gz_a->temp.f < gz_b->temp.f) {
144  return -1;
145  }
146  if (gz_a->temp.f > gz_b->temp.f) {
147  return 1;
148  }
149  return 0;
150 }
151 
152 int WM_gizmo_cmp_temp_fl_reverse(const void *gz_a_ptr, const void *gz_b_ptr)
153 {
154  const wmGizmo *gz_a = gz_a_ptr;
155  const wmGizmo *gz_b = gz_b_ptr;
156  if (gz_a->temp.f < gz_b->temp.f) {
157  return 1;
158  }
159  if (gz_a->temp.f > gz_b->temp.f) {
160  return -1;
161  }
162  return 0;
163 }
164 
166  const wmGizmoGroup *gzgroup,
167  wmGizmo *gz,
168  const int event_modifier,
169  int *r_gzgroup_keymap_uses_modifier)
170 {
171  if (gz->keymap) {
172  wmKeyMap *keymap = WM_keymap_active(wm, gz->keymap);
173  if (!WM_keymap_uses_event_modifier(keymap, event_modifier)) {
174  return false;
175  }
176  }
177  else if (gzgroup->type->keymap) {
178  if (*r_gzgroup_keymap_uses_modifier == -1) {
179  wmKeyMap *keymap = WM_keymap_active(wm, gzgroup->type->keymap);
180  *r_gzgroup_keymap_uses_modifier = WM_keymap_uses_event_modifier(keymap, event_modifier);
181  }
182  if (*r_gzgroup_keymap_uses_modifier == 0) {
183  return false;
184  }
185  }
186  return true;
187 }
188 
190  const wmGizmoGroup *gzgroup,
191  bContext *C,
192  const int event_modifier,
193  const int mval[2],
194  int *r_part)
195 {
196  int gzgroup_keymap_uses_modifier = -1;
197 
198  LISTBASE_FOREACH (wmGizmo *, gz, &gzgroup->gizmos) {
199  if (gz->type->test_select && (gz->flag & (WM_GIZMO_HIDDEN | WM_GIZMO_HIDDEN_SELECT)) == 0) {
200 
202  wm, gzgroup, gz, event_modifier, &gzgroup_keymap_uses_modifier)) {
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 NULL;
213 }
214 
216  const wmGizmoGroup *gzgroup,
217  const int event_modifier,
218  BLI_Buffer *visible_gizmos)
219 {
220  int gzgroup_keymap_uses_modifier = -1;
221  for (wmGizmo *gz = gzgroup->gizmos.last; gz; gz = gz->prev) {
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 
228  wm, gzgroup, gz, event_modifier, &gzgroup_keymap_uses_modifier)) {
229  continue;
230  }
231 
232  BLI_buffer_append(visible_gizmos, wmGizmo *, gz);
233  }
234  }
235  }
236 }
237 
239 {
240  /* prepare for first draw */
241  if (UNLIKELY((gzgroup->init_flag & WM_GIZMOGROUP_INIT_SETUP) == 0)) {
242 
243  gzgroup->type->setup(C, gzgroup);
244 
245  /* Not ideal, initialize keymap here, needed for RNA runtime generated gizmos. */
246  wmGizmoGroupType *gzgt = gzgroup->type;
247  if (gzgt->keymap == NULL) {
250  BLI_assert(gzgt->keymap != NULL);
251  }
253  }
254 
255  /* Refresh may be called multiple times,
256  * this just ensures its called at least once before we draw. */
257  if (UNLIKELY((gzgroup->init_flag & WM_GIZMOGROUP_INIT_REFRESH) == 0)) {
258  /* Clear the flag before calling refresh so the callback
259  * can postpone the refresh by clearing this flag. */
261  WM_gizmo_group_refresh(C, gzgroup);
262  }
263 }
264 
266  Main *bmain,
267  const wmGizmoGroupType *gzgt,
268  const bToolRef *tref)
269 {
270  wmGizmoMapType *gzmap_type = WM_gizmomaptype_find(&gzgt->gzmap_params);
271  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
272  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
273  if (area->runtime.tool == tref) {
274  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
275  wmGizmoMap *gzmap = region->gizmo_map;
276  if (gzmap && gzmap->type == gzmap_type) {
277  wmGizmoGroup *gzgroup, *gzgroup_next;
278  for (gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup_next) {
279  gzgroup_next = gzgroup->next;
280  if (gzgroup->type == gzgt) {
281  BLI_assert(gzgroup->parent_gzmap == gzmap);
282  wm_gizmogroup_free(C, gzgroup);
284  }
285  }
286  }
287  }
288  }
289  }
290  }
291 }
292 
294  const eWM_GizmoFlagMapDrawStep drawstep)
295 {
296  switch (drawstep) {
298  return (gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D) == 0;
300  return (gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D);
301  default:
303  return false;
304  }
305 }
306 
308 {
309  if (gzgroup->type->flag & WM_GIZMOGROUPTYPE_SELECT) {
310  LISTBASE_FOREACH (const wmGizmo *, gz, &gzgroup->gizmos) {
311  if (gz->state & WM_GIZMO_STATE_SELECT) {
312  return true;
313  }
314  }
315  }
316  return false;
317 }
318 
321 /* -------------------------------------------------------------------- */
327 static int gizmo_select_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
328 {
329  ARegion *region = CTX_wm_region(C);
330  wmGizmoMap *gzmap = region->gizmo_map;
332  wmGizmo *highlight = gzmap->gzmap_context.highlight;
333 
334  bool extend = RNA_boolean_get(op->ptr, "extend");
335  bool deselect = RNA_boolean_get(op->ptr, "deselect");
336  bool toggle = RNA_boolean_get(op->ptr, "toggle");
337 
338  /* deselect all first */
339  if (extend == false && deselect == false && toggle == false) {
341  BLI_assert(msel->items == NULL && msel->len == 0);
342  UNUSED_VARS_NDEBUG(msel);
343  }
344 
345  if (highlight) {
346  const bool is_selected = (highlight->state & WM_GIZMO_STATE_SELECT);
347  bool redraw = false;
348 
349  if (toggle) {
350  /* toggle: deselect if already selected, else select */
351  deselect = is_selected;
352  }
353 
354  if (deselect) {
355  if (is_selected && WM_gizmo_select_set(gzmap, highlight, false)) {
356  redraw = true;
357  }
358  }
359  else if (wm_gizmo_select_and_highlight(C, gzmap, highlight)) {
360  redraw = true;
361  }
362 
363  if (redraw) {
365  }
366 
367  return OPERATOR_FINISHED;
368  }
369 
372 }
373 
375 {
376  /* identifiers */
377  ot->name = "Gizmo Select";
378  ot->description = "Select the currently highlighted gizmo";
379  ot->idname = "GIZMOGROUP_OT_gizmo_select";
380 
381  /* api callbacks */
383 
384  ot->flag = OPTYPE_UNDO;
385 
387 }
388 
389 typedef struct GizmoTweakData {
393 
394  int init_event; /* initial event type */
395  int flag; /* tweak flags */
396 
398 
399 static bool gizmo_tweak_start(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event)
400 {
401  /* activate highlighted gizmo */
402  wm_gizmomap_modal_set(gzmap, C, gz, event, true);
403 
404  return (gz->state & WM_GIZMO_STATE_MODAL);
405 }
406 
408  bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event, bool *r_is_modal)
409 {
411  if (r_is_modal) {
412  *r_is_modal = false;
413  }
414  if (gzop && gzop->type) {
415 
416  /* Undo/Redo */
417  if (gzop->is_redo) {
420 
421  /* We may want to enable this, for now the gizmo can manage its own properties. */
422 #if 0
423  IDP_MergeGroup(gzop->ptr.data, op->properties, false);
424 #endif
425 
427  ED_undo_pop_op(C, op);
428  }
429 
430  /* XXX temporary workaround for modal gizmo operator
431  * conflicting with modal operator attached to gizmo */
432  if (gzop->type->modal) {
433  /* activate highlighted gizmo */
434  wm_gizmomap_modal_set(gzmap, C, gz, event, true);
435  if (r_is_modal) {
436  *r_is_modal = true;
437  }
438  }
439  else {
440  if (gz->parent_gzgroup->type->invoke_prepare) {
441  gz->parent_gzgroup->type->invoke_prepare(C, gz->parent_gzgroup, gz, event);
442  }
443  /* Allow for 'button' gizmos, single click to run an action. */
444  WM_gizmo_operator_invoke(C, gz, gzop, event);
445  }
446  return true;
447  }
448  return false;
449 }
450 
451 static void gizmo_tweak_finish(bContext *C, wmOperator *op, const bool cancel, bool clear_modal)
452 {
453  GizmoTweakData *mtweak = op->customdata;
454  if (mtweak->gz_modal->type->exit) {
455  mtweak->gz_modal->type->exit(C, mtweak->gz_modal, cancel);
456  }
457  if (clear_modal) {
458  /* The gizmo may have been removed. */
459  if ((BLI_findindex(&mtweak->gzmap->groups, mtweak->gzgroup) != -1) &&
460  (BLI_findindex(&mtweak->gzgroup->gizmos, mtweak->gz_modal) != -1)) {
461  wm_gizmomap_modal_set(mtweak->gzmap, C, mtweak->gz_modal, NULL, false);
462  }
463  }
464  MEM_freeN(mtweak);
465 }
466 
467 static int gizmo_tweak_modal(bContext *C, wmOperator *op, const wmEvent *event)
468 {
469  GizmoTweakData *mtweak = op->customdata;
470  wmGizmo *gz = mtweak->gz_modal;
471  int retval = OPERATOR_PASS_THROUGH;
472  bool clear_modal = true;
473 
474  if (gz == NULL) {
477  }
478 
479  if (retval == OPERATOR_FINISHED) {
480  /* pass */
481  }
482  else if (event->type == mtweak->init_event && event->val == KM_RELEASE) {
483  retval = OPERATOR_FINISHED;
484  }
485  else if (event->type == EVT_MODAL_MAP) {
486  switch (event->val) {
487  case TWEAK_MODAL_CANCEL:
488  retval = OPERATOR_CANCELLED;
489  break;
490  case TWEAK_MODAL_CONFIRM:
491  retval = OPERATOR_FINISHED;
492  break;
494  mtweak->flag |= WM_GIZMO_TWEAK_PRECISE;
495  break;
497  mtweak->flag &= ~WM_GIZMO_TWEAK_PRECISE;
498  break;
499 
500  case TWEAK_MODAL_SNAP_ON:
501  mtweak->flag |= WM_GIZMO_TWEAK_SNAP;
502  break;
504  mtweak->flag &= ~WM_GIZMO_TWEAK_SNAP;
505  break;
506  }
507  }
508 
509  if (retval != OPERATOR_PASS_THROUGH) {
510  gizmo_tweak_finish(C, op, retval != OPERATOR_FINISHED, clear_modal);
511  return retval;
512  }
513 
514  /* handle gizmo */
515  wmGizmoFnModal modal_fn = gz->custom_modal ? gz->custom_modal : gz->type->modal;
516  if (modal_fn) {
517  /* Ugly hack to ensure Python won't get 'EVT_MODAL_MAP' which isn't supported, see T73727.
518  * note that we could move away from wrapping modal gizmos in a modal operator,
519  * since it's causing the need for code like this. */
520  wmEvent *evil_event = (wmEvent *)event;
521  short event_modal_val = 0;
522 
523  if (event->type == EVT_MODAL_MAP) {
524  event_modal_val = evil_event->val;
525  evil_event->type = evil_event->prev_type;
526  evil_event->val = evil_event->prev_val;
527  }
528 
529  int modal_retval = modal_fn(C, gz, event, mtweak->flag);
530 
531  if (event_modal_val != 0) {
532  evil_event->type = EVT_MODAL_MAP;
533  evil_event->val = event_modal_val;
534  }
535 
536  if ((modal_retval & OPERATOR_RUNNING_MODAL) == 0) {
537  gizmo_tweak_finish(C, op, (modal_retval & OPERATOR_CANCELLED) != 0, true);
538  return OPERATOR_FINISHED;
539  }
540 
541  /* Ugly hack to send gizmo events */
542  evil_event->type = EVT_GIZMO_UPDATE;
543  }
544 
545  /* always return PASS_THROUGH so modal handlers
546  * with gizmos attached can update */
548  return OPERATOR_PASS_THROUGH;
549 }
550 
551 static int gizmo_tweak_invoke(bContext *C, wmOperator *op, const wmEvent *event)
552 {
553  ARegion *region = CTX_wm_region(C);
554  wmGizmoMap *gzmap = region->gizmo_map;
555  wmGizmo *gz = gzmap->gzmap_context.highlight;
556 
557  /* Needed for single click actions which don't enter modal state. */
559 
560  if (!gz) {
561  /* wm_handlers_do_intern shouldn't let this happen */
564  }
565 
566  const int highlight_part_init = gz->highlight_part;
567 
568  if (gz->drag_part != -1) {
569  if (WM_event_is_mouse_drag(event)) {
570  gz->highlight_part = gz->drag_part;
571  }
572  }
573 
574  if (gizmo_tweak_start_and_finish(C, gzmap, gz, event, NULL)) {
575  return OPERATOR_FINISHED;
576  }
577 
578  if (!gizmo_tweak_start(C, gzmap, gz, event)) {
579  /* failed to start */
580  gz->highlight_part = highlight_part_init;
581  return OPERATOR_PASS_THROUGH;
582  }
583 
584  GizmoTweakData *mtweak = MEM_mallocN(sizeof(GizmoTweakData), __func__);
585 
587  mtweak->gz_modal = gzmap->gzmap_context.highlight;
588  mtweak->gzgroup = mtweak->gz_modal->parent_gzgroup;
589  mtweak->gzmap = gzmap;
590  mtweak->flag = 0;
591 
592  op->customdata = mtweak;
593 
595 
596  return OPERATOR_RUNNING_MODAL;
597 }
598 
600 {
601  /* identifiers */
602  ot->name = "Gizmo Tweak";
603  ot->description = "Tweak the active gizmo";
604  ot->idname = "GIZMOGROUP_OT_gizmo_tweak";
605 
606  /* api callbacks */
609 
610  /* TODO(@campbellbarton): This causes problems tweaking settings for operators,
611  * need to find a way to support this. */
612 #if 0
613  ot->flag = OPTYPE_UNDO;
614 #endif
615 }
616 
618 {
619  wmKeyMap *keymap;
620  char name[KMAP_MAX_NAME];
621 
622  static EnumPropertyItem modal_items[] = {
623  {TWEAK_MODAL_CANCEL, "CANCEL", 0, "Cancel", ""},
624  {TWEAK_MODAL_CONFIRM, "CONFIRM", 0, "Confirm", ""},
625  {TWEAK_MODAL_PRECISION_ON, "PRECISION_ON", 0, "Enable Precision", ""},
626  {TWEAK_MODAL_PRECISION_OFF, "PRECISION_OFF", 0, "Disable Precision", ""},
627  {TWEAK_MODAL_SNAP_ON, "SNAP_ON", 0, "Enable Snap", ""},
628  {TWEAK_MODAL_SNAP_OFF, "SNAP_OFF", 0, "Disable Snap", ""},
629  {0, NULL, 0, NULL, NULL},
630  };
631 
632  STRNCPY(name, "Generic Gizmo Tweak Modal Map");
633  keymap = WM_modalkeymap_find(keyconf, name);
634 
635  /* this function is called for each spacetype, only needs to add map once */
636  if (keymap && keymap->modal_items) {
637  return NULL;
638  }
639 
640  keymap = WM_modalkeymap_ensure(keyconf, name, modal_items);
641 
642  /* items for modal map */
644  &(const KeyMapItem_Params){
645  .type = EVT_ESCKEY,
646  .value = KM_PRESS,
647  .modifier = KM_ANY,
648  .direction = KM_ANY,
649  },
652  &(const KeyMapItem_Params){
653  .type = RIGHTMOUSE,
654  .value = KM_PRESS,
655  .modifier = KM_ANY,
656  .direction = KM_ANY,
657  },
659 
661  &(const KeyMapItem_Params){
662  .type = EVT_RETKEY,
663  .value = KM_PRESS,
664  .modifier = KM_ANY,
665  .direction = KM_ANY,
666  },
669  &(const KeyMapItem_Params){
670  .type = EVT_PADENTER,
671  .value = KM_PRESS,
672  .modifier = KM_ANY,
673  .direction = KM_ANY,
674  },
676 
678  &(const KeyMapItem_Params){
679  .type = EVT_RIGHTSHIFTKEY,
680  .value = KM_PRESS,
681  .modifier = KM_ANY,
682  .direction = KM_ANY,
683  },
686  &(const KeyMapItem_Params){
687  .type = EVT_RIGHTSHIFTKEY,
688  .value = KM_RELEASE,
689  .modifier = KM_ANY,
690  .direction = KM_ANY,
691  },
694  &(const KeyMapItem_Params){
695  .type = EVT_LEFTSHIFTKEY,
696  .value = KM_PRESS,
697  .modifier = KM_ANY,
698  .direction = KM_ANY,
699  },
702  &(const KeyMapItem_Params){
703  .type = EVT_LEFTSHIFTKEY,
704  .value = KM_RELEASE,
705  .modifier = KM_ANY,
706  .direction = KM_ANY,
707  },
709 
711  &(const KeyMapItem_Params){
712  .type = EVT_RIGHTCTRLKEY,
713  .value = KM_PRESS,
714  .modifier = KM_ANY,
715  .direction = KM_ANY,
716  },
719  &(const KeyMapItem_Params){
720  .type = EVT_RIGHTCTRLKEY,
721  .value = KM_RELEASE,
722  .modifier = KM_ANY,
723  .direction = KM_ANY,
724  },
727  &(const KeyMapItem_Params){
728  .type = EVT_LEFTCTRLKEY,
729  .value = KM_PRESS,
730  .modifier = KM_ANY,
731  .direction = KM_ANY,
732  },
735  &(const KeyMapItem_Params){
736  .type = EVT_LEFTCTRLKEY,
737  .value = KM_RELEASE,
738  .modifier = KM_ANY,
739  .direction = KM_ANY,
740  },
742 
743  WM_modalkeymap_assign(keymap, "GIZMOGROUP_OT_gizmo_tweak");
744 
745  return keymap;
746 }
747  /* wmGizmoGroup */
749 
750 /* -------------------------------------------------------------------- */
755 {
757 }
758 
760  wmKeyConfig *kc)
761 {
763 }
764 
766  wmKeyConfig *kc)
767 {
769 }
770 
780  wmKeyConfig *kc, const char *name, const struct wmGizmoMapType_Params *params)
781 {
782  /* Use area and region id since we might have multiple gizmos
783  * with the same name in different areas/regions. */
784  wmKeyMap *km = WM_keymap_ensure(kc, name, params->spaceid, params->regionid);
785  const bool do_init = BLI_listbase_is_empty(&km->items);
786 
787  /* FIXME(@campbellbarton): Currently hard coded. */
788 #if 0
789  const int select_mouse = (U.flag & USER_LMOUSESELECT) ? LEFTMOUSE : RIGHTMOUSE;
790  const int select_tweak = (U.flag & USER_LMOUSESELECT) ? EVT_TWEAK_L : EVT_TWEAK_R;
791  const int action_mouse = (U.flag & USER_LMOUSESELECT) ? RIGHTMOUSE : LEFTMOUSE;
792 #else
793  const int select_mouse = RIGHTMOUSE, select_mouse_val = KM_PRESS;
794  const int select_tweak = RIGHTMOUSE, select_tweak_val = KM_CLICK_DRAG;
795  const int action_mouse = LEFTMOUSE, action_mouse_val = KM_PRESS;
796 #endif
797 
798  if (do_init) {
800  "GIZMOGROUP_OT_gizmo_tweak",
801  &(const KeyMapItem_Params){
802  .type = action_mouse,
803  .value = action_mouse_val,
804  .modifier = KM_ANY,
805  .direction = KM_ANY,
806  });
808  "GIZMOGROUP_OT_gizmo_tweak",
809  &(const KeyMapItem_Params){
810  .type = select_tweak,
811  .value = select_tweak_val,
812  .modifier = 0,
813  .direction = KM_ANY,
814  });
815  }
816 
817  if (do_init) {
819  "GIZMOGROUP_OT_gizmo_select",
820  &(const KeyMapItem_Params){
821  .type = select_mouse,
822  .value = select_mouse_val,
823  .modifier = 0,
824  .direction = KM_ANY,
825  });
826  RNA_boolean_set(kmi->ptr, "extend", false);
827  RNA_boolean_set(kmi->ptr, "deselect", false);
828  RNA_boolean_set(kmi->ptr, "toggle", false);
829  kmi = WM_keymap_add_item(km,
830  "GIZMOGROUP_OT_gizmo_select",
831  &(const KeyMapItem_Params){
832  .type = select_mouse,
833  .value = select_mouse_val,
834  .modifier = KM_SHIFT,
835  .direction = KM_ANY,
836  });
837  RNA_boolean_set(kmi->ptr, "extend", false);
838  RNA_boolean_set(kmi->ptr, "deselect", false);
839  RNA_boolean_set(kmi->ptr, "toggle", true);
840  }
841 
842  return km;
843 }
844 
846  wmKeyConfig *kc)
847 {
848  struct wmGizmoMapType_Params params = {
849  .spaceid = SPACE_EMPTY,
850  .regionid = RGN_TYPE_WINDOW,
851  };
852  return WM_gizmogroup_keymap_template_select_ex(kc, "Generic Gizmo Select", &params);
853 }
854 
857 /* -------------------------------------------------------------------- */
864 {
865  const char *idname = "Generic Gizmo";
867 }
869 {
871 }
872 
874 {
875  const char *idname = "Generic Gizmo Select";
877 }
879 {
881 }
882 
884 {
885  const char *idname = "Generic Gizmo Drag";
887 }
889 {
891 }
892 
894 {
895  const char *idname = "Generic Gizmo Click Drag";
897 }
899 {
901 }
902 
904 {
905  const char *idname = "Generic Gizmo Maybe Drag";
907 }
909 {
911 }
912 
915 /* -------------------------------------------------------------------- */
920  const wmGizmoGroupType *gzgt)
921 {
922  /* could use hash lookups as operator types do, for now simple search. */
923  LISTBASE_FOREACH (wmGizmoGroupTypeRef *, gzgt_ref, &gzmap_type->grouptype_refs) {
924  if (gzgt_ref->type == gzgt) {
925  return gzgt_ref;
926  }
927  }
928  return NULL;
929 }
930 
932  const char *idname)
933 {
934  /* could use hash lookups as operator types do, for now simple search. */
935  LISTBASE_FOREACH (wmGizmoGroupTypeRef *, gzgt_ref, &gzmap_type->grouptype_refs) {
936  if (STREQ(idname, gzgt_ref->type->idname)) {
937  return gzgt_ref;
938  }
939  }
940  return NULL;
941 }
942 
944 {
945  wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
946  BLI_assert(gzgt != NULL);
947  return WM_gizmomaptype_group_link_ptr(gzmap_type, gzgt);
948 }
949 
951  wmGizmoGroupType *gzgt)
952 {
953  wmGizmoGroupTypeRef *gzgt_ref = MEM_callocN(sizeof(wmGizmoGroupTypeRef), "gizmo-group-ref");
954  gzgt_ref->type = gzgt;
955  BLI_addtail(&gzmap_type->grouptype_refs, gzgt_ref);
956  return gzgt_ref;
957 }
958 
960 {
961  /* init keymap - on startup there's an extra call to init keymaps for 'permanent' gizmo-groups */
962  wm_gizmogrouptype_setup_keymap(gzgt, ((wmWindowManager *)bmain->wm.first)->defaultconf);
963 }
964 
966  wmGizmoMapType *gzmap_type,
967  wmGizmoGroupType *gzgt)
968 {
969  /* Tools add themselves. */
970  if (gzgt->flag & WM_GIZMOGROUPTYPE_TOOL_INIT) {
971  return;
972  }
973 
974  /* now create a gizmo for all existing areas */
975  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
976  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
977  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
978  ListBase *lb = (sl == area->spacedata.first) ? &area->regionbase : &sl->regionbase;
979  LISTBASE_FOREACH (ARegion *, region, lb) {
980  wmGizmoMap *gzmap = region->gizmo_map;
981  if (gzmap && gzmap->type == gzmap_type) {
982  WM_gizmomaptype_group_init_runtime_with_region(gzmap_type, gzgt, region);
983  }
984  }
985  }
986  }
987  }
988 }
989 
991  wmGizmoGroupType *gzgt,
992  ARegion *region)
993 {
994  wmGizmoMap *gzmap = region->gizmo_map;
995  BLI_assert(gzmap && gzmap->type == gzmap_type);
996  UNUSED_VARS_NDEBUG(gzmap_type);
997 
998  wmGizmoGroup *gzgroup = wm_gizmogroup_new_from_type(gzmap, gzgt);
999 
1000  /* Don't allow duplicates when switching modes for e.g. see: T66229. */
1001  LISTBASE_FOREACH (wmGizmoGroup *, gzgroup_iter, &gzmap->groups) {
1002  if (gzgroup_iter->type == gzgt) {
1003  if (gzgroup_iter != gzgroup) {
1004  WM_gizmo_group_tag_remove(gzgroup_iter);
1005  }
1006  }
1007  }
1008 
1009  wm_gizmomap_highlight_set(gzmap, NULL, NULL, 0);
1010 
1012 
1013  return gzgroup;
1014 }
1015 
1017 {
1018  MEM_freeN(gzgt_ref);
1019 }
1020 
1022  Main *bmain,
1023  wmGizmoMapType *gzmap_type,
1024  const wmGizmoGroupType *gzgt)
1025 {
1026  /* Free instances. */
1027  for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1028  LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1029  LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
1030  ListBase *lb = (sl == area->spacedata.first) ? &area->regionbase : &sl->regionbase;
1031  LISTBASE_FOREACH (ARegion *, region, lb) {
1032  wmGizmoMap *gzmap = region->gizmo_map;
1033  if (gzmap && gzmap->type == gzmap_type) {
1034  wmGizmoGroup *gzgroup, *gzgroup_next;
1035  for (gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup_next) {
1036  gzgroup_next = gzgroup->next;
1037  if (gzgroup->type == gzgt) {
1038  BLI_assert(gzgroup->parent_gzmap == gzmap);
1039  wm_gizmogroup_free(C, gzgroup);
1041  }
1042  }
1043  }
1044  }
1045  }
1046  }
1047  }
1048 
1049  /* Free types. */
1050  wmGizmoGroupTypeRef *gzgt_ref = WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt);
1051  if (gzgt_ref) {
1052  BLI_remlink(&gzmap_type->grouptype_refs, gzgt_ref);
1053  WM_gizmomaptype_group_free(gzgt_ref);
1054  }
1055 
1056  /* TODO(campbell): Gizmos may share key-maps, for now don't
1057  * remove however we could flag them as temporary/owned by the gizmo. */
1058 #if 0
1059  /* NOTE: we may want to keep this key-map for editing. */
1060  WM_keymap_remove(gzgt->keyconf, gzgt->keymap);
1061 #endif
1062 
1063  BLI_assert(WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt) == NULL);
1064 }
1065 
1067 {
1068  /* Use flag since setup_keymap may return NULL,
1069  * in that case we better not keep calling it. */
1071  gzgt->keymap = gzgt->setup_keymap(gzgt, keyconf);
1072  gzgt->keyconf = keyconf;
1074  }
1075 }
1076  /* wmGizmoGroupType */
1078 
1079 /* -------------------------------------------------------------------- */
1094 {
1095  WM_gizmomaptype_group_link_ptr(gzmap_type, gzgt);
1096 
1098 }
1100 {
1101  wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params);
1102  WM_gizmo_group_type_add_ptr_ex(gzgt, gzmap_type);
1103 }
1104 void WM_gizmo_group_type_add(const char *idname)
1105 {
1106  wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1107  BLI_assert(gzgt != NULL);
1109 }
1110 
1112 {
1113  wmGizmoGroupTypeRef *gzgt_ref = WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt);
1114  if (gzgt_ref == NULL) {
1115  WM_gizmo_group_type_add_ptr_ex(gzgt, gzmap_type);
1116  return true;
1117  }
1118  return false;
1119 }
1121 {
1122  wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params);
1123  return WM_gizmo_group_type_ensure_ptr_ex(gzgt, gzmap_type);
1124 }
1125 bool WM_gizmo_group_type_ensure(const char *idname)
1126 {
1127  wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1128  BLI_assert(gzgt != NULL);
1129  return WM_gizmo_group_type_ensure_ptr(gzgt);
1130 }
1131 
1133  wmGizmoGroupType *gzgt,
1134  wmGizmoMapType *gzmap_type)
1135 {
1136  WM_gizmomaptype_group_unlink(NULL, bmain, gzmap_type, gzgt);
1137 }
1139 {
1140  wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params);
1141  WM_gizmo_group_type_remove_ptr_ex(bmain, gzgt, gzmap_type);
1142 }
1143 void WM_gizmo_group_type_remove(struct Main *bmain, const char *idname)
1144 {
1145  wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1146  BLI_assert(gzgt != NULL);
1147  WM_gizmo_group_type_remove_ptr(bmain, gzgt);
1148 }
1149 
1151  wmGizmoGroupType *gzgt,
1152  wmGizmoMapType *gzmap_type)
1153 {
1154  wmGizmoGroupTypeRef *gzgt_ref = WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt);
1155  BLI_assert(gzgt_ref != NULL);
1156  UNUSED_VARS_NDEBUG(gzgt_ref);
1157  WM_gizmomaptype_group_unlink(NULL, bmain, gzmap_type, gzgt);
1158  WM_gizmo_group_type_add_ptr_ex(gzgt, gzmap_type);
1159 }
1161 {
1162  wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params);
1163  WM_gizmo_group_type_reinit_ptr_ex(bmain, gzgt, gzmap_type);
1164 }
1165 void WM_gizmo_group_type_reinit(struct Main *bmain, const char *idname)
1166 {
1167  wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1168  BLI_assert(gzgt != NULL);
1169  WM_gizmo_group_type_reinit_ptr(bmain, gzgt);
1170 }
1171 
1172 /* delayed versions */
1173 
1175 {
1177 }
1178 
1180 {
1181  wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params);
1183 }
1184 
1185 void WM_gizmo_group_type_unlink_delayed(const char *idname)
1186 {
1187  wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false);
1188  BLI_assert(gzgt != NULL);
1190 }
1191 
1193  wmGizmoMapType *gzmap_type,
1194  ScrArea *area)
1195 {
1196  LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
1197  wmGizmoMap *gzmap = region->gizmo_map;
1198  if (gzmap && gzmap->type == gzmap_type) {
1199  LISTBASE_FOREACH (wmGizmoGroup *, gzgroup, &gzmap->groups) {
1200  if (gzgroup->type == gzgt) {
1201  WM_gizmo_group_tag_remove(gzgroup);
1202  }
1203  }
1204  }
1205  }
1206 }
1207 
1210 /* -------------------------------------------------------------------- */
1215 {
1216  /* If we're tagged, only use compatible. */
1217  if (gzgt->owner_id[0] != '\0') {
1218  const WorkSpace *workspace = CTX_wm_workspace(C);
1219  if (BKE_workspace_owner_id_check(workspace, gzgt->owner_id) == false) {
1220  return false;
1221  }
1222  }
1223  /* Check for poll function, if gizmo-group belongs to an operator,
1224  * also check if the operator is running. */
1225  return (!gzgt->poll || gzgt->poll(C, (wmGizmoGroupType *)gzgt));
1226 }
1227 
1229 {
1230  const wmGizmoGroupType *gzgt = gzgroup->type;
1232  wmGizmoMap *gzmap = gzgroup->parent_gzmap;
1233  wmGizmo *gz = NULL;
1234  /* Without the check for refresh, any highlighted gizmo will prevent hiding
1235  * when selecting with RMB when the cursor happens to be over a gizmo. */
1236  if ((gzgroup->init_flag & WM_GIZMOGROUP_INIT_REFRESH) == 0) {
1237  gz = wm_gizmomap_highlight_get(gzmap);
1238  }
1239  if (!gz || gz->parent_gzgroup != gzgroup) {
1240  wmWindow *win = CTX_wm_window(C);
1241  ARegion *region = CTX_wm_region(C);
1242  BLI_assert(region->gizmo_map == gzmap);
1243  /* Check if the tweak event originated from this region. */
1244  if ((win->eventstate != NULL) && (win->event_queue_check_drag) &&
1246  /* We need to run refresh again. */
1249  gzgroup->hide.delay_refresh_for_tweak = true;
1250  return;
1251  }
1252  }
1253  gzgroup->hide.delay_refresh_for_tweak = false;
1254  }
1255 
1256  if (gzgroup->hide.any) {
1257  return;
1258  }
1259 
1260  if (gzgt->refresh) {
1261  gzgt->refresh(C, gzgroup);
1262  }
1263 }
1264 
struct WorkSpace * CTX_wm_workspace(const bContext *C)
Definition: context.c:728
struct wmWindowManager * CTX_wm_manager(const bContext *C)
Definition: context.c:713
struct ARegion * CTX_wm_region(const bContext *C)
Definition: context.c:749
struct wmWindow * CTX_wm_window(const bContext *C)
Definition: context.c:723
void IDP_MergeGroup(struct IDProperty *dest, const struct IDProperty *src, bool do_overwrite) ATTR_NONNULL()
void BKE_reports_clear(ReportList *reports)
Definition: report.c:63
bool BKE_workspace_owner_id_check(const struct WorkSpace *workspace, const char *owner_id) ATTR_NONNULL()
#define BLI_assert_unreachable()
Definition: BLI_assert.h:93
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define BLI_buffer_append(buffer_, type_, val_)
Definition: BLI_buffer.h:50
BLI_INLINE bool BLI_listbase_is_empty(const struct ListBase *lb)
Definition: BLI_listbase.h:269
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:100
int BLI_findindex(const struct ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void * BLI_findptr(const struct ListBase *listbase, const void *ptr, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
bool BLI_rcti_isect_pt_v(const struct rcti *rect, const int xy[2])
#define STRNCPY(dst, src)
Definition: BLI_string.h:483
#define UNUSED_VARS_NDEBUG(...)
#define UNUSED(x)
#define UNLIKELY(x)
#define STREQ(a, b)
void BPY_DECREF_RNA_INVALIDATE(void *pyob_ptr)
@ RGN_TYPE_WINDOW
@ SPACE_EMPTY
#define KMAP_MAX_NAME
@ OPERATOR_CANCELLED
@ OPERATOR_FINISHED
@ OPERATOR_RUNNING_MODAL
@ OPERATOR_PASS_THROUGH
void ED_region_tag_redraw_editor_overlays(struct ARegion *region)
Definition: area.c:690
void ED_undo_pop_op(struct bContext *C, struct wmOperator *op)
Definition: ed_undo.c:420
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
Read Guarded memory(de)allocation.
#define MEM_SAFE_FREE(v)
#define C
Definition: RandGen.cpp:25
eWM_GizmoFlagMapDrawStep
@ WM_GIZMOMAP_DRAWSTEP_3D
@ WM_GIZMOMAP_DRAWSTEP_2D
@ WM_GIZMO_TWEAK_PRECISE
@ WM_GIZMO_TWEAK_SNAP
@ WM_GIZMOMAPTYPE_KEYMAP_INIT
@ WM_GIZMOGROUP_INIT_REFRESH
@ WM_GIZMOGROUP_INIT_SETUP
@ WM_GIZMO_HIDDEN
@ WM_GIZMO_HIDDEN_SELECT
@ WM_GIZMOGROUPTYPE_TOOL_INIT
@ WM_GIZMOGROUPTYPE_DELAY_REFRESH_FOR_TWEAK
@ WM_GIZMOGROUPTYPE_3D
@ WM_GIZMOGROUPTYPE_SELECT
@ WM_GIZMO_STATE_MODAL
@ WM_GIZMO_STATE_SELECT
@ KM_ANY
Definition: WM_types.h:265
@ KM_PRESS
Definition: WM_types.h:267
@ KM_CLICK_DRAG
Definition: WM_types.h:275
@ KM_RELEASE
Definition: WM_types.h:268
@ OPTYPE_UNDO
Definition: WM_types.h:148
@ KM_SHIFT
Definition: WM_types.h:238
unsigned int U
Definition: btGjkEpa3.h:78
uiWidgetBaseParameters params[MAX_WIDGET_BASE_BATCH]
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
static void area(int d1, int d2, int e1, int e2, float weights[2])
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
Definition: rna_access.c:4874
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4863
struct wmGizmoMap * gizmo_map
wmGizmoGroup * gzgroup
wmGizmo * gz_modal
wmGizmoMap * gzmap
void * last
Definition: DNA_listBase.h:31
void * first
Definition: DNA_listBase.h:31
Definition: BKE_main.h:121
ListBase wm
Definition: BKE_main.h:197
ListBase screens
Definition: BKE_main.h:183
void * data
Definition: RNA_types.h:38
short val
Definition: WM_types.h:680
short prev_type
Definition: WM_types.h:720
short prev_val
Definition: WM_types.h:722
int prev_press_xy[2]
Definition: WM_types.h:738
short type
Definition: WM_types.h:678
struct wmGizmoGroupType * type
wmGizmoGroupFnSetupKeymap setup_keymap
struct wmKeyConfig * keyconf
wmGizmoGroupFnRefresh refresh
wmGizmoGroupFnInit setup
wmGizmoGroupFnInvokePrepare invoke_prepare
eWM_GizmoFlagGroupTypeFlag flag
struct wmKeyMap * keymap
eWM_GizmoFlagMapTypeUpdateFlag type_update_flag
wmGizmoGroupFnPoll poll
struct wmGizmoMapType_Params gzmap_params
struct wmGizmoGroup * next
ListBase gizmos
struct wmGizmoGroupType * type
eWM_GizmoFlagGroupInitFlag init_flag
void * py_instance
void(* customdata_free)(void *)
struct wmGizmoMap * parent_gzmap
struct ReportList * reports
union wmGizmoGroup::@1186 hide
uint delay_refresh_for_tweak
struct wmGizmo ** items
ListBase grouptype_refs
struct wmGizmoMapType * type
ListBase groups
struct wmGizmo * modal
struct wmGizmo * highlight
struct wmGizmoMapSelectState select
struct wmGizmoMap::@1182 gzmap_context
Gizmo map runtime context.
PointerRNA ptr
struct wmOperatorType * type
wmGizmoFnModal modal
wmGizmoFnExit exit
eWM_GizmoFlagState state
struct wmGizmoGroup * parent_gzgroup
int highlight_part
union wmGizmo::@1184 temp
struct wmKeyMap * keymap
wmGizmoFnModal custom_modal
const struct wmGizmoType * type
struct PointerRNA * ptr
const void * modal_items
int(* invoke)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:919
const char * name
Definition: WM_types.h:888
int(* modal)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:935
const char * idname
Definition: WM_types.h:890
const char * description
Definition: WM_types.h:893
IDProperty * properties
struct PointerRNA * ptr
struct wmKeyConfig * defaultconf
struct wmEvent * eventstate
#define USER_LMOUSESELECT
void WM_operator_free_all_after(wmWindowManager *wm, struct wmOperator *op)
Definition: wm.c:325
bool WM_event_is_mouse_drag(const wmEvent *event)
int WM_userdef_event_type_from_keymap_type(int kmitype)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
@ RIGHTMOUSE
@ EVT_MODAL_MAP
@ EVT_RIGHTCTRLKEY
@ EVT_LEFTCTRLKEY
@ EVT_PADENTER
@ LEFTMOUSE
@ EVT_ESCKEY
@ EVT_GIZMO_UPDATE
@ EVT_RIGHTSHIFTKEY
@ EVT_LEFTSHIFTKEY
@ EVT_RETKEY
wmOperatorType * ot
Definition: wm_files.c:3479
bool wm_gizmo_select_and_highlight(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz)
Definition: wm_gizmo.c:407
void WM_gizmo_free(wmGizmo *gz)
Definition: wm_gizmo.c:126
int WM_gizmo_operator_invoke(bContext *C, wmGizmo *gz, wmGizmoOpElem *gzop, const wmEvent *event)
Definition: wm_gizmo.c:229
bool WM_gizmo_select_unlink(wmGizmoMap *gzmap, wmGizmo *gz)
Definition: wm_gizmo.c:392
struct wmGizmoOpElem * WM_gizmo_operator_get(wmGizmo *gz, int part_index)
Definition: wm_gizmo.c:195
bool WM_gizmo_select_set(wmGizmoMap *gzmap, wmGizmo *gz, bool select)
Definition: wm_gizmo.c:397
int(* wmGizmoFnModal)(struct bContext *, struct wmGizmo *, const struct wmEvent *, eWM_GizmoFlagTweak)
Definition: wm_gizmo_fn.h:42
void WM_gizmo_group_refresh(const bContext *C, wmGizmoGroup *gzgroup)
void WM_gizmomaptype_group_init_runtime_keymap(const Main *bmain, wmGizmoGroupType *gzgt)
int WM_gizmo_cmp_temp_fl_reverse(const void *gz_a_ptr, const void *gz_b_ptr)
wmKeyMap * WM_gizmogroup_setup_keymap_generic_drag(const wmGizmoGroupType *UNUSED(gzgt), wmKeyConfig *kc)
wmGizmoGroup * wm_gizmogroup_new_from_type(wmGizmoMap *gzmap, wmGizmoGroupType *gzgt)
struct wmGizmoGroupTypeRef * WM_gizmomaptype_group_find_ptr(struct wmGizmoMapType *gzmap_type, const wmGizmoGroupType *gzgt)
void WM_gizmomaptype_group_init_runtime(const Main *bmain, wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt)
wmGizmoGroupTypeRef * WM_gizmomaptype_group_link(wmGizmoMapType *gzmap_type, const char *idname)
struct wmKeyMap * WM_gizmo_keymap_generic_maybe_drag(wmWindowManager *wm)
void wm_gizmogroup_gizmo_register(wmGizmoGroup *gzgroup, wmGizmo *gz)
void wm_gizmogrouptype_setup_keymap(wmGizmoGroupType *gzgt, wmKeyConfig *keyconf)
void WM_gizmo_group_type_reinit_ptr_ex(struct Main *bmain, wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
void WM_gizmogroup_ensure_init(const bContext *C, wmGizmoGroup *gzgroup)
bool WM_gizmo_group_type_ensure_ptr(wmGizmoGroupType *gzgt)
static int gizmo_tweak_modal(bContext *C, wmOperator *op, const wmEvent *event)
static wmKeyMap * WM_gizmogroup_keymap_template_select_ex(wmKeyConfig *kc, const char *name, const struct wmGizmoMapType_Params *params)
bool WM_gizmo_group_type_ensure_ptr_ex(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
struct wmKeyMap * WM_gizmo_keymap_generic_drag_with_keyconfig(wmKeyConfig *kc)
void WM_gizmo_group_type_unlink_delayed_ptr(wmGizmoGroupType *gzgt)
void WM_gizmo_group_remove_by_tool(bContext *C, Main *bmain, const wmGizmoGroupType *gzgt, const bToolRef *tref)
void WM_gizmo_group_type_add_ptr(wmGizmoGroupType *gzgt)
void WM_gizmo_group_type_remove_ptr_ex(struct Main *bmain, wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
struct GizmoTweakData GizmoTweakData
void WM_gizmo_group_type_remove(struct Main *bmain, const char *idname)
wmKeyMap * wm_gizmogroup_tweak_modal_keymap(wmKeyConfig *keyconf)
bool wm_gizmogroup_is_visible_in_drawstep(const wmGizmoGroup *gzgroup, const eWM_GizmoFlagMapDrawStep drawstep)
struct wmKeyMap * WM_gizmo_keymap_generic_click_drag(wmWindowManager *wm)
static bool gizmo_tweak_start_and_finish(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event, bool *r_is_modal)
void WM_gizmo_group_unlink_delayed_ptr_from_space(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type, ScrArea *area)
void WM_gizmomaptype_group_free(wmGizmoGroupTypeRef *gzgt_ref)
void WM_gizmo_group_type_add(const char *idname)
void WM_gizmo_group_type_reinit(struct Main *bmain, const char *idname)
static int gizmo_tweak_invoke(bContext *C, wmOperator *op, const wmEvent *event)
static bool gizmo_tweak_start(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event)
bool WM_gizmo_group_type_ensure(const char *idname)
struct wmGizmoGroupTypeRef * WM_gizmomaptype_group_find(struct wmGizmoMapType *gzmap_type, const char *idname)
void wm_gizmogroup_intersectable_gizmos_to_list(wmWindowManager *wm, const wmGizmoGroup *gzgroup, const int event_modifier, BLI_Buffer *visible_gizmos)
void WM_gizmo_group_type_reinit_ptr(struct Main *bmain, wmGizmoGroupType *gzgt)
void WM_gizmo_group_type_unlink_delayed(const char *idname)
void WM_gizmo_group_type_add_ptr_ex(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
wmGizmo * wm_gizmogroup_find_intersected_gizmo(wmWindowManager *wm, const wmGizmoGroup *gzgroup, bContext *C, const int event_modifier, const int mval[2], int *r_part)
struct wmKeyMap * WM_gizmo_keymap_generic_drag(wmWindowManager *wm)
wmKeyMap * WM_gizmogroup_setup_keymap_generic_maybe_drag(const wmGizmoGroupType *UNUSED(gzgt), wmKeyConfig *kc)
int WM_gizmo_cmp_temp_fl(const void *gz_a_ptr, const void *gz_b_ptr)
bool WM_gizmo_group_type_poll(const bContext *C, const wmGizmoGroupType *gzgt)
void GIZMOGROUP_OT_gizmo_select(wmOperatorType *ot)
void WM_gizmo_group_tag_remove(wmGizmoGroup *gzgroup)
struct wmKeyMap * WM_gizmo_keymap_generic_maybe_drag_with_keyconfig(wmKeyConfig *kc)
wmGizmoGroupTypeRef * WM_gizmomaptype_group_link_ptr(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt)
bool wm_gizmogroup_is_any_selected(const wmGizmoGroup *gzgroup)
void WM_gizmomaptype_group_unlink(bContext *C, Main *bmain, wmGizmoMapType *gzmap_type, const wmGizmoGroupType *gzgt)
struct wmKeyMap * WM_gizmo_keymap_generic_select_with_keyconfig(wmKeyConfig *kc)
static void gizmo_tweak_finish(bContext *C, wmOperator *op, const bool cancel, bool clear_modal)
static bool wm_gizmo_keymap_uses_event_modifier(wmWindowManager *wm, const wmGizmoGroup *gzgroup, wmGizmo *gz, const int event_modifier, int *r_gzgroup_keymap_uses_modifier)
struct wmKeyMap * WM_gizmo_keymap_generic_click_drag_with_keyconfig(wmKeyConfig *kc)
struct wmKeyMap * WM_gizmo_keymap_generic(wmWindowManager *wm)
static int gizmo_select_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
wmGizmoGroup * WM_gizmomaptype_group_init_runtime_with_region(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt, ARegion *region)
wmGizmoGroup * wm_gizmogroup_find_by_type(const wmGizmoMap *gzmap, const wmGizmoGroupType *gzgt)
void WM_gizmo_group_type_unlink_delayed_ptr_ex(wmGizmoGroupType *gzgt, wmGizmoMapType *gzmap_type)
wmKeyMap * WM_gizmogroup_setup_keymap_generic_select(const wmGizmoGroupType *UNUSED(gzgt), wmKeyConfig *kc)
struct wmKeyMap * WM_gizmo_keymap_generic_with_keyconfig(wmKeyConfig *kc)
void wm_gizmogroup_free(bContext *C, wmGizmoGroup *gzgroup)
wmKeyMap * WM_gizmogroup_setup_keymap_generic(const wmGizmoGroupType *UNUSED(gzgt), wmKeyConfig *kc)
struct wmKeyMap * WM_gizmo_keymap_generic_select(wmWindowManager *wm)
void GIZMOGROUP_OT_gizmo_tweak(wmOperatorType *ot)
void WM_gizmo_group_type_remove_ptr(struct Main *bmain, wmGizmoGroupType *gzgt)
wmGizmoGroupType * WM_gizmogrouptype_find(const char *idname, bool quiet)
@ TWEAK_MODAL_PRECISION_ON
@ TWEAK_MODAL_SNAP_ON
@ TWEAK_MODAL_PRECISION_OFF
@ TWEAK_MODAL_CONFIRM
@ TWEAK_MODAL_SNAP_OFF
@ TWEAK_MODAL_CANCEL
bool wm_gizmomap_deselect_all(struct wmGizmoMap *gzmap)
Definition: wm_gizmo_map.c:855
wmGizmoMapType * WM_gizmomaptype_find(const struct wmGizmoMapType_Params *gzmap_params)
void wm_gizmomap_modal_set(wmGizmoMap *gzmap, bContext *C, wmGizmo *gz, const wmEvent *event, bool enable)
eWM_GizmoFlagMapDrawStep WM_gizmomap_drawstep_from_gizmo_group(const wmGizmoGroup *gzgroup)
Definition: wm_gizmo_map.c:288
wmGizmoMapType * WM_gizmomaptype_ensure(const struct wmGizmoMapType_Params *gzmap_params)
wmGizmo * wm_gizmomap_highlight_get(wmGizmoMap *gzmap)
bool wm_gizmomap_highlight_set(wmGizmoMap *gzmap, const bContext *C, wmGizmo *gz, int part)
Definition: wm_gizmo_map.c:983
void WM_gizmomap_tag_refresh_drawstep(wmGizmoMap *gzmap, const eWM_GizmoFlagMapDrawStep drawstep)
Definition: wm_gizmo_map.c:300
void WM_gizmoconfig_update_tag_group_type_init(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt)
void WM_gizmoconfig_update_tag_group_type_remove(wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt)
void WM_gizmoconfig_update_tag_group_remove(wmGizmoMap *gzmap)
wmKeyMap * WM_modalkeymap_find(wmKeyConfig *keyconf, const char *idname)
Definition: wm_keymap.c:914
wmKeyMap * WM_keymap_ensure(wmKeyConfig *keyconf, const char *idname, int spaceid, int regionid)
Definition: wm_keymap.c:852
void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
Definition: wm_keymap.c:985
wmKeyMap * WM_keymap_active(const wmWindowManager *wm, wmKeyMap *keymap)
Definition: wm_keymap.c:1943
wmKeyMapItem * WM_modalkeymap_add_item(wmKeyMap *km, const KeyMapItem_Params *params, int value)
Definition: wm_keymap.c:927
bool WM_keymap_remove(wmKeyConfig *keyconf, wmKeyMap *keymap)
Definition: wm_keymap.c:419
wmKeyMapItem * WM_keymap_add_item(wmKeyMap *keymap, const char *idname, const KeyMapItem_Params *params)
Definition: wm_keymap.c:505
wmKeyMap * WM_modalkeymap_ensure(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items)
Definition: wm_keymap.c:888
bool WM_keymap_uses_event_modifier(const wmKeyMap *keymap, const int event_modifier)
void WM_operator_properties_mouse_select(wmOperatorType *ot)
wmOperator * WM_operator_last_redo(const bContext *C)
void WM_tooltip_clear(bContext *C, wmWindow *win)
Definition: wm_tooltip.c:80