Gizmo: add depth bias for 3D selection
[blender.git] / source / blender / makesrna / intern / rna_wm_gizmo.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22
23 #include "DNA_screen_types.h"
24 #include "DNA_space_types.h"
25 #include "DNA_userdef_types.h"
26 #include "DNA_view3d_types.h"
27 #include "DNA_windowmanager_types.h"
28
29 #include "BLI_utildefines.h"
30
31 #include "BLT_translation.h"
32
33 #include "RNA_access.h"
34 #include "RNA_define.h"
35 #include "RNA_enum_types.h"
36
37 #include "rna_internal.h"
38
39 #include "WM_types.h"
40
41 #ifdef RNA_RUNTIME
42 /* enum definitions */
43 #endif /* RNA_RUNTIME */
44
45 #ifdef RNA_RUNTIME
46
47 #  include <assert.h>
48
49 #  include "BLI_string_utils.h"
50
51 #  include "WM_api.h"
52
53 #  include "DNA_workspace_types.h"
54
55 #  include "ED_screen.h"
56
57 #  include "UI_interface.h"
58
59 #  include "BKE_global.h"
60 #  include "BKE_idprop.h"
61 #  include "BKE_workspace.h"
62
63 #  include "MEM_guardedalloc.h"
64
65 #  ifdef WITH_PYTHON
66 #    include "BPY_extern.h"
67 #  endif
68
69 /* -------------------------------------------------------------------- */
70 /** \name Gizmo API
71  * \{ */
72
73 #  ifdef WITH_PYTHON
74 static void rna_gizmo_draw_cb(const struct bContext *C, struct wmGizmo *gz)
75 {
76   extern FunctionRNA rna_Gizmo_draw_func;
77   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
78   PointerRNA gz_ptr;
79   ParameterList list;
80   FunctionRNA *func;
81   RNA_pointer_create(NULL, gz->type->ext.srna, gz, &gz_ptr);
82   /* RNA_struct_find_function(&gz_ptr, "draw"); */
83   func = &rna_Gizmo_draw_func;
84   RNA_parameter_list_create(&list, &gz_ptr, func);
85   RNA_parameter_set_lookup(&list, "context", &C);
86   gzgroup->type->ext.call((bContext *)C, &gz_ptr, func, &list);
87   RNA_parameter_list_free(&list);
88 }
89
90 static void rna_gizmo_draw_select_cb(const struct bContext *C, struct wmGizmo *gz, int select_id)
91 {
92   extern FunctionRNA rna_Gizmo_draw_select_func;
93   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
94   PointerRNA gz_ptr;
95   ParameterList list;
96   FunctionRNA *func;
97   RNA_pointer_create(NULL, gz->type->ext.srna, gz, &gz_ptr);
98   /* RNA_struct_find_function(&gz_ptr, "draw_select"); */
99   func = &rna_Gizmo_draw_select_func;
100   RNA_parameter_list_create(&list, &gz_ptr, func);
101   RNA_parameter_set_lookup(&list, "context", &C);
102   RNA_parameter_set_lookup(&list, "select_id", &select_id);
103   gzgroup->type->ext.call((bContext *)C, &gz_ptr, func, &list);
104   RNA_parameter_list_free(&list);
105 }
106
107 static int rna_gizmo_test_select_cb(struct bContext *C, struct wmGizmo *gz, const int location[2])
108 {
109   extern FunctionRNA rna_Gizmo_test_select_func;
110   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
111   PointerRNA gz_ptr;
112   ParameterList list;
113   FunctionRNA *func;
114   RNA_pointer_create(NULL, gz->type->ext.srna, gz, &gz_ptr);
115   /* RNA_struct_find_function(&gz_ptr, "test_select"); */
116   func = &rna_Gizmo_test_select_func;
117   RNA_parameter_list_create(&list, &gz_ptr, func);
118   RNA_parameter_set_lookup(&list, "context", &C);
119   RNA_parameter_set_lookup(&list, "location", location);
120   gzgroup->type->ext.call((bContext *)C, &gz_ptr, func, &list);
121
122   void *ret;
123   RNA_parameter_get_lookup(&list, "intersect_id", &ret);
124   int intersect_id = *(int *)ret;
125
126   RNA_parameter_list_free(&list);
127   return intersect_id;
128 }
129
130 static int rna_gizmo_modal_cb(struct bContext *C,
131                               struct wmGizmo *gz,
132                               const struct wmEvent *event,
133                               eWM_GizmoFlagTweak tweak_flag)
134 {
135   extern FunctionRNA rna_Gizmo_modal_func;
136   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
137   PointerRNA gz_ptr;
138   ParameterList list;
139   FunctionRNA *func;
140   const int tweak_flag_int = tweak_flag;
141   RNA_pointer_create(NULL, gz->type->ext.srna, gz, &gz_ptr);
142   /* RNA_struct_find_function(&gz_ptr, "modal"); */
143   func = &rna_Gizmo_modal_func;
144   RNA_parameter_list_create(&list, &gz_ptr, func);
145   RNA_parameter_set_lookup(&list, "context", &C);
146   RNA_parameter_set_lookup(&list, "event", &event);
147   RNA_parameter_set_lookup(&list, "tweak", &tweak_flag_int);
148   gzgroup->type->ext.call((bContext *)C, &gz_ptr, func, &list);
149
150   void *ret;
151   RNA_parameter_get_lookup(&list, "result", &ret);
152   int ret_enum = *(int *)ret;
153
154   RNA_parameter_list_free(&list);
155   return ret_enum;
156 }
157
158 static void rna_gizmo_setup_cb(struct wmGizmo *gz)
159 {
160   extern FunctionRNA rna_Gizmo_setup_func;
161   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
162   PointerRNA gz_ptr;
163   ParameterList list;
164   FunctionRNA *func;
165   RNA_pointer_create(NULL, gz->type->ext.srna, gz, &gz_ptr);
166   /* RNA_struct_find_function(&gz_ptr, "setup"); */
167   func = &rna_Gizmo_setup_func;
168   RNA_parameter_list_create(&list, &gz_ptr, func);
169   gzgroup->type->ext.call((bContext *)NULL, &gz_ptr, func, &list);
170   RNA_parameter_list_free(&list);
171 }
172
173 static int rna_gizmo_invoke_cb(struct bContext *C, struct wmGizmo *gz, const struct wmEvent *event)
174 {
175   extern FunctionRNA rna_Gizmo_invoke_func;
176   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
177   PointerRNA gz_ptr;
178   ParameterList list;
179   FunctionRNA *func;
180   RNA_pointer_create(NULL, gz->type->ext.srna, gz, &gz_ptr);
181   /* RNA_struct_find_function(&gz_ptr, "invoke"); */
182   func = &rna_Gizmo_invoke_func;
183   RNA_parameter_list_create(&list, &gz_ptr, func);
184   RNA_parameter_set_lookup(&list, "context", &C);
185   RNA_parameter_set_lookup(&list, "event", &event);
186   gzgroup->type->ext.call((bContext *)C, &gz_ptr, func, &list);
187
188   void *ret;
189   RNA_parameter_get_lookup(&list, "result", &ret);
190   int ret_enum = *(int *)ret;
191
192   RNA_parameter_list_free(&list);
193   return ret_enum;
194 }
195
196 static void rna_gizmo_exit_cb(struct bContext *C, struct wmGizmo *gz, bool cancel)
197 {
198   extern FunctionRNA rna_Gizmo_exit_func;
199   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
200   PointerRNA gz_ptr;
201   ParameterList list;
202   FunctionRNA *func;
203   RNA_pointer_create(NULL, gz->type->ext.srna, gz, &gz_ptr);
204   /* RNA_struct_find_function(&gz_ptr, "exit"); */
205   func = &rna_Gizmo_exit_func;
206   RNA_parameter_list_create(&list, &gz_ptr, func);
207   RNA_parameter_set_lookup(&list, "context", &C);
208   {
209     int cancel_i = cancel;
210     RNA_parameter_set_lookup(&list, "cancel", &cancel_i);
211   }
212   gzgroup->type->ext.call((bContext *)C, &gz_ptr, func, &list);
213   RNA_parameter_list_free(&list);
214 }
215
216 static void rna_gizmo_select_refresh_cb(struct wmGizmo *gz)
217 {
218   extern FunctionRNA rna_Gizmo_select_refresh_func;
219   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
220   PointerRNA gz_ptr;
221   ParameterList list;
222   FunctionRNA *func;
223   RNA_pointer_create(NULL, gz->type->ext.srna, gz, &gz_ptr);
224   /* RNA_struct_find_function(&gz_ptr, "select_refresh"); */
225   func = &rna_Gizmo_select_refresh_func;
226   RNA_parameter_list_create(&list, &gz_ptr, func);
227   gzgroup->type->ext.call((bContext *)NULL, &gz_ptr, func, &list);
228   RNA_parameter_list_free(&list);
229 }
230
231 #  endif /* WITH_PYTHON */
232
233 /* just to work around 'const char *' warning and to ensure this is a python op */
234 static void rna_Gizmo_bl_idname_set(PointerRNA *ptr, const char *value)
235 {
236   wmGizmo *data = ptr->data;
237   char *str = (char *)data->type->idname;
238   if (!str[0]) {
239     BLI_strncpy(str, value, MAX_NAME); /* utf8 already ensured */
240   }
241   else {
242     assert(!"setting the bl_idname on a non-builtin operator");
243   }
244 }
245
246 static wmGizmo *rna_GizmoProperties_find_operator(PointerRNA *ptr)
247 {
248 #  if 0
249   wmWindowManager *wm = ptr->id.data;
250 #  endif
251
252   /* We could try workaruond this lookup, but not trivial. */
253   for (bScreen *screen = G_MAIN->screens.first; screen; screen = screen->id.next) {
254     IDProperty *properties = ptr->data;
255     for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
256       for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {
257         if (ar->gizmo_map) {
258           wmGizmoMap *gzmap = ar->gizmo_map;
259           for (wmGizmoGroup *gzgroup = WM_gizmomap_group_list(gzmap)->first; gzgroup;
260                gzgroup = gzgroup->next) {
261             for (wmGizmo *gz = gzgroup->gizmos.first; gz; gz = gz->next) {
262               if (gz->properties == properties) {
263                 return gz;
264               }
265             }
266           }
267         }
268       }
269     }
270   }
271   return NULL;
272 }
273
274 static StructRNA *rna_GizmoProperties_refine(PointerRNA *ptr)
275 {
276   wmGizmo *gz = rna_GizmoProperties_find_operator(ptr);
277
278   if (gz)
279     return gz->type->srna;
280   else
281     return ptr->type;
282 }
283
284 static IDProperty *rna_GizmoProperties_idprops(PointerRNA *ptr, bool create)
285 {
286   if (create && !ptr->data) {
287     IDPropertyTemplate val = {0};
288     ptr->data = IDP_New(IDP_GROUP, &val, "RNA_GizmoProperties group");
289   }
290
291   return ptr->data;
292 }
293
294 static PointerRNA rna_Gizmo_properties_get(PointerRNA *ptr)
295 {
296   wmGizmo *gz = ptr->data;
297   return rna_pointer_inherit_refine(ptr, gz->type->srna, gz->properties);
298 }
299
300 /* wmGizmo.float */
301 #  define RNA_GIZMO_GENERIC_FLOAT_RW_DEF(func_id, member_id) \
302     static float rna_Gizmo_##func_id##_get(PointerRNA *ptr) \
303     { \
304       wmGizmo *gz = ptr->data; \
305       return gz->member_id; \
306     } \
307     static void rna_Gizmo_##func_id##_set(PointerRNA *ptr, float value) \
308     { \
309       wmGizmo *gz = ptr->data; \
310       gz->member_id = value; \
311     }
312 #  define RNA_GIZMO_GENERIC_FLOAT_ARRAY_INDEX_RW_DEF(func_id, member_id, index) \
313     static float rna_Gizmo_##func_id##_get(PointerRNA *ptr) \
314     { \
315       wmGizmo *gz = ptr->data; \
316       return gz->member_id[index]; \
317     } \
318     static void rna_Gizmo_##func_id##_set(PointerRNA *ptr, float value) \
319     { \
320       wmGizmo *gz = ptr->data; \
321       gz->member_id[index] = value; \
322     }
323 /* wmGizmo.float[len] */
324 #  define RNA_GIZMO_GENERIC_FLOAT_ARRAY_RW_DEF(func_id, member_id, len) \
325     static void rna_Gizmo_##func_id##_get(PointerRNA *ptr, float value[len]) \
326     { \
327       wmGizmo *gz = ptr->data; \
328       memcpy(value, gz->member_id, sizeof(float[len])); \
329     } \
330     static void rna_Gizmo_##func_id##_set(PointerRNA *ptr, const float value[len]) \
331     { \
332       wmGizmo *gz = ptr->data; \
333       memcpy(gz->member_id, value, sizeof(float[len])); \
334     }
335
336 /* wmGizmo.flag */
337 #  define RNA_GIZMO_GENERIC_FLAG_RW_DEF(func_id, member_id, flag_value) \
338     static bool rna_Gizmo_##func_id##_get(PointerRNA *ptr) \
339     { \
340       wmGizmo *gz = ptr->data; \
341       return (gz->member_id & flag_value) != 0; \
342     } \
343     static void rna_Gizmo_##func_id##_set(PointerRNA *ptr, bool value) \
344     { \
345       wmGizmo *gz = ptr->data; \
346       SET_FLAG_FROM_TEST(gz->member_id, value, flag_value); \
347     }
348
349 /* wmGizmo.flag (negative) */
350 #  define RNA_GIZMO_GENERIC_FLAG_NEG_RW_DEF(func_id, member_id, flag_value) \
351     static bool rna_Gizmo_##func_id##_get(PointerRNA *ptr) \
352     { \
353       wmGizmo *gz = ptr->data; \
354       return (gz->member_id & flag_value) == 0; \
355     } \
356     static void rna_Gizmo_##func_id##_set(PointerRNA *ptr, bool value) \
357     { \
358       wmGizmo *gz = ptr->data; \
359       SET_FLAG_FROM_TEST(gz->member_id, !value, flag_value); \
360     }
361
362 #  define RNA_GIZMO_FLAG_RO_DEF(func_id, member_id, flag_value) \
363     static int rna_Gizmo_##func_id##_get(PointerRNA *ptr) \
364     { \
365       wmGizmo *gz = ptr->data; \
366       return (gz->member_id & flag_value) != 0; \
367     }
368
369 RNA_GIZMO_GENERIC_FLOAT_ARRAY_RW_DEF(color, color, 3);
370 RNA_GIZMO_GENERIC_FLOAT_ARRAY_RW_DEF(color_hi, color_hi, 3);
371
372 RNA_GIZMO_GENERIC_FLOAT_ARRAY_INDEX_RW_DEF(alpha, color, 3);
373 RNA_GIZMO_GENERIC_FLOAT_ARRAY_INDEX_RW_DEF(alpha_hi, color_hi, 3);
374
375 RNA_GIZMO_GENERIC_FLOAT_ARRAY_RW_DEF(matrix_space, matrix_space, 16);
376 RNA_GIZMO_GENERIC_FLOAT_ARRAY_RW_DEF(matrix_basis, matrix_basis, 16);
377 RNA_GIZMO_GENERIC_FLOAT_ARRAY_RW_DEF(matrix_offset, matrix_offset, 16);
378
379 static void rna_Gizmo_matrix_world_get(PointerRNA *ptr, float value[16])
380 {
381   wmGizmo *gz = ptr->data;
382   WM_gizmo_calc_matrix_final(gz, (float(*)[4])value);
383 }
384
385 RNA_GIZMO_GENERIC_FLOAT_RW_DEF(scale_basis, scale_basis);
386 RNA_GIZMO_GENERIC_FLOAT_RW_DEF(line_width, line_width);
387 RNA_GIZMO_GENERIC_FLOAT_RW_DEF(select_bias, select_bias);
388
389 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_use_draw_hover, flag, WM_GIZMO_DRAW_HOVER);
390 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_use_draw_modal, flag, WM_GIZMO_DRAW_MODAL);
391 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_use_draw_value, flag, WM_GIZMO_DRAW_VALUE);
392 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_use_draw_offset_scale, flag, WM_GIZMO_DRAW_OFFSET_SCALE);
393 RNA_GIZMO_GENERIC_FLAG_NEG_RW_DEF(flag_use_draw_scale, flag, WM_GIZMO_DRAW_OFFSET_SCALE);
394 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_hide, flag, WM_GIZMO_HIDDEN);
395 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_hide_select, flag, WM_GIZMO_HIDDEN_SELECT);
396 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_use_grab_cursor, flag, WM_GIZMO_MOVE_CURSOR);
397 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_use_select_background, flag, WM_GIZMO_SELECT_BACKGROUND);
398 RNA_GIZMO_GENERIC_FLAG_RW_DEF(flag_use_operator_tool_properties,
399                               flag,
400                               WM_GIZMO_OPERATOR_TOOL_INIT);
401
402 /* wmGizmo.state */
403 RNA_GIZMO_FLAG_RO_DEF(state_is_highlight, state, WM_GIZMO_STATE_HIGHLIGHT);
404 RNA_GIZMO_FLAG_RO_DEF(state_is_modal, state, WM_GIZMO_STATE_MODAL);
405 RNA_GIZMO_FLAG_RO_DEF(state_select, state, WM_GIZMO_STATE_SELECT);
406
407 static void rna_Gizmo_state_select_set(struct PointerRNA *ptr, bool value)
408 {
409   wmGizmo *gz = ptr->data;
410   wmGizmoGroup *gzgroup = gz->parent_gzgroup;
411   WM_gizmo_select_set(gzgroup->parent_gzmap, gz, value);
412 }
413
414 static PointerRNA rna_Gizmo_group_get(PointerRNA *ptr)
415 {
416   wmGizmo *gz = ptr->data;
417   return rna_pointer_inherit_refine(ptr, &RNA_GizmoGroup, gz->parent_gzgroup);
418 }
419
420 #  ifdef WITH_PYTHON
421
422 static void rna_Gizmo_unregister(struct Main *bmain, StructRNA *type);
423 void BPY_RNA_gizmo_wrapper(wmGizmoType *gzgt, void *userdata);
424
425 static StructRNA *rna_Gizmo_register(Main *bmain,
426                                      ReportList *reports,
427                                      void *data,
428                                      const char *identifier,
429                                      StructValidateFunc validate,
430                                      StructCallbackFunc call,
431                                      StructFreeFunc free)
432 {
433   struct {
434     char idname[MAX_NAME];
435   } temp_buffers;
436
437   wmGizmoType dummygt = {NULL};
438   wmGizmo dummymnp = {NULL};
439   PointerRNA mnp_ptr;
440
441   /* Two sets of functions. */
442   int have_function[8];
443
444   /* setup dummy gizmo & gizmo type to store static properties in */
445   dummymnp.type = &dummygt;
446   dummygt.idname = temp_buffers.idname;
447   RNA_pointer_create(NULL, &RNA_Gizmo, &dummymnp, &mnp_ptr);
448
449   /* Clear so we can detect if it's left unset. */
450   temp_buffers.idname[0] = '\0';
451
452   /* validate the python class */
453   if (validate(&mnp_ptr, data, have_function) != 0)
454     return NULL;
455
456   if (strlen(identifier) >= sizeof(temp_buffers.idname)) {
457     BKE_reportf(reports,
458                 RPT_ERROR,
459                 "Registering gizmo class: '%s' is too long, maximum length is %d",
460                 identifier,
461                 (int)sizeof(temp_buffers.idname));
462     return NULL;
463   }
464
465   /* check if we have registered this gizmo type before, and remove it */
466   {
467     const wmGizmoType *gzt = WM_gizmotype_find(dummygt.idname, true);
468     if (gzt && gzt->ext.srna) {
469       rna_Gizmo_unregister(bmain, gzt->ext.srna);
470     }
471   }
472   if (!RNA_struct_available_or_report(reports, dummygt.idname)) {
473     return NULL;
474   }
475
476   { /* allocate the idname */
477     /* For multiple strings see GizmoGroup. */
478     dummygt.idname = BLI_strdup(temp_buffers.idname);
479   }
480
481   /* create a new gizmo type */
482   dummygt.ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, dummygt.idname, &RNA_Gizmo);
483   /* gizmo properties are registered separately */
484   RNA_def_struct_flag(dummygt.ext.srna, STRUCT_NO_IDPROPERTIES);
485   dummygt.ext.data = data;
486   dummygt.ext.call = call;
487   dummygt.ext.free = free;
488
489   {
490     int i = 0;
491     dummygt.draw = (have_function[i++]) ? rna_gizmo_draw_cb : NULL;
492     dummygt.draw_select = (have_function[i++]) ? rna_gizmo_draw_select_cb : NULL;
493     dummygt.test_select = (have_function[i++]) ? rna_gizmo_test_select_cb : NULL;
494     dummygt.modal = (have_function[i++]) ? rna_gizmo_modal_cb : NULL;
495     //      dummygt.property_update = (have_function[i++]) ? rna_gizmo_property_update : NULL;
496     //      dummygt.position_get = (have_function[i++]) ? rna_gizmo_position_get : NULL;
497     dummygt.setup = (have_function[i++]) ? rna_gizmo_setup_cb : NULL;
498     dummygt.invoke = (have_function[i++]) ? rna_gizmo_invoke_cb : NULL;
499     dummygt.exit = (have_function[i++]) ? rna_gizmo_exit_cb : NULL;
500     dummygt.select_refresh = (have_function[i++]) ? rna_gizmo_select_refresh_cb : NULL;
501
502     BLI_assert(i == ARRAY_SIZE(have_function));
503   }
504
505   WM_gizmotype_append_ptr(BPY_RNA_gizmo_wrapper, (void *)&dummygt);
506
507   /* update while blender is running */
508   WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
509
510   return dummygt.ext.srna;
511 }
512
513 static void rna_Gizmo_unregister(struct Main *bmain, StructRNA *type)
514 {
515   wmGizmoType *gzt = RNA_struct_blender_type_get(type);
516
517   if (!gzt) {
518     return;
519   }
520
521   RNA_struct_free_extension(type, &gzt->ext);
522   RNA_struct_free(&BLENDER_RNA, type);
523
524   WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
525
526   WM_gizmotype_remove_ptr(NULL, bmain, gzt);
527 }
528
529 static void **rna_Gizmo_instance(PointerRNA *ptr)
530 {
531   wmGizmo *gz = ptr->data;
532   return &gz->py_instance;
533 }
534
535 #  endif /* WITH_PYTHON */
536
537 static StructRNA *rna_Gizmo_refine(PointerRNA *mnp_ptr)
538 {
539   wmGizmo *gz = mnp_ptr->data;
540   return (gz->type && gz->type->ext.srna) ? gz->type->ext.srna : &RNA_Gizmo;
541 }
542
543 /** \} */
544
545 /** \name Gizmo Group API
546  * \{ */
547
548 static wmGizmoGroupType *rna_GizmoGroupProperties_find_gizmo_group_type(PointerRNA *ptr)
549 {
550   IDProperty *properties = (IDProperty *)ptr->data;
551   wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(properties->name, false);
552   return gzgt;
553 }
554
555 static StructRNA *rna_GizmoGroupProperties_refine(PointerRNA *ptr)
556 {
557   wmGizmoGroupType *gzgt = rna_GizmoGroupProperties_find_gizmo_group_type(ptr);
558
559   if (gzgt)
560     return gzgt->srna;
561   else
562     return ptr->type;
563 }
564
565 static IDProperty *rna_GizmoGroupProperties_idprops(PointerRNA *ptr, bool create)
566 {
567   if (create && !ptr->data) {
568     IDPropertyTemplate val = {0};
569     ptr->data = IDP_New(IDP_GROUP, &val, "RNA_GizmoGroupProperties group");
570   }
571
572   return ptr->data;
573 }
574
575 static wmGizmo *rna_GizmoGroup_gizmo_new(wmGizmoGroup *gzgroup,
576                                          ReportList *reports,
577                                          const char *idname)
578 {
579   const wmGizmoType *gzt = WM_gizmotype_find(idname, true);
580   if (gzt == NULL) {
581     BKE_reportf(reports, RPT_ERROR, "GizmoType '%s' not known", idname);
582     return NULL;
583   }
584   wmGizmo *gz = WM_gizmo_new_ptr(gzt, gzgroup, NULL);
585   return gz;
586 }
587
588 static void rna_GizmoGroup_gizmo_remove(wmGizmoGroup *gzgroup, bContext *C, wmGizmo *gz)
589 {
590   WM_gizmo_unlink(&gzgroup->gizmos, gzgroup->parent_gzmap, gz, C);
591 }
592
593 static void rna_GizmoGroup_gizmo_clear(wmGizmoGroup *gzgroup, bContext *C)
594 {
595   while (gzgroup->gizmos.first) {
596     WM_gizmo_unlink(&gzgroup->gizmos, gzgroup->parent_gzmap, gzgroup->gizmos.first, C);
597   }
598 }
599
600 static void rna_GizmoGroup_name_get(PointerRNA *ptr, char *value)
601 {
602   wmGizmoGroup *gzgroup = ptr->data;
603   strcpy(value, gzgroup->type->name);
604 }
605
606 static int rna_GizmoGroup_name_length(PointerRNA *ptr)
607 {
608   wmGizmoGroup *gzgroup = ptr->data;
609   return strlen(gzgroup->type->name);
610 }
611
612 /* just to work around 'const char *' warning and to ensure this is a python op */
613 static void rna_GizmoGroup_bl_idname_set(PointerRNA *ptr, const char *value)
614 {
615   wmGizmoGroup *data = ptr->data;
616   char *str = (char *)data->type->idname;
617   if (!str[0])
618     BLI_strncpy(str, value, MAX_NAME); /* utf8 already ensured */
619   else
620     assert(!"setting the bl_idname on a non-builtin operator");
621 }
622
623 static void rna_GizmoGroup_bl_label_set(PointerRNA *ptr, const char *value)
624 {
625   wmGizmoGroup *data = ptr->data;
626   char *str = (char *)data->type->name;
627   if (!str[0])
628     BLI_strncpy(str, value, MAX_NAME); /* utf8 already ensured */
629   else
630     assert(!"setting the bl_label on a non-builtin operator");
631 }
632
633 static bool rna_GizmoGroup_has_reports_get(PointerRNA *ptr)
634 {
635   wmGizmoGroup *gzgroup = ptr->data;
636   return (gzgroup->reports && gzgroup->reports->list.first);
637 }
638
639 #  ifdef WITH_PYTHON
640
641 static bool rna_gizmogroup_poll_cb(const bContext *C, wmGizmoGroupType *gzgt)
642 {
643
644   extern FunctionRNA rna_GizmoGroup_poll_func;
645
646   PointerRNA ptr;
647   ParameterList list;
648   FunctionRNA *func;
649   void *ret;
650   bool visible;
651
652   RNA_pointer_create(NULL, gzgt->ext.srna, NULL, &ptr); /* dummy */
653   func = &rna_GizmoGroup_poll_func; /* RNA_struct_find_function(&ptr, "poll"); */
654
655   RNA_parameter_list_create(&list, &ptr, func);
656   RNA_parameter_set_lookup(&list, "context", &C);
657   gzgt->ext.call((bContext *)C, &ptr, func, &list);
658
659   RNA_parameter_get_lookup(&list, "visible", &ret);
660   visible = *(bool *)ret;
661
662   RNA_parameter_list_free(&list);
663
664   return visible;
665 }
666
667 static void rna_gizmogroup_setup_cb(const bContext *C, wmGizmoGroup *gzgroup)
668 {
669   extern FunctionRNA rna_GizmoGroup_setup_func;
670
671   PointerRNA gzgroup_ptr;
672   ParameterList list;
673   FunctionRNA *func;
674
675   RNA_pointer_create(NULL, gzgroup->type->ext.srna, gzgroup, &gzgroup_ptr);
676   func = &rna_GizmoGroup_setup_func; /* RNA_struct_find_function(&wgroupr, "setup"); */
677
678   RNA_parameter_list_create(&list, &gzgroup_ptr, func);
679   RNA_parameter_set_lookup(&list, "context", &C);
680   gzgroup->type->ext.call((bContext *)C, &gzgroup_ptr, func, &list);
681
682   RNA_parameter_list_free(&list);
683 }
684
685 static wmKeyMap *rna_gizmogroup_setup_keymap_cb(const wmGizmoGroupType *gzgt, wmKeyConfig *config)
686 {
687   extern FunctionRNA rna_GizmoGroup_setup_keymap_func;
688   void *ret;
689
690   PointerRNA ptr;
691   ParameterList list;
692   FunctionRNA *func;
693
694   RNA_pointer_create(NULL, gzgt->ext.srna, NULL, &ptr); /* dummy */
695   func =
696       &rna_GizmoGroup_setup_keymap_func; /* RNA_struct_find_function(&wgroupr, "setup_keymap"); */
697
698   RNA_parameter_list_create(&list, &ptr, func);
699   RNA_parameter_set_lookup(&list, "keyconfig", &config);
700   gzgt->ext.call(NULL, &ptr, func, &list);
701
702   RNA_parameter_get_lookup(&list, "keymap", &ret);
703   wmKeyMap *keymap = *(wmKeyMap **)ret;
704
705   RNA_parameter_list_free(&list);
706
707   return keymap;
708 }
709
710 static void rna_gizmogroup_refresh_cb(const bContext *C, wmGizmoGroup *gzgroup)
711 {
712   extern FunctionRNA rna_GizmoGroup_refresh_func;
713
714   PointerRNA gzgroup_ptr;
715   ParameterList list;
716   FunctionRNA *func;
717
718   RNA_pointer_create(NULL, gzgroup->type->ext.srna, gzgroup, &gzgroup_ptr);
719   func = &rna_GizmoGroup_refresh_func; /* RNA_struct_find_function(&wgroupr, "refresh"); */
720
721   RNA_parameter_list_create(&list, &gzgroup_ptr, func);
722   RNA_parameter_set_lookup(&list, "context", &C);
723   gzgroup->type->ext.call((bContext *)C, &gzgroup_ptr, func, &list);
724
725   RNA_parameter_list_free(&list);
726 }
727
728 static void rna_gizmogroup_draw_prepare_cb(const bContext *C, wmGizmoGroup *gzgroup)
729 {
730   extern FunctionRNA rna_GizmoGroup_draw_prepare_func;
731
732   PointerRNA gzgroup_ptr;
733   ParameterList list;
734   FunctionRNA *func;
735
736   RNA_pointer_create(NULL, gzgroup->type->ext.srna, gzgroup, &gzgroup_ptr);
737   func =
738       &rna_GizmoGroup_draw_prepare_func; /* RNA_struct_find_function(&wgroupr, "draw_prepare"); */
739
740   RNA_parameter_list_create(&list, &gzgroup_ptr, func);
741   RNA_parameter_set_lookup(&list, "context", &C);
742   gzgroup->type->ext.call((bContext *)C, &gzgroup_ptr, func, &list);
743
744   RNA_parameter_list_free(&list);
745 }
746
747 static void rna_gizmogroup_invoke_prepare_cb(const bContext *C, wmGizmoGroup *gzgroup, wmGizmo *gz)
748 {
749   extern FunctionRNA rna_GizmoGroup_invoke_prepare_func;
750
751   PointerRNA gzgroup_ptr;
752   ParameterList list;
753   FunctionRNA *func;
754
755   RNA_pointer_create(NULL, gzgroup->type->ext.srna, gzgroup, &gzgroup_ptr);
756   /* RNA_struct_find_function(&wgroupr, "invoke_prepare"); */
757   func = &rna_GizmoGroup_invoke_prepare_func;
758
759   RNA_parameter_list_create(&list, &gzgroup_ptr, func);
760   RNA_parameter_set_lookup(&list, "context", &C);
761   RNA_parameter_set_lookup(&list, "gizmo", &gz);
762   gzgroup->type->ext.call((bContext *)C, &gzgroup_ptr, func, &list);
763
764   RNA_parameter_list_free(&list);
765 }
766
767 void BPY_RNA_gizmogroup_wrapper(wmGizmoGroupType *gzgt, void *userdata);
768 static void rna_GizmoGroup_unregister(struct Main *bmain, StructRNA *type);
769
770 static StructRNA *rna_GizmoGroup_register(Main *bmain,
771                                           ReportList *reports,
772                                           void *data,
773                                           const char *identifier,
774                                           StructValidateFunc validate,
775                                           StructCallbackFunc call,
776                                           StructFreeFunc free)
777 {
778   struct {
779     char name[MAX_NAME];
780     char idname[MAX_NAME];
781   } temp_buffers;
782
783   wmGizmoGroupType dummywgt = {NULL};
784   wmGizmoGroup dummywg = {NULL};
785   PointerRNA wgptr;
786
787   /* Two sets of functions. */
788   int have_function[6];
789
790   /* setup dummy gizmogroup & gizmogroup type to store static properties in */
791   dummywg.type = &dummywgt;
792   dummywgt.name = temp_buffers.name;
793   dummywgt.idname = temp_buffers.idname;
794
795   RNA_pointer_create(NULL, &RNA_GizmoGroup, &dummywg, &wgptr);
796
797   /* Clear so we can detect if it's left unset. */
798   temp_buffers.idname[0] = temp_buffers.name[0] = '\0';
799
800   /* validate the python class */
801   if (validate(&wgptr, data, have_function) != 0)
802     return NULL;
803
804   if (strlen(identifier) >= sizeof(temp_buffers.idname)) {
805     BKE_reportf(reports,
806                 RPT_ERROR,
807                 "Registering gizmogroup class: '%s' is too long, maximum length is %d",
808                 identifier,
809                 (int)sizeof(temp_buffers.idname));
810     return NULL;
811   }
812
813   /* check if the area supports widgets */
814   const struct wmGizmoMapType_Params wmap_params = {
815       .spaceid = dummywgt.gzmap_params.spaceid,
816       .regionid = dummywgt.gzmap_params.regionid,
817   };
818
819   wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&wmap_params);
820   if (gzmap_type == NULL) {
821     BKE_report(reports, RPT_ERROR, "Area type does not support gizmos");
822     return NULL;
823   }
824
825   /* check if we have registered this gizmogroup type before, and remove it */
826   {
827     wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(dummywgt.idname, true);
828     if (gzgt && gzgt->ext.srna) {
829       rna_GizmoGroup_unregister(bmain, gzgt->ext.srna);
830     }
831   }
832   if (!RNA_struct_available_or_report(reports, dummywgt.idname)) {
833     return NULL;
834   }
835
836   { /* allocate the idname */
837     const char *strings[] = {
838         temp_buffers.idname,
839         temp_buffers.name,
840     };
841     char *strings_table[ARRAY_SIZE(strings)];
842     BLI_string_join_array_by_sep_char_with_tableN(
843         '\0', strings_table, strings, ARRAY_SIZE(strings));
844
845     dummywgt.idname = strings_table[0]; /* allocated string stored here */
846     dummywgt.name = strings_table[1];
847     BLI_assert(ARRAY_SIZE(strings) == 2);
848   }
849
850   /* create a new gizmogroup type */
851   dummywgt.ext.srna = RNA_def_struct_ptr(&BLENDER_RNA, dummywgt.idname, &RNA_GizmoGroup);
852   RNA_def_struct_flag(
853       dummywgt.ext.srna,
854       STRUCT_NO_IDPROPERTIES); /* gizmogroup properties are registered separately */
855   dummywgt.ext.data = data;
856   dummywgt.ext.call = call;
857   dummywgt.ext.free = free;
858
859   /* We used to register widget group types like this, now we do it similar to
860    * operator types. Thus we should be able to do the same as operator types now. */
861   dummywgt.poll = (have_function[0]) ? rna_gizmogroup_poll_cb : NULL;
862   dummywgt.setup_keymap = (have_function[1]) ? rna_gizmogroup_setup_keymap_cb : NULL;
863   dummywgt.setup = (have_function[2]) ? rna_gizmogroup_setup_cb : NULL;
864   dummywgt.refresh = (have_function[3]) ? rna_gizmogroup_refresh_cb : NULL;
865   dummywgt.draw_prepare = (have_function[4]) ? rna_gizmogroup_draw_prepare_cb : NULL;
866   dummywgt.invoke_prepare = (have_function[5]) ? rna_gizmogroup_invoke_prepare_cb : NULL;
867
868   wmGizmoGroupType *gzgt = WM_gizmogrouptype_append_ptr(BPY_RNA_gizmogroup_wrapper,
869                                                         (void *)&dummywgt);
870
871   {
872     const char *owner_id = RNA_struct_state_owner_get();
873     if (owner_id) {
874       BLI_strncpy(gzgt->owner_id, owner_id, sizeof(gzgt->owner_id));
875     }
876   }
877
878   if (gzgt->flag & WM_GIZMOGROUPTYPE_PERSISTENT) {
879     WM_gizmo_group_type_add_ptr_ex(gzgt, gzmap_type);
880
881     /* update while blender is running */
882     WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
883   }
884
885   return dummywgt.ext.srna;
886 }
887
888 static void rna_GizmoGroup_unregister(struct Main *bmain, StructRNA *type)
889 {
890   wmGizmoGroupType *gzgt = RNA_struct_blender_type_get(type);
891
892   if (!gzgt)
893     return;
894
895   RNA_struct_free_extension(type, &gzgt->ext);
896   RNA_struct_free(&BLENDER_RNA, type);
897
898   WM_main_add_notifier(NC_SCREEN | NA_EDITED, NULL);
899
900   WM_gizmo_group_type_remove_ptr(bmain, gzgt);
901 }
902
903 static void **rna_GizmoGroup_instance(PointerRNA *ptr)
904 {
905   wmGizmoGroup *gzgroup = ptr->data;
906   return &gzgroup->py_instance;
907 }
908
909 #  endif /* WITH_PYTHON */
910
911 static StructRNA *rna_GizmoGroup_refine(PointerRNA *gzgroup_ptr)
912 {
913   wmGizmoGroup *gzgroup = gzgroup_ptr->data;
914   return (gzgroup->type && gzgroup->type->ext.srna) ? gzgroup->type->ext.srna : &RNA_GizmoGroup;
915 }
916
917 static void rna_GizmoGroup_gizmos_begin(CollectionPropertyIterator *iter, PointerRNA *gzgroup_ptr)
918 {
919   wmGizmoGroup *gzgroup = gzgroup_ptr->data;
920   rna_iterator_listbase_begin(iter, &gzgroup->gizmos, NULL);
921 }
922
923 /** \} */
924
925 #else /* RNA_RUNTIME */
926
927 /* GizmoGroup.gizmos */
928 static void rna_def_gizmos(BlenderRNA *brna, PropertyRNA *cprop)
929 {
930   StructRNA *srna;
931
932   FunctionRNA *func;
933   PropertyRNA *parm;
934
935   RNA_def_property_srna(cprop, "Gizmos");
936   srna = RNA_def_struct(brna, "Gizmos", NULL);
937   RNA_def_struct_sdna(srna, "wmGizmoGroup");
938   RNA_def_struct_ui_text(srna, "Gizmos", "Collection of gizmos");
939
940   func = RNA_def_function(srna, "new", "rna_GizmoGroup_gizmo_new");
941   RNA_def_function_ui_description(func, "Add gizmo");
942   RNA_def_function_flag(func, FUNC_USE_REPORTS);
943   parm = RNA_def_string(func, "type", "Type", 0, "", "Gizmo identifier"); /* optional */
944   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
945   parm = RNA_def_pointer(func, "gizmo", "Gizmo", "", "New gizmo");
946   RNA_def_function_return(func, parm);
947
948   func = RNA_def_function(srna, "remove", "rna_GizmoGroup_gizmo_remove");
949   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
950   RNA_def_function_ui_description(func, "Delete gizmo");
951   parm = RNA_def_pointer(func, "gizmo", "Gizmo", "", "New gizmo");
952   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
953   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
954
955   func = RNA_def_function(srna, "clear", "rna_GizmoGroup_gizmo_clear");
956   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
957   RNA_def_function_ui_description(func, "Delete all gizmos");
958 }
959
960 static void rna_def_gizmo(BlenderRNA *brna, PropertyRNA *cprop)
961 {
962   StructRNA *srna;
963   PropertyRNA *prop;
964
965   FunctionRNA *func;
966   PropertyRNA *parm;
967
968   RNA_def_property_srna(cprop, "Gizmo");
969   srna = RNA_def_struct(brna, "Gizmo", NULL);
970   RNA_def_struct_sdna(srna, "wmGizmo");
971   RNA_def_struct_ui_text(srna, "Gizmo", "Collection of gizmos");
972   RNA_def_struct_refine_func(srna, "rna_Gizmo_refine");
973
974 #  ifdef WITH_PYTHON
975   RNA_def_struct_register_funcs(
976       srna, "rna_Gizmo_register", "rna_Gizmo_unregister", "rna_Gizmo_instance");
977 #  endif
978   RNA_def_struct_translation_context(srna, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
979
980   prop = RNA_def_property(srna, "properties", PROP_POINTER, PROP_NONE);
981   RNA_def_property_flag(prop, PROP_NEVER_NULL);
982   RNA_def_property_struct_type(prop, "GizmoProperties");
983   RNA_def_property_ui_text(prop, "Properties", "");
984   RNA_def_property_pointer_funcs(prop, "rna_Gizmo_properties_get", NULL, NULL, NULL);
985
986   /* -------------------------------------------------------------------- */
987   /* Registerable Variables */
988
989   RNA_define_verify_sdna(0); /* not in sdna */
990
991   prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
992   RNA_def_property_string_sdna(prop, NULL, "type->idname");
993   RNA_def_property_string_maxlength(prop, MAX_NAME);
994   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Gizmo_bl_idname_set");
995   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
996   RNA_def_property_flag(prop, PROP_REGISTER);
997
998   RNA_define_verify_sdna(1); /* not in sdna */
999
1000   /* wmGizmo.draw */
1001   func = RNA_def_function(srna, "draw", NULL);
1002   RNA_def_function_ui_description(func, "");
1003   RNA_def_function_flag(func, FUNC_REGISTER);
1004   parm = RNA_def_pointer(func, "context", "Context", "", "");
1005   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1006
1007   /* wmGizmo.draw_select */
1008   func = RNA_def_function(srna, "draw_select", NULL);
1009   RNA_def_function_ui_description(func, "");
1010   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
1011   parm = RNA_def_pointer(func, "context", "Context", "", "");
1012   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1013   parm = RNA_def_int(func, "select_id", 0, 0, INT_MAX, "", "", 0, INT_MAX);
1014
1015   /* wmGizmo.test_select */
1016   func = RNA_def_function(srna, "test_select", NULL);
1017   RNA_def_function_ui_description(func, "");
1018   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
1019   parm = RNA_def_pointer(func, "context", "Context", "", "");
1020   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1021   parm = RNA_def_int_array(func,
1022                            "location",
1023                            2,
1024                            NULL,
1025                            INT_MIN,
1026                            INT_MAX,
1027                            "Location",
1028                            "Region coordinates",
1029                            INT_MIN,
1030                            INT_MAX);
1031   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1032   parm = RNA_def_int(
1033       func, "intersect_id", -1, -1, INT_MAX, "", "Use -1 to skip this gizmo", -1, INT_MAX);
1034   RNA_def_function_return(func, parm);
1035
1036   /* wmGizmo.handler */
1037   static EnumPropertyItem tweak_actions[] = {
1038       {WM_GIZMO_TWEAK_PRECISE, "PRECISE", 0, "Precise", ""},
1039       {WM_GIZMO_TWEAK_SNAP, "SNAP", 0, "Snap", ""},
1040       {0, NULL, 0, NULL, NULL},
1041   };
1042   func = RNA_def_function(srna, "modal", NULL);
1043   RNA_def_function_ui_description(func, "");
1044   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
1045   parm = RNA_def_pointer(func, "context", "Context", "", "");
1046   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1047   parm = RNA_def_pointer(func, "event", "Event", "", "");
1048   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1049   /* TODO, shuold be a enum-flag */
1050   parm = RNA_def_enum_flag(func, "tweak", tweak_actions, 0, "Tweak", "");
1051   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1052   parm = RNA_def_enum_flag(
1053       func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
1054   RNA_def_function_return(func, parm);
1055   /* wmGizmo.property_update */
1056   /* TODO */
1057
1058   /* wmGizmo.setup */
1059   func = RNA_def_function(srna, "setup", NULL);
1060   RNA_def_function_ui_description(func, "");
1061   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
1062
1063   /* wmGizmo.invoke */
1064   func = RNA_def_function(srna, "invoke", NULL);
1065   RNA_def_function_ui_description(func, "");
1066   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
1067   parm = RNA_def_pointer(func, "context", "Context", "", "");
1068   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1069   parm = RNA_def_pointer(func, "event", "Event", "", "");
1070   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1071   parm = RNA_def_enum_flag(
1072       func, "result", rna_enum_operator_return_items, OPERATOR_CANCELLED, "result", "");
1073   RNA_def_function_return(func, parm);
1074
1075   /* wmGizmo.exit */
1076   func = RNA_def_function(srna, "exit", NULL);
1077   RNA_def_function_ui_description(func, "");
1078   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
1079   parm = RNA_def_pointer(func, "context", "Context", "", "");
1080   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1081   parm = RNA_def_boolean(func, "cancel", 0, "Cancel, otherwise confirm", "");
1082   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1083
1084   /* wmGizmo.cursor_get */
1085   /* TODO */
1086
1087   /* wmGizmo.select_refresh */
1088   func = RNA_def_function(srna, "select_refresh", NULL);
1089   RNA_def_function_ui_description(func, "");
1090   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL | FUNC_ALLOW_WRITE);
1091
1092   /* -------------------------------------------------------------------- */
1093   /* Instance Variables */
1094
1095   prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
1096   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1097   RNA_def_property_struct_type(prop, "GizmoGroup");
1098   RNA_def_property_pointer_funcs(prop, "rna_Gizmo_group_get", NULL, NULL, NULL);
1099   RNA_def_property_ui_text(prop, "", "Gizmo group this gizmo is a member of");
1100
1101   /* Color & Alpha */
1102   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
1103   RNA_def_property_array(prop, 3);
1104   RNA_def_property_float_funcs(prop, "rna_Gizmo_color_get", "rna_Gizmo_color_set", NULL);
1105
1106   prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
1107   RNA_def_property_ui_text(prop, "Alpha", "");
1108   RNA_def_property_float_funcs(prop, "rna_Gizmo_alpha_get", "rna_Gizmo_alpha_set", NULL);
1109   RNA_def_property_range(prop, 0.0f, 1.0f);
1110   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1111
1112   /* Color & Alpha (highlight) */
1113   prop = RNA_def_property(srna, "color_highlight", PROP_FLOAT, PROP_COLOR);
1114   RNA_def_property_array(prop, 3);
1115   RNA_def_property_float_funcs(prop, "rna_Gizmo_color_hi_get", "rna_Gizmo_color_hi_set", NULL);
1116
1117   prop = RNA_def_property(srna, "alpha_highlight", PROP_FLOAT, PROP_NONE);
1118   RNA_def_property_ui_text(prop, "Alpha", "");
1119   RNA_def_property_float_funcs(prop, "rna_Gizmo_alpha_hi_get", "rna_Gizmo_alpha_hi_set", NULL);
1120   RNA_def_property_range(prop, 0.0f, 1.0f);
1121   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1122
1123   prop = RNA_def_property(srna, "matrix_space", PROP_FLOAT, PROP_MATRIX);
1124   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1125   RNA_def_property_ui_text(prop, "Space Matrix", "");
1126   RNA_def_property_float_funcs(
1127       prop, "rna_Gizmo_matrix_space_get", "rna_Gizmo_matrix_space_set", NULL);
1128   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1129
1130   prop = RNA_def_property(srna, "matrix_basis", PROP_FLOAT, PROP_MATRIX);
1131   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1132   RNA_def_property_ui_text(prop, "Basis Matrix", "");
1133   RNA_def_property_float_funcs(
1134       prop, "rna_Gizmo_matrix_basis_get", "rna_Gizmo_matrix_basis_set", NULL);
1135   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1136
1137   prop = RNA_def_property(srna, "matrix_offset", PROP_FLOAT, PROP_MATRIX);
1138   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1139   RNA_def_property_ui_text(prop, "Offset Matrix", "");
1140   RNA_def_property_float_funcs(
1141       prop, "rna_Gizmo_matrix_offset_get", "rna_Gizmo_matrix_offset_set", NULL);
1142   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1143
1144   prop = RNA_def_property(srna, "matrix_world", PROP_FLOAT, PROP_MATRIX);
1145   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1146   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1147   RNA_def_property_ui_text(prop, "Final World Matrix", "");
1148   RNA_def_property_float_funcs(prop, "rna_Gizmo_matrix_world_get", NULL, NULL);
1149
1150   prop = RNA_def_property(srna, "scale_basis", PROP_FLOAT, PROP_NONE);
1151   RNA_def_property_ui_text(prop, "Scale Basis", "");
1152   RNA_def_property_float_funcs(
1153       prop, "rna_Gizmo_scale_basis_get", "rna_Gizmo_scale_basis_set", NULL);
1154   RNA_def_property_range(prop, 0.0f, FLT_MAX);
1155   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1156
1157   prop = RNA_def_property(srna, "line_width", PROP_FLOAT, PROP_PIXEL);
1158   RNA_def_property_ui_text(prop, "Line Width", "");
1159   RNA_def_property_float_funcs(prop, "rna_Gizmo_line_width_get", "rna_Gizmo_line_width_set", NULL);
1160   RNA_def_property_range(prop, 0.0f, FLT_MAX);
1161   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1162
1163   prop = RNA_def_property(srna, "select_bias", PROP_FLOAT, PROP_NONE);
1164   RNA_def_property_ui_text(prop, "Select Bias", "Depth bias used for selection");
1165   RNA_def_property_float_funcs(
1166       prop, "rna_Gizmo_select_bias_get", "rna_Gizmo_select_bias_set", NULL);
1167   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1168
1169   /* wmGizmo.flag */
1170   /* WM_GIZMO_HIDDEN */
1171   prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1172   RNA_def_property_boolean_funcs(prop, "rna_Gizmo_flag_hide_get", "rna_Gizmo_flag_hide_set");
1173   RNA_def_property_ui_text(prop, "Hide", "");
1174   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1175   /* WM_GIZMO_HIDDEN_SELECT */
1176   prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
1177   RNA_def_property_boolean_funcs(
1178       prop, "rna_Gizmo_flag_hide_select_get", "rna_Gizmo_flag_hide_select_set");
1179   RNA_def_property_ui_text(prop, "Hide Select", "");
1180   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1181   /* WM_GIZMO_MOVE_CURSOR */
1182   prop = RNA_def_property(srna, "use_grab_cursor", PROP_BOOLEAN, PROP_NONE);
1183   RNA_def_property_boolean_funcs(
1184       prop, "rna_Gizmo_flag_use_grab_cursor_get", "rna_Gizmo_flag_use_grab_cursor_set");
1185   RNA_def_property_ui_text(prop, "Grab Cursor", "");
1186   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1187
1188   /* WM_GIZMO_DRAW_HOVER */
1189   prop = RNA_def_property(srna, "use_draw_hover", PROP_BOOLEAN, PROP_NONE);
1190   RNA_def_property_boolean_funcs(
1191       prop, "rna_Gizmo_flag_use_draw_hover_get", "rna_Gizmo_flag_use_draw_hover_set");
1192   RNA_def_property_ui_text(prop, "Draw Hover", "");
1193   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1194   /* WM_GIZMO_DRAW_MODAL */
1195   prop = RNA_def_property(srna, "use_draw_modal", PROP_BOOLEAN, PROP_NONE);
1196   RNA_def_property_boolean_funcs(
1197       prop, "rna_Gizmo_flag_use_draw_modal_get", "rna_Gizmo_flag_use_draw_modal_set");
1198   RNA_def_property_ui_text(prop, "Draw Active", "Draw while dragging");
1199   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1200   /* WM_GIZMO_DRAW_VALUE */
1201   prop = RNA_def_property(srna, "use_draw_value", PROP_BOOLEAN, PROP_NONE);
1202   RNA_def_property_boolean_funcs(
1203       prop, "rna_Gizmo_flag_use_draw_value_get", "rna_Gizmo_flag_use_draw_value_set");
1204   RNA_def_property_ui_text(
1205       prop, "Draw Value", "Show an indicator for the current value while dragging");
1206   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1207   /* WM_GIZMO_DRAW_OFFSET_SCALE */
1208   prop = RNA_def_property(srna, "use_draw_offset_scale", PROP_BOOLEAN, PROP_NONE);
1209   RNA_def_property_boolean_funcs(prop,
1210                                  "rna_Gizmo_flag_use_draw_offset_scale_get",
1211                                  "rna_Gizmo_flag_use_draw_offset_scale_set");
1212   RNA_def_property_ui_text(
1213       prop, "Scale Offset", "Scale the offset matrix (use to apply screen-space offset)");
1214   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1215   /* WM_GIZMO_DRAW_NO_SCALE (negated) */
1216   prop = RNA_def_property(srna, "use_draw_scale", PROP_BOOLEAN, PROP_NONE);
1217   RNA_def_property_boolean_funcs(
1218       prop, "rna_Gizmo_flag_use_draw_scale_get", "rna_Gizmo_flag_use_draw_scale_set");
1219   RNA_def_property_ui_text(prop, "Scale", "Use scale when calculating the matrix");
1220   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1221   /* WM_GIZMO_SELECT_BACKGROUND */
1222   prop = RNA_def_property(srna, "use_select_background", PROP_BOOLEAN, PROP_NONE);
1223   RNA_def_property_boolean_funcs(prop,
1224                                  "rna_Gizmo_flag_use_select_background_get",
1225                                  "rna_Gizmo_flag_use_select_background_set");
1226   RNA_def_property_ui_text(prop, "Select Background", "Don't write into the depth buffer");
1227   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1228
1229   /* WM_GIZMO_OPERATOR_TOOL_INIT */
1230   prop = RNA_def_property(srna, "use_operator_tool_properties", PROP_BOOLEAN, PROP_NONE);
1231   RNA_def_property_boolean_funcs(prop,
1232                                  "rna_Gizmo_flag_use_operator_tool_properties_get",
1233                                  "rna_Gizmo_flag_use_operator_tool_properties_set");
1234   RNA_def_property_ui_text(
1235       prop,
1236       "Tool Property Init",
1237       "Merge active tool properties on activation (does not overwrite existing)");
1238   RNA_def_property_update(prop, NC_SCREEN | NA_EDITED, NULL);
1239
1240   /* wmGizmo.state (readonly) */
1241   /* WM_GIZMO_STATE_HIGHLIGHT */
1242   prop = RNA_def_property(srna, "is_highlight", PROP_BOOLEAN, PROP_NONE);
1243   RNA_def_property_boolean_funcs(prop, "rna_Gizmo_state_is_highlight_get", NULL);
1244   RNA_def_property_ui_text(prop, "Highlight", "");
1245   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1246   /* WM_GIZMO_STATE_MODAL */
1247   prop = RNA_def_property(srna, "is_modal", PROP_BOOLEAN, PROP_NONE);
1248   RNA_def_property_boolean_funcs(prop, "rna_Gizmo_state_is_modal_get", NULL);
1249   RNA_def_property_ui_text(prop, "Highlight", "");
1250   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1251   /* WM_GIZMO_STATE_SELECT */
1252   /* (note that setting is involved, needs to handle array) */
1253   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1254   RNA_def_property_boolean_funcs(prop, "rna_Gizmo_state_select_get", "rna_Gizmo_state_select_set");
1255   RNA_def_property_ui_text(prop, "Select", "");
1256
1257   RNA_api_gizmo(srna);
1258
1259   srna = RNA_def_struct(brna, "GizmoProperties", NULL);
1260   RNA_def_struct_ui_text(srna, "Gizmo Properties", "Input properties of an Gizmo");
1261   RNA_def_struct_refine_func(srna, "rna_GizmoProperties_refine");
1262   RNA_def_struct_idprops_func(srna, "rna_GizmoProperties_idprops");
1263   RNA_def_struct_flag(srna, STRUCT_NO_DATABLOCK_IDPROPERTIES);
1264 }
1265
1266 static void rna_def_gizmogroup(BlenderRNA *brna)
1267 {
1268   StructRNA *srna;
1269   PropertyRNA *prop;
1270
1271   FunctionRNA *func;
1272   PropertyRNA *parm;
1273
1274   srna = RNA_def_struct(brna, "GizmoGroup", NULL);
1275   RNA_def_struct_ui_text(
1276       srna, "GizmoGroup", "Storage of an operator being executed, or registered after execution");
1277   RNA_def_struct_sdna(srna, "wmGizmoGroup");
1278   RNA_def_struct_refine_func(srna, "rna_GizmoGroup_refine");
1279 #  ifdef WITH_PYTHON
1280   RNA_def_struct_register_funcs(
1281       srna, "rna_GizmoGroup_register", "rna_GizmoGroup_unregister", "rna_GizmoGroup_instance");
1282 #  endif
1283   RNA_def_struct_translation_context(srna, BLT_I18NCONTEXT_OPERATOR_DEFAULT);
1284
1285   /* -------------------------------------------------------------------- */
1286   /* Registration */
1287
1288   RNA_define_verify_sdna(0); /* not in sdna */
1289
1290   prop = RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
1291   RNA_def_property_string_sdna(prop, NULL, "type->idname");
1292   RNA_def_property_string_maxlength(prop, MAX_NAME);
1293   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GizmoGroup_bl_idname_set");
1294   RNA_def_property_flag(prop, PROP_REGISTER);
1295   RNA_def_struct_name_property(srna, prop);
1296
1297   prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
1298   RNA_def_property_string_sdna(prop, NULL, "type->name");
1299   RNA_def_property_string_maxlength(prop, MAX_NAME); /* else it uses the pointer size! */
1300   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GizmoGroup_bl_label_set");
1301   /* RNA_def_property_clear_flag(prop, PROP_EDITABLE); */
1302   RNA_def_property_flag(prop, PROP_REGISTER);
1303
1304   prop = RNA_def_property(srna, "bl_space_type", PROP_ENUM, PROP_NONE);
1305   RNA_def_property_enum_sdna(prop, NULL, "type->gzmap_params.spaceid");
1306   RNA_def_property_enum_items(prop, rna_enum_space_type_items);
1307   RNA_def_property_flag(prop, PROP_REGISTER);
1308   RNA_def_property_ui_text(prop, "Space type", "The space where the panel is going to be used in");
1309
1310   prop = RNA_def_property(srna, "bl_region_type", PROP_ENUM, PROP_NONE);
1311   RNA_def_property_enum_sdna(prop, NULL, "type->gzmap_params.regionid");
1312   RNA_def_property_enum_items(prop, rna_enum_region_type_items);
1313   RNA_def_property_flag(prop, PROP_REGISTER);
1314   RNA_def_property_ui_text(
1315       prop, "Region Type", "The region where the panel is going to be used in");
1316
1317   prop = RNA_def_property(srna, "bl_owner_id", PROP_STRING, PROP_NONE);
1318   RNA_def_property_string_sdna(prop, NULL, "type->owner_id");
1319   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
1320
1321   /* bl_options */
1322   static EnumPropertyItem gizmogroup_flag_items[] = {
1323       {WM_GIZMOGROUPTYPE_3D, "3D", 0, "3D", "Use in 3D viewport"},
1324       {WM_GIZMOGROUPTYPE_SCALE,
1325        "SCALE",
1326        0,
1327        "Scale",
1328        "Scale to respect zoom (otherwise zoom independent draw size)"},
1329       {WM_GIZMOGROUPTYPE_DEPTH_3D,
1330        "DEPTH_3D",
1331        0,
1332        "Depth 3D",
1333        "Supports culled depth by other objects in the view"},
1334       {WM_GIZMOGROUPTYPE_SELECT, "SELECT", 0, "Select", "Supports selection"},
1335       {WM_GIZMOGROUPTYPE_PERSISTENT, "PERSISTENT", 0, "Persistent", ""},
1336       {WM_GIZMOGROUPTYPE_DRAW_MODAL_ALL,
1337        "SHOW_MODAL_ALL",
1338        0,
1339        "Show Modal All",
1340        "Show all while interacting"},
1341       {WM_GIZMOGROUPTYPE_TOOL_INIT,
1342        "TOOL_INIT",
1343        0,
1344        "Tool Init",
1345        "Postpone running until tool operator run (when used with a tool)"},
1346       {0, NULL, 0, NULL, NULL},
1347   };
1348   prop = RNA_def_property(srna, "bl_options", PROP_ENUM, PROP_NONE);
1349   RNA_def_property_enum_sdna(prop, NULL, "type->flag");
1350   RNA_def_property_enum_items(prop, gizmogroup_flag_items);
1351   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL | PROP_ENUM_FLAG);
1352   RNA_def_property_ui_text(prop, "Options", "Options for this operator type");
1353
1354   RNA_define_verify_sdna(1); /* not in sdna */
1355
1356   /* Functions */
1357
1358   /* poll */
1359   func = RNA_def_function(srna, "poll", NULL);
1360   RNA_def_function_ui_description(func, "Test if the gizmo group can be called or not");
1361   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
1362   RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
1363   parm = RNA_def_pointer(func, "context", "Context", "", "");
1364   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1365
1366   /* setup_keymap */
1367   func = RNA_def_function(srna, "setup_keymap", NULL);
1368   RNA_def_function_ui_description(
1369       func, "Initialize keymaps for this gizmo group, use fallback keymap when not present");
1370   RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_REGISTER_OPTIONAL);
1371   parm = RNA_def_pointer(func, "keyconfig", "KeyConfig", "", "");
1372   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1373   /* return */
1374   parm = RNA_def_pointer(func, "keymap", "KeyMap", "", "");
1375   RNA_def_property_flag(parm, PROP_NEVER_NULL);
1376   RNA_def_function_return(func, parm);
1377
1378   /* setup */
1379   func = RNA_def_function(srna, "setup", NULL);
1380   RNA_def_function_ui_description(func, "Create gizmos function for the gizmo group");
1381   RNA_def_function_flag(func, FUNC_REGISTER);
1382   parm = RNA_def_pointer(func, "context", "Context", "", "");
1383   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1384
1385   /* refresh */
1386   func = RNA_def_function(srna, "refresh", NULL);
1387   RNA_def_function_ui_description(
1388       func, "Refresh data (called on common state changes such as selection)");
1389   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
1390   parm = RNA_def_pointer(func, "context", "Context", "", "");
1391   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1392
1393   func = RNA_def_function(srna, "draw_prepare", NULL);
1394   RNA_def_function_ui_description(func, "Run before each redraw");
1395   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
1396   parm = RNA_def_pointer(func, "context", "Context", "", "");
1397   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1398
1399   func = RNA_def_function(srna, "invoke_prepare", NULL);
1400   RNA_def_function_ui_description(func, "Run before invoke");
1401   RNA_def_function_flag(func, FUNC_REGISTER_OPTIONAL);
1402   parm = RNA_def_pointer(func, "context", "Context", "", "");
1403   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1404   parm = RNA_def_pointer(func, "gizmo", "Gizmo", "", "");
1405   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1406
1407   /* -------------------------------------------------------------------- */
1408   /* Instance Variables */
1409
1410   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1411   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1412   RNA_def_property_string_funcs(
1413       prop, "rna_GizmoGroup_name_get", "rna_GizmoGroup_name_length", NULL);
1414   RNA_def_property_ui_text(prop, "Name", "");
1415
1416   prop = RNA_def_property(srna, "has_reports", PROP_BOOLEAN, PROP_NONE);
1417   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* this is 'virtual' property */
1418   RNA_def_property_boolean_funcs(prop, "rna_GizmoGroup_has_reports_get", NULL);
1419   RNA_def_property_ui_text(
1420       prop,
1421       "Has Reports",
1422       "GizmoGroup has a set of reports (warnings and errors) from last execution");
1423
1424   RNA_define_verify_sdna(0); /* not in sdna */
1425
1426   prop = RNA_def_property(srna, "gizmos", PROP_COLLECTION, PROP_NONE);
1427   RNA_def_property_collection_sdna(prop, NULL, "gizmos", NULL);
1428   RNA_def_property_struct_type(prop, "Gizmo");
1429   RNA_def_property_collection_funcs(prop,
1430                                     "rna_GizmoGroup_gizmos_begin",
1431                                     "rna_iterator_listbase_next",
1432                                     "rna_iterator_listbase_end",
1433                                     "rna_iterator_listbase_get",
1434                                     NULL,
1435                                     NULL,
1436                                     NULL,
1437                                     NULL);
1438
1439   RNA_def_property_ui_text(prop, "Gizmos", "List of gizmos in the Gizmo Map");
1440   rna_def_gizmo(brna, prop);
1441   rna_def_gizmos(brna, prop);
1442
1443   RNA_define_verify_sdna(1); /* not in sdna */
1444
1445   RNA_api_gizmogroup(srna);
1446
1447   srna = RNA_def_struct(brna, "GizmoGroupProperties", NULL);
1448   RNA_def_struct_ui_text(srna, "Gizmo Group Properties", "Input properties of a Gizmo Group");
1449   RNA_def_struct_refine_func(srna, "rna_GizmoGroupProperties_refine");
1450   RNA_def_struct_idprops_func(srna, "rna_GizmoGroupProperties_idprops");
1451   RNA_def_struct_flag(srna, STRUCT_NO_DATABLOCK_IDPROPERTIES);
1452 }
1453
1454 void RNA_def_wm_gizmo(BlenderRNA *brna)
1455 {
1456   rna_def_gizmogroup(brna);
1457 }
1458
1459 #endif /* RNA_RUNTIME */